@arkade-os/swap 0.0.12 → 0.1.0-rc.1

package/dist/index.d.cts

@@ -1,9 +1,9 @@
-import { ProvisionedKey, ProvisionedClaimSecret, asset, RelativeTimelock, IWallet, arkade, RestIndexerProvider, Transaction, IContractManager, OnchainProvider, PaymentRail, VHTLC, Identity, ActivityResolver } from '@arkade-os/sdk';
-import { S as SwapSecretsProjection, R as RfqSwapRecord, A as AssetSwapRepository, a as AssetSwap, M as MarketsCacheEntry, b as RefundArkProvider, c as RefundIndexer, L as LockupVtxo, d as RfqSwap, e as ArkadeRefundResult, f as LockupSpendIndexer, g as RfqSwapState } from './repository-DaK1RzRq.cjs';
-export { h as AssetSwapStatus, i as AvailableRfqSwapManagerCallbacks, B as BTC_ASSET_ID, I as InMemoryAssetSwapRepository, j as LightningReceiveSwap, k as LightningSendSwap, l as LockupFate, m as LockupNeedsRecoveryError, n as LockupParams, o as LockupSpend, O as OnchainSendAction, p as OnchainSendSwap, P as PersistableRfqSwap, q as PreimageBlockedReason, r as PreimageNotRecoverableError, s as REFUND_MTP_LAG_SECONDS, t as RFQ_RESOLVED_STATES, u as RFQ_SWAP_RETENTION_SECONDS, v as RFQ_SWAP_TERMINAL_STATES, w as RefundOutcome, x as RfqRestoreFailure, y as RfqRestoreOptions, z as RfqRestoreResult, C as RfqSwapActionName, D as RfqSwapLockup, E as RfqSwapManager, F as RfqSwapManagerCallbacks, G as RfqSwapManagerConfig, H as RfqSwapManagerDeps, J as RfqSwapManagerEvents, K as RfqSwapOrigin, N as RfqSwapOriginRequired, Q as RfqSwapOutcome, T as RfqSwapRecordStore, U as SwapContractRegistry, V as addAssetSwap, W as awaitRfqResolution, X as createRfqSwapRecord, Y as findLockupVtxos, Z as getAssetSwaps, _ as getAssetSwapsOrThrow, $ as isRfqSwapTerminal, a0 as isRfqTerminal, a1 as nextOnchainAction, a2 as preimageForSwapRecord, a3 as pushRefundWithoutReceiver, a4 as readLockupFate, a5 as rebuildRfqSwap, a6 as refundIfUnresolved, a7 as rfqSwapOriginOf, a8 as shouldRetainRfqSwap, a9 as swapSecretsToRecord, aa as updateAssetSwap, ab as updateAssetSwapBestEffort, ac as updateRfqSwapRecord } from './repository-DaK1RzRq.cjs';
+import { ProvisionedKey, ProvisionedClaimSecret, asset, RelativeTimelock, IWallet, arkade, RestIndexerProvider, Transaction, IContractManager, OnchainProvider, PaymentRail, PaymentHandle, RouterPreferences, Wallet, PaymentRouter, PaymentStatus, VHTLC, Identity, ActivityResolver } from '@arkade-os/sdk';
+import { S as SwapSecretsProjection, R as RfqSwapRecord, A as AssetSwapRepository, a as AssetSwap, b as SwapRecord, M as MarketsCacheEntry, c as AssetSwapStatus, O as Outcome, d as Swap, Q as QuoteInput, e as RouteResolution, f as Quote, g as SwapUpdate, U as Unsubscribe, h as RefundIndexer, L as LockupVtxo, i as SwapOperator, j as RfqSwap, k as ArkadeRefundResult, l as LockupSpendIndexer, m as RfqSwapState, n as RfqSwapManager, o as RfqSwapManagerCallbacks } from './repository-oeW8KZo1.cjs';
+export { p as AvailableRfqSwapManagerCallbacks, B as BTC_ASSET_ID, I as InMemoryAssetSwapRepository, q as LightningReceiveSwap, r as LightningSendSwap, s as LockupFate, t as LockupNeedsRecoveryError, u as LockupParams, v as LockupSpend, w as OnchainSendAction, x as OnchainSendSwap, P as PersistableRfqSwap, y as PreimageBlockedReason, z as PreimageNotRecoverableError, C as REFUND_MTP_LAG_SECONDS, D as RFQ_RESOLVED_STATES, E as RFQ_SWAP_RETENTION_SECONDS, F as RFQ_SWAP_TERMINAL_STATES, G as RefundOutcome, H as RfqRestoreFailure, J as RfqRestoreOptions, K as RfqRestoreResult, N as RfqSwapActionName, T as RfqSwapLockup, V as RfqSwapManagerConfig, W as RfqSwapManagerDeps, X as RfqSwapManagerEvents, Y as RfqSwapOrigin, Z as RfqSwapOriginRequired, _ as RfqSwapOutcome, $ as RfqSwapRecordStore, a0 as SwapContractRegistry, a1 as addAssetSwap, a2 as awaitRfqResolution, a3 as createRfqSwapRecord, a4 as findLockupVtxos, a5 as getAssetSwaps, a6 as getAssetSwapsOrThrow, a7 as isRfqSwapTerminal, a8 as isRfqTerminal, a9 as nextOnchainAction, aa as normalizeRfqSwapRecord, ab as preimageForSwapRecord, ac as pushRefundWithoutReceiver, ad as readLockupFate, ae as rebuildRfqSwap, af as refundIfUnresolved, ag as rfqSwapOriginOf, ah as shouldRetainRfqSwap, ai as swapSecretsToRecord, aj as updateAssetSwap, ak as updateAssetSwapBestEffort, al as updateRfqSwapRecord } from './repository-oeW8KZo1.cjs';
 import { Network, LocalCardInput, DiscoveredMarket, Side, OfferPlan } from '@arkade-os/solver-discovery';
-import { O as OnchainNetwork, a as OnchainHtlc, b as OnchainHtlcParams, C as ChainSource, R as RfqTransport, r as requestOnchainSend, I as InvoiceFacts, c as requestLightningSend } from './rfq-DzsmhXX3.cjs';
-export { A as ARKADE_ASSET, d as ARKADE_BTC, e as AddressMismatch, f as ChainUtxo, H as HtlcUtxo, L as LIGHTNING_BTC, g as LIGHTNING_RECEIVE_PAIR, h as LIGHTNING_SEND_PAIR, i as LOCKTIME_THRESHOLD, j as LightningReceiveTreeParams, k as LightningSendTreeParams, M as MAX_MIN_CONFIRMATIONS, l as MIN_CLAIM_WINDOW_SECONDS, m as MIN_HEADROOM_SECONDS, n as ONCHAIN_BTC, o as ONCHAIN_CLAIM_MARGIN_SECONDS, p as ONCHAIN_DUST_SATS, q as ONCHAIN_ORDER_MARGIN_SECONDS, s as ONCHAIN_RECEIVE_PAIR, t as ONCHAIN_SECONDS_PER_BLOCK, u as ONCHAIN_SEND_PAIR, v as OnchainHtlcPhase, w as RFQ_TERMINAL_STATES, x as RelaySocket, y as RfqQuote, z as RfqRefusalReason, B as RfqStatus, S as SOLO_REFUND_HEADROOM_SECONDS, D as SwapRefusal, E as arkadeAssetLeg, F as arkadeSwapRequest, G as assertFundable, J as assertReceivable, K as awaitOnchainFill, N as buildHtlcClaim, P as buildHtlcRefund, Q as claimOnchainFill, T as classifyOnchainHtlc, U as deriveLightningReceive, V as deriveOnchainReceive, W as deriveOnchainSend, X as extractPreimage, Y as httpTransport, Z as l1ScriptForAddress, _ as lightningReceiveRequest, $ as lightningSendRequest, a0 as lightningSendVtxoScript, a1 as newPreimage, a2 as newRfqId, a3 as offerTermsFromQuote, a4 as onchainHtlcScript, a5 as onchainReceiveRequest, a6 as onchainSendRequest, a7 as paymentHashOf, a8 as receiveVtxoScript, a9 as relayTransport, aa as requestLightningReceive, ab as requestOnchainReceive, ac as rfqPair, ad as unilateralClaimDelay, ae as unilateralRefundDelay, af as unilateralRefundWithoutReceiverDelay, ag as verifyLockupAddress, ah as verifyReceiveInvoice } from './rfq-DzsmhXX3.cjs';
+import { O as OnchainNetwork, a as OnchainHtlc, b as OnchainHtlcParams, C as ChainSource, R as RfqTransport, r as requestOnchainSend, I as InvoiceFacts, c as requestLightningSend, d as requestLightningReceive } from './rfq-D0KGjmnn.cjs';
+export { A as ARKADE_ASSET, e as ARKADE_BTC, f as AddressMismatch, g as ChainUtxo, H as HtlcUtxo, L as LIGHTNING_BTC, h as LIGHTNING_RECEIVE_PAIR, i as LIGHTNING_SEND_PAIR, j as LOCKTIME_THRESHOLD, k as LightningReceiveContractParams, l as LightningSendContractParams, M as MAX_MIN_CONFIRMATIONS, m as MIN_CLAIM_WINDOW_SECONDS, n as MIN_HEADROOM_SECONDS, o as ONCHAIN_BTC, p as ONCHAIN_CLAIM_MARGIN_SECONDS, q as ONCHAIN_DUST_SATS, s as ONCHAIN_ORDER_MARGIN_SECONDS, t as ONCHAIN_RECEIVE_PAIR, u as ONCHAIN_SECONDS_PER_BLOCK, v as ONCHAIN_SEND_PAIR, w as OnchainHtlcPhase, x as RFQ_TERMINAL_STATES, y as RelaySocket, z as RfqQuote, B as RfqRefusalReason, D as RfqStatus, S as SOLO_REFUND_HEADROOM_SECONDS, E as SwapRefusal, F as arkadeAssetLeg, G as arkadeSwapRequest, J as assertFundable, K as assertReceivable, N as awaitOnchainFill, P as buildHtlcClaim, Q as buildHtlcRefund, T as claimOnchainFill, U as classifyOnchainHtlc, V as deriveLightningReceive, W as deriveOnchainReceive, X as deriveOnchainSend, Y as extractPreimage, Z as httpTransport, _ as l1ScriptForAddress, $ as lightningReceiveContract, a0 as lightningReceiveRequest, a1 as lightningSendContract, a2 as lightningSendRequest, a3 as newPreimage, a4 as newRfqId, a5 as offerTermsFromQuote, a6 as onchainHtlcScript, a7 as onchainReceiveRequest, a8 as onchainSendRequest, a9 as paymentHashOf, aa as relayTransport, ab as requestOnchainReceive, ac as rfqPair, ad as unilateralClaimDelay, ae as unilateralRefundDelay, af as unilateralRefundWithoutReceiverDelay, ag as verifyLockupAddress, ah as verifyReceiveInvoice } from './rfq-D0KGjmnn.cjs';
 
 /**
  * Which wallet key signs this leg. Stored at `profile.signer`.
@@ -111,7 +111,7 @@ interface LightningReceiveProfile extends Record<string, unknown> {
      * preimage that is already public, and a swap that did claim is relabelled
      * `needs_counterparty` once its window shuts.
      */
-    claimArkTxid?: string;
+    claimTxid?: string;
 }
 /** `arkade:BTC->onchain:BTC`. */
 interface OnchainSendProfile extends Record<string, unknown> {
@@ -228,7 +228,7 @@ interface Offer {
     exitDelay?: RelativeTimelock;
 }
 /** Compile the offer's contract: program + args -> taproot tree. */
-declare function offerVtxoScript(offer: Omit<Offer, "swapPkScript">, serverPubkey: Uint8Array): InstanceType<typeof arkade.ArkadeProgramScript>;
+declare function offerContract(offer: Omit<Offer, "swapPkScript">, operatorPubkey: Uint8Array): InstanceType<typeof arkade.ArkadeProgramScript>;
 /** Extension packet type tag for Arkade Intents offers. */
 declare const OFFER_PACKET_TYPE = 3;
 /** Serialize an offer to TLV bytes (the packet payload). */
@@ -240,11 +240,11 @@ declare function decodeOffer(data: Uint8Array): Offer;
  * you deposit, embedding the returned extension, and the solver does the rest:
  *
  *   // BTC -> asset
- *   const o = await createOffer(wallet, ARK, { wantAmount: 1000n, wantAsset })
+ *   const o = await createOffer(wallet, { wantAmount: 1000n, wantAsset })
  *   await wallet.send({ address: o.address, amount: 1000, extensions: [o.extension] })
  *
  *   // asset -> BTC (the sats are the VTXO carrier for the asset)
- *   const o = await createOffer(wallet, ARK, { wantAmount: 1000n, offerAsset })
+ *   const o = await createOffer(wallet, { wantAmount: 1000n, offerAsset })
  *   await wallet.send({ address: o.address, amount: 500,
  *                       assets: [{ assetId, amount: 1000n }],
  *                       extensions: [o.extension] })
@@ -265,7 +265,7 @@ declare function decodeOffer(data: Uint8Array): Offer;
  * so that exposure has no end. `noExit` opts out for a caller who wants the
  * smaller tree and accepts the dependency.
  */
-declare function createOffer(wallet: IWallet, arkServerUrl: string, params: {
+declare function createOffer(wallet: IWallet, params: {
     wantAmount: bigint;
     wantAsset?: asset.AssetId;
     offerAsset?: asset.AssetId;
@@ -332,8 +332,8 @@ declare function createOffer(wallet: IWallet, arkServerUrl: string, params: {
  * Identical offers derive the same address, so `fundingTxid` selects the exact
  * deposit; without it the address must hold exactly one spendable VTXO — with
  * several, cancel refuses to guess and throws.
- * `swapAddress` (the funded address) pins the server key the covenant was
- * built with, so cancel keeps working across a server signer rotation; without
+ * `swapAddress` (the funded address) pins the operator key the covenant was
+ * built with, so cancel keeps working across an operator signer rotation; without
  * it a rotated key is detected and reported rather than reading as a missing
  * VTXO.
  *
@@ -354,12 +354,44 @@ declare function createOffer(wallet: IWallet, arkServerUrl: string, params: {
  * returns, so a spend event that arrives in that window finds a `cancelling`
  * record and classifies the spend by its covenant leaf instead — the same
  * answer, one indexer read more.
+ *
+ * Takes no server URL, like every other entrypoint here: broadcast comes from
+ * `wallet.getArkadeBroadcaster()` and the indexer fallback from
+ * `wallet.getArkadeReader()`, so the wallet's own connection is the only one
+ * used (#734).
  */
-declare function cancelOffer(wallet: IWallet, arkServerUrl: string, offerHex: string, opts: {
+declare function cancelOffer(wallet: IWallet, offerHex: string, opts: {
     repository: AssetSwapRepository;
     fundingTxid?: string;
     swapAddress?: string;
 }): Promise<string>;
+/**
+ * No deposit left to cancel at the swap address.
+ *
+ * Almost always the fill winning the race — v1's documented
+ * throw-means-completed trap, which the v2 client's `cancel()` reconciles
+ * against the covenant's leaves instead of surfacing (see `client/cancel.ts`).
+ * Typed so that reconciliation is an `instanceof`, not a message match; the
+ * message is v1's, unchanged.
+ */
+declare class NoSpendableDepositError extends Error {
+    readonly name = "NoSpendableDepositError";
+    constructor(options?: ErrorOptions);
+}
+/**
+ * The rebuilt covenant disagrees with the offer's own `swapPkScript`: the
+ * operator key the rebuild pinned is not the one the covenant was funded with.
+ *
+ * v1's fallback read this as a missing VTXO; with a pinned `swapAddress` the
+ * only remaining causes are a record corrupted or a `swapAddress` that is not
+ * the one funded — so the condition is typed rather than left to surface raw.
+ * Fires before any broadcast, where §7's law still governs.
+ */
+declare class OfferCovenantMismatchError extends Error {
+    readonly swapPkScript: string;
+    readonly name = "OfferCovenantMismatchError";
+    constructor(swapPkScript: string, options?: ErrorOptions);
+}
 
 /**
  * Quoting: solver discovery and the pricing guardrails around a plan.
@@ -434,10 +466,9 @@ type PlanError = "insufficient-balance" | "side-disabled" | "below-min" | "above
 /** Validate a plan against the user's balance and the server dust limit. */
 declare const validatePlan: (plan: OfferPlan, giveBalance: bigint, dust: bigint) => PlanError | undefined;
 
-/** Browser backend over the SDK's shared IndexedDB manager — the same
- * infrastructure the wallet already uses for its Boltz swap repository. */
+/** Browser backend over the SDK's shared IndexedDB manager. */
 declare class IndexedDbAssetSwapRepository implements AssetSwapRepository {
-    readonly version: 4;
+    readonly version: 5;
     private readonly connection;
     constructor(dbName?: string);
     private ensureDb;
@@ -452,6 +483,10 @@ declare class IndexedDbAssetSwapRepository implements AssetSwapRepository {
     getRfqSwap(rfqId: string): Promise<RfqSwapRecord | undefined>;
     getAllRfqSwaps(): Promise<RfqSwapRecord[]>;
     removeRfqSwap(rfqId: string): Promise<void>;
+    saveSwapRecord(record: SwapRecord): Promise<void>;
+    getSwapRecord(id: string): Promise<SwapRecord | undefined>;
+    getAllSwapRecords(): Promise<SwapRecord[]>;
+    removeSwapRecord(id: string): Promise<void>;
     getScannedTxids(): Promise<Set<string>>;
     markTxidsScanned(txids: Iterable<string>): Promise<void>;
     getCachedMarkets(network: string, registry: string): Promise<MarketsCacheEntry | undefined>;
@@ -524,12 +559,12 @@ type SpendKind = "cancelled" | "fulfilled" | "indeterminate";
  * and they also survive batching: a solver filling several offers in one tx
  * gives each input its own leaf.
  *
- * `serverPubkey` must be the key the covenant was *funded* against. If it has
+ * `operatorPubkey` must be the key the covenant was *funded* against. If it has
  * rotated since, the rebuilt script will not match the offer's own
  * `swapPkScript` and this returns `indeterminate` rather than guessing —
  * `cancelOffer` diagnoses the same mismatch the same way.
  */
-declare function classifySpend(offer: Offer, serverPubkey: Uint8Array, spendTx: Transaction, deposit: {
+declare function classifySpend(offer: Offer, operatorPubkey: Uint8Array, spendTx: Transaction, deposit: {
     txid: string;
     vout: number;
 }): SpendKind;
@@ -550,7 +585,7 @@ declare const spendTxidsOf: (vtxo: {
  * settlement they may be the same id. Try each and take the first definite
  * answer, so the classification does not depend on that distinction.
  */
-declare function classifyDepositSpend(offer: Offer, serverPubkey: Uint8Array, spendTxs: Iterable<Transaction>, deposit: {
+declare function classifyDepositSpend(offer: Offer, operatorPubkey: Uint8Array, spendTxs: Iterable<Transaction>, deposit: {
     txid: string;
     vout: number;
 }): SpendKind;
@@ -575,18 +610,65 @@ declare function classifyDepositSpend(offer: Offer, serverPubkey: Uint8Array, sp
  * does, so the `existingIds` escape hatch is no longer a correction mechanism
  * for a wrong label — it is only a skip list.
  *
- * `serverPubkey` must be the server key the covenants were funded against; a
+ * `operatorPubkey` must be the operator key the covenants were funded against; a
  * key that has rotated since makes every affected swap unclassifiable rather
  * than misclassified.
  */
 declare function restoreAssetSwaps(indexer: RestoreIndexer, txs: Tx[], existingIds: ReadonlySet<string>, opts: {
-    serverPubkey: Uint8Array;
+    operatorPubkey: Uint8Array;
     scanned?: ReadonlySet<string>;
 }): Promise<{
     restored: AssetSwap[];
     scannedTxids: string[];
 }>;
 
+/**
+ * What this watcher needs to know about an offer swap.
+ *
+ * Structural, and narrower than {@link AssetSwap}, because two record families
+ * now answer the same question. v1 keys its records on the funding txid — the
+ * deposit IS the identity, so no record can exist before the money does — while
+ * the v2 client keys on the quote id and writes the record BEFORE funding, with
+ * `fundingTxid` a later best-effort write. Projecting the second onto the first
+ * is impossible for the whole pre-funding window, so the parameter widens
+ * instead: `id` is whatever key the source stores under, and the spend is
+ * matched on `fundingTxid` and `swapPkScript`, which both families carry.
+ *
+ * `createdAt` is unix **milliseconds**, the unit `coverage.ts` marks issuance
+ * in; see {@link CoveredSwap}.
+ */
+interface OfferSwapFacts {
+    readonly id: string;
+    readonly status: AssetSwapStatus;
+    /** The TLV offer, hex — what {@link classifyDepositSpend} needs. */
+    readonly offerHex: string;
+    readonly swapPkScript: string;
+    readonly fundingTxid?: string;
+    readonly spentTxid?: string;
+    readonly createdAt: number;
+}
+/** The record change a classified spend implies. */
+interface OfferSpendChanges {
+    readonly status: AssetSwapStatus;
+    readonly spentTxid: string;
+    readonly completedAt?: number;
+}
+/**
+ * Where the watcher reads offer records and writes their spends.
+ *
+ * One seam, two implementations: {@link assetSwapSource} over v1's store, and
+ * the v2 client's own over its quote-id-keyed record store. `apply` returns
+ * both halves for the same reason `updateAssetSwapBestEffort` does — a lost
+ * write must not retire a script, and the post-update view is what the liveness
+ * check reads without a third round trip.
+ */
+interface OfferSwapSource<S extends OfferSwapFacts = OfferSwapFacts> {
+    list(): Promise<S[]>;
+    apply(swap: S, changes: OfferSpendChanges): Promise<{
+        persisted: boolean;
+        swaps: S[];
+    }>;
+}
 /**
  * The record change a classified spend implies, or `undefined` when it implies
  * none — an already-resolved swap, or a spend nobody could classify.
@@ -595,25 +677,26 @@ declare function restoreAssetSwaps(indexer: RestoreIndexer, txs: Tx[], existingI
  * taking the watcher, and so re-delivery of an event is a no-op rather than a
  * rewrite.
  */
-declare function spendUpdate(swap: AssetSwap, spend: {
+declare function spendUpdate(swap: Pick<OfferSwapFacts, "status">, spend: {
     txid: string;
     kind: SpendKind;
     at?: number;
-}): Partial<Omit<AssetSwap, "id">> | undefined;
+}): OfferSpendChanges | undefined;
 /** A running watcher. `idle()` exists because the writes are async: shutdown
  * and tests both need to know when in-flight updates have settled. */
 interface OfferSwapWatcher {
     stop(): void;
     idle(): Promise<void>;
 }
-interface WatchOfferSwapsParams {
+interface WatchOfferSwapsParams<S extends OfferSwapFacts = OfferSwapFacts> {
     wallet: IWallet;
-    /** Same URL `createOffer`/`cancelOffer` take; used to read a spending tx
-     * when the exact classifier cannot answer. */
-    arkServerUrl: string;
-    repository: AssetSwapRepository;
+    /** v1's record source. Ignored when {@link source} is given. */
+    repository?: AssetSwapRepository;
+    /** Where records are read and spends written. Defaults to
+     * {@link assetSwapSource} over `repository`. */
+    source?: OfferSwapSource<S>;
     /** Called after a change is persisted. A notification, not a store. */
-    onUpdate?: (swap: AssetSwap) => void;
+    onUpdate?: (swap: S) => void;
 }
 /**
  * Subscribe to the wallet's contract events and drive offer swap status.
@@ -626,7 +709,16 @@ interface WatchOfferSwapsParams {
  * provide an `EventSource` implementation or use a runtime where it is enabled;
  * otherwise live updates do not arrive and restore remains the fallback.
  */
-declare function watchOfferSwaps({ wallet, arkServerUrl, repository, onUpdate, }: WatchOfferSwapsParams): Promise<OfferSwapWatcher>;
+declare function watchOfferSwaps(params: {
+    wallet: IWallet;
+    repository: AssetSwapRepository;
+    onUpdate?: (swap: AssetSwap) => void;
+}): Promise<OfferSwapWatcher>;
+declare function watchOfferSwaps<S extends OfferSwapFacts>(params: {
+    wallet: IWallet;
+    source: OfferSwapSource<S>;
+    onUpdate?: (swap: S) => void;
+}): Promise<OfferSwapWatcher>;
 
 /**
  * Coverage: whether an offer's script is in the wallet's watched set.
@@ -659,6 +751,25 @@ declare function watchOfferSwaps({ wallet, arkServerUrl, repository, onUpdate, }
  * the same backstop every other best-effort step here relies on.
  */
 
+/**
+ * What coverage needs to know about a swap, and nothing else.
+ *
+ * Structural rather than `AssetSwap`, because two record families now ask the
+ * same question: v1's offer swaps and the v2 client's `OfferSwapRecord`s, which
+ * are keyed on a quote id and carry none of `AssetSwap`'s other fields.
+ * Liveness is a property of the status and the funding time, so those are the
+ * whole parameter.
+ *
+ * `createdAt` is unix **milliseconds** — the unit {@link promoteOfferContract}
+ * marks issuance in. A v2 record stores seconds, so its adapter converts;
+ * comparing seconds against a `Date.now()` mark would leave every issued script
+ * outstanding forever and never retire one.
+ */
+interface CoveredSwap {
+    readonly swapPkScript: string;
+    readonly status: AssetSwapStatus;
+    readonly createdAt: number;
+}
 /** The one contract-manager capability changing coverage needs. */
 type OfferContractRetirer = Pick<IContractManager, "setContractWatchState">;
 /**
@@ -669,7 +780,7 @@ type OfferContractRetirer = Pick<IContractManager, "setContractWatchState">;
  * Takes the caller's full record list: liveness is a property of all records at
  * a script, so a partial list would retire a script another record still holds.
  */
-declare function retireSettledOfferContracts(manager: OfferContractRetirer, swaps: AssetSwap[]): Promise<void>;
+declare function retireSettledOfferContracts(manager: OfferContractRetirer, swaps: readonly CoveredSwap[]): Promise<void>;
 
 /** `network` is `requestOnchainSend`'s `l1Network`, and only decodes scripts to
  *  addresses — the provider decides which chain is read, so mismatching the two
@@ -720,7 +831,6 @@ type SolverOnchainSend = Awaited<ReturnType<typeof requestOnchainSend>> & {
     payoutPkScript: Uint8Array;
 };
 interface SolverOnchainRailDeps {
-    arkServerUrl: string;
     l1Network: OnchainNetwork;
     /** x-only L1 key that AUTHORISES the claim — not where it pays. */
     payoutPubkey: Uint8Array;
@@ -759,7 +869,6 @@ type SolverLightningSend = Awaited<ReturnType<typeof requestLightningSend>> & {
 };
 /** Mirrors {@link SolverOnchainRailDeps}; see there for the shared seams. */
 interface SolverLightningRailDeps {
-    arkServerUrl: string;
     /** A decoder that throws drops the rail rather than taking the router
      *  down — correct, since an undecodable invoice cannot be paid. */
     decodeInvoice(bolt11: string): InvoiceFacts;
@@ -776,6 +885,289 @@ interface SolverLightningRailDeps {
 declare const solverLightningRendezvous: (markets: DiscoveredMarket[], amountSats: number, fallbackEmulatorPubkey?: Uint8Array) => SolverRendezvous | undefined;
 declare function solverLightningRail(deps: SolverLightningRailDeps): PaymentRail;
 
+/**
+ * What the two v2 swap rails share: the client seam, the quote arithmetic, and
+ * the handle that observes a swap through core's four-state stream.
+ *
+ * A rail here is a thin adapter and deliberately nothing more. Persistence,
+ * refunds, recovery and the outcome vocabulary all live behind the v2 client;
+ * the rail's whole job is to turn a `PaymentRequest` into a `QuoteInput`, a
+ * `Quote` into a receiver-exact `RouteQuote`, and a swap's outcome stream into
+ * a `PaymentHandle`.
+ *
+ * Two boundaries are crossed here and both are named. Amounts narrow from P3's
+ * `bigint` to core's `number` (see `client/sats.ts`). And a ranking estimate
+ * meets a binding quote: `RouteQuote.fee` is documented as "a display and
+ * ranking figure, not a guarantee" while a v2 `Quote` is verified before return
+ * and expires. `PaymentOption.quote()` is lazy and `options()` never calls it,
+ * so ranking is free — but a swap rail's `quote()` is an RFQ round trip that
+ * discloses an invoice and an amount, and an app that ranks then quotes several
+ * options would disclose to every solver. `available()` therefore **never
+ * quotes**: it resolves, which is network-free against the cached snapshot.
+ *
+ * A held `RouteQuote` can outlive its `Quote` — core's shape carries no
+ * `expiresAt` — and then `send()` throws `QuoteExpired` inside `makeHandle`'s
+ * run, which core turns into a terminal `failed`. That stays: re-quoting inside
+ * `send()` is the silent re-quote §3.2 forbids.
+ */
+
+/**
+ * The slice of `SwapClient` a rail uses.
+ *
+ * Structural and minimal, so what a rail can reach is visible in one place and
+ * a test can stand in for it without a wallet, a repository or a solver behind
+ * it. A full `SwapClient` satisfies it.
+ */
+interface SwapRailClient {
+    resolve(input: QuoteInput): Promise<RouteResolution>;
+    quote(input: QuoteInput): Promise<Quote>;
+    accept(quote: Quote): Promise<Swap>;
+    onUpdate(fn: (update: SwapUpdate) => void): Unsubscribe;
+}
+/**
+ * A payment that ended in something other than success.
+ *
+ * Not a member of §7's taxonomy and suffixed to say so: that taxonomy is thrown
+ * *before* value moves, and this is an outcome reported after it did. It exists
+ * to carry the {@link Outcome} onto the handle's terminal `error`, which is
+ * where `refunded` and `lapsed` stay distinguishable after the four-state
+ * projection has mapped both to `failed`.
+ */
+declare class SwapPaymentFailedError extends Error {
+    readonly railId: string;
+    readonly outcome: Outcome;
+    readonly swap: Swap;
+    readonly name = "SwapPaymentFailedError";
+    constructor(railId: string, outcome: Outcome, swap: Swap);
+}
+/** `eligible > 0` for this input, or false for anything that will not route. */
+declare const railAvailable: (client: SwapRailClient, input: QuoteInput) => Promise<boolean>;
+/**
+ * The three receiver-exact numbers, checked against each other.
+ *
+ * `total === amount + fee` is core's contract and this is where a rail proves
+ * it rather than asserting it in a comment: `amount` is what the recipient
+ * gets, `fee` is what the rail and its counterparty charge on top, and `total`
+ * is what leaves the wallet. A `Quote` whose give leg does not equal the take
+ * leg plus the spread has broken an invariant M3 owns, and surfacing it here
+ * beats quoting a number that would rank this rail against the collaborative
+ * exit on a fee it does not charge.
+ */
+declare const receiverExact: (railId: string, parts: {
+    amount: bigint;
+    fee: bigint;
+    total: bigint;
+}) => {
+    amount: number;
+    fee: number;
+    total: number;
+};
+/**
+ * Accept the quote, then observe it to its first terminal outcome.
+ *
+ * The handle's contract, stated once: it observes the payment up to and
+ * including the first terminal outcome, and every recovery past that point is
+ * observed on `client.onUpdate` — keyed by the tagged `RouteResult.swapId`, so
+ * the two views join. `client.onUpdate` replays synchronously on subscribe, so
+ * a swap that was already terminal by the time we subscribed still resolves.
+ */
+declare const swapHandle: (railId: string, client: SwapRailClient, quote: Quote) => Promise<PaymentHandle>;
+
+/**
+ * `lightning` — pay a BOLT11 invoice out of an Arkade balance, through the v2
+ * swap client.
+ *
+ * The rail id is a registry key with published history: the factory deleted
+ * with `packages/boltz-swap` registered `"lightning"`, and a key is what an
+ * app's `priority` array and `disabled` list name. It therefore stays
+ * `lightning` even though Q12 renamed the lightning *asset* namespace to
+ * `bolt11` — the divergence between a registry key and an asset vocabulary is
+ * recorded here, not resolved by a rename that would break every consumer's
+ * preferences.
+ *
+ * The whole rail is an adapter. The invoice fixes the amount, the client
+ * verifies and prices the route, `accept()` persists before it funds, and the
+ * drive owns everything after — so there is no `persist`, no `awaitSettlement`
+ * and no solver selection to configure here.
+ */
+
+declare const LIGHTNING_RAIL = "lightning";
+/**
+ * Register alongside core's rails. The deleted factory's ranking was
+ * `["ark", "lightning", "onchain-swap", "onchain"]`; see
+ * {@link createSwapPaymentRouter}.
+ */
+declare function lightningRail(client: SwapRailClient): PaymentRail;
+
+/**
+ * `onchain-swap` — pay an L1 address out of an Arkade balance through a solver,
+ * via the v2 swap client.
+ *
+ * Registered alongside core's `onchain` rail (the collaborative exit) and
+ * ranked ahead of it, with both left registered: the default is a *preference*,
+ * not a restriction. The preference self-heals by amount — an out-of-range
+ * request drops this rail at `available()` and `onchain` wins with no error.
+ *
+ * The id is the deleted factory's published registry key, `"onchain-swap"`,
+ * kept for the reason the `lightning` rail keeps its own: a rail id is what an
+ * app's `priority` array names.
+ *
+ * **The claim fee is this rail's whole subtlety.** On `arkade -> onchain` the
+ * trader claims the solver's L1 HTLC itself, and that claim's fee comes out of
+ * the HTLC output — `payout = utxo.amount - fee`. So the sats the recipient
+ * actually receives are less than the sats the solver locks, by an amount the
+ * swap quote knows nothing about. A rail that quoted the solver's spread alone
+ * would be reporting a fee it does not charge, and would win a ranking against
+ * the collaborative exit that it should lose.
+ *
+ * This rail therefore takes a claim fee-rate policy at construction and grosses
+ * the swap up by the estimate: it asks the solver for `amount + claimFee` on the
+ * take leg, so what lands after the claim is the `amount` the caller asked for,
+ * and it reports the estimate inside `fee` where a ranking can see it. A fee
+ * rate is environment-specific and is nobody's to default — the same reason
+ * `CorridorOverrides.onchain.claim` has no default.
+ */
+
+declare const ONCHAIN_SWAP_RAIL = "onchain-swap";
+interface OnchainSwapRailDeps {
+    /**
+     * Sat/vB the trader's L1 claim will be built at — the rate the corridor's
+     * own `claim` dep will use.
+     *
+     * No default, and the rail refuses to exist without it: the fee comes out
+     * of the recipient's payout, so a rail with no rate either quotes a fee it
+     * does not charge or short-pays the recipient. Neither is a default.
+     */
+    readonly claimFeeRateSatVb: number;
+    /** vsize the claim is priced at. Defaults to {@link ONCHAIN_CLAIM_VSIZE}. */
+    readonly claimVsize?: number;
+}
+/** What the trader's L1 claim will cost, rounded up as the builder rounds it. */
+declare const claimFeeSats: (deps: OnchainSwapRailDeps) => bigint;
+/**
+ * Register alongside core's rails, ranked ahead of `onchain`:
+ * `["ark", "lightning", "onchain-swap", "onchain"]`. See
+ * {@link createSwapPaymentRouter}.
+ */
+declare function onchainSwapRail(client: SwapRailClient, deps: OnchainSwapRailDeps): PaymentRail;
+
+/**
+ * The router that puts lightning and `arkade -> onchain` back into a payment
+ * app's reach.
+ *
+ * Core's `createDefaultPaymentRouter(wallet)` registers `ark` and `onchain` and
+ * nothing else. The two swap rails never lived there — they were in
+ * `packages/boltz-swap`, behind a second overload with the priority
+ * `["ark", "lightning", "onchain-swap", "onchain"]`, and ts-sdk #811 removed
+ * them along with the package. This is that overload's shape, rebuilt on the v2
+ * client.
+ *
+ * **The rails close over their own dependencies, and `RouterContext` is not
+ * re-opened.** Widening core's context was the alternative and it is the wrong
+ * half: it edits a published payment type, re-imports the `swaps?: unknown`
+ * smell that was deliberately deleted, and asks core to name things it cannot —
+ * a repository, a transport, a discovery index. A rail factory over an
+ * already-constructed `SwapClient` names none of that in core.
+ *
+ * This factory stays out of core's own, which is pinned at exactly
+ * `["ark", "onchain"]`. Registering the swap rails is the app's decision, and
+ * the ranking it gets is a *preference*: both `onchain-swap` and `onchain` stay
+ * registered, so an amount outside the solver's range drops the swap rail at
+ * `available()` and the collaborative exit wins with no error.
+ */
+
+/** The deleted factory's ranking, and the one this factory ships. */
+declare const SWAP_ROUTER_PRIORITY: readonly string[];
+interface SwapPaymentRouterConfig extends OnchainSwapRailDeps {
+    /** Overrides the shipped ranking; `disabled`, `caps` and `tieBreak` pass through. */
+    readonly prefs?: RouterPreferences;
+}
+/**
+ * Core's four rails plus the two this package supplies, ranked as the deleted
+ * factory ranked them.
+ *
+ * Takes the concrete `Wallet` because that is what `RouterContext` holds — core
+ * types it as the class, not `IWallet` — and the already-constructed client,
+ * because building one here would put storage, discovery and corridor policy
+ * behind a payment-router call that has no business deciding any of them.
+ */
+declare function createSwapPaymentRouter(wallet: Wallet, client: SwapRailClient, config: SwapPaymentRouterConfig): PaymentRouter;
+
+/**
+ * Fourteen outcomes onto four payment statuses — the only artefact M7 mints.
+ *
+ * Declared **total** even though a send rail cannot reach every member, because
+ * a partial map is where the collapse hides: an outcome with no row does not
+ * fail loudly, it renders as whatever the lookup happens to return.
+ *
+ * The projection is lossy by construction and the loss is recoverable, which is
+ * the whole design. `refunded` and `lapsed` both land on `failed` — P6 exists so
+ * those two never become one word, and the difference survives on the update's
+ * `error`, which core's `PaymentHandle` docblock already reserves for it. No
+ * fifth `PaymentStatus` is proposed: a status is what a payment UI branches on,
+ * and "the trader's value came back" versus "the incoming payment never arrived"
+ * is a sentence, not a branch.
+ *
+ * **Where the rail goes terminal is a decision, not a rounding.** It goes
+ * terminal at `refunding`, not at `refunded`: `makeHandle` clears its subscriber
+ * set on a terminal update and replays-without-registering afterwards, so the
+ * `refunded` that follows could not reach that handle anyway — and holding
+ * terminality back until the refund resolves would hang every
+ * `settled({ timeoutMs })` caller for a whole refund window. The refund is
+ * observed through `client.onUpdate` and `swaps()`, keyed by the tagged
+ * `RouteResult.swapId`.
+ *
+ * The same rule answers the `unblock` backslide. `needs_recovery -> funded` is
+ * a legal re-entry that crosses the terminality boundary the rail just drew; it
+ * is emitted rather than swallowed, because the drive's idempotence key is the
+ * DERIVED outcome and the second `funded` is a new key — delivered on
+ * `client.onUpdate`, never through the handle, which stays terminal. A handle
+ * observes a payment up to and including its first terminal outcome; every
+ * recovery past that point is observed on the client's update stream.
+ */
+
+/**
+ * The projection, total over {@link Outcome}.
+ *
+ * The `on the rail` column of M7's table is not encoded here: a send rail
+ * cannot reach `open`, `filled`, `cancelling`, `cancelled` or `lapsed`, but a
+ * map that refused them would be a map with holes, and the point of totality is
+ * that there are none.
+ */
+declare const PAYMENT_STATUS: {
+    /** Persisted, funding not broadcast. */
+    readonly accepted: "pending";
+    readonly funding: "pending";
+    /** The lockup is funded. Nothing has emitted `"sent"` in core since the
+     *  `onchain-swap` rail left with `packages/boltz-swap`. */
+    readonly funded: "sent";
+    /** Asset swaps only: an unfilled offer. */
+    readonly open: "pending";
+    /** Asset swaps only. */
+    readonly filled: "settled";
+    /** The trader's L1 claim on `arkade -> onchain`. */
+    readonly claimed: "settled";
+    /** Terminal success on `arkade -> lightning`: the solver's hash-verified
+     *  spend IS the invoice being paid. */
+    readonly paid: "settled";
+    readonly cancelling: "pending";
+    /** Value returned, and the router has no non-loss terminal to say so with. */
+    readonly cancelled: "failed";
+    /** Terminal HERE, not at `refunded` — see the module docblock. */
+    readonly refunding: "failed";
+    /** The trader's value came back. Reaches `onUpdate`, not the handle. */
+    readonly refunded: "failed";
+    /** The solver reclaimed a receive-leg lockup: a loss, and not `refunded`. */
+    readonly lapsed: "failed";
+    /** Never retried silently; `client.recover` drives it. */
+    readonly needs_recovery: "failed";
+    readonly failed: "failed";
+};
+/** Where a payment stands, in core's four-state vocabulary. */
+declare const paymentStatusOf: (outcome: Outcome) => PaymentStatus;
+/** Whether this status ends the handle's observation. Core's own rule. */
+declare const isTerminalStatus: (status: PaymentStatus) => boolean;
+
 interface SealedClaimPacket {
     /** `ephPub(33) ‖ nonce(12) ‖ ciphertext`, base64 — wire-ready. This is
      * the whole packet: the RFQ request's `claim_packet` field carries
@@ -799,8 +1191,6 @@ interface ClaimPacketInput {
  */
 declare function sealClaimPacket(input: ClaimPacketInput): Promise<SealedClaimPacket>;
 
-/** The Ark surface the claim push needs — the same seam the refund push uses. */
-type ClaimArkProvider = RefundArkProvider;
 /**
  * The lockup is funded for less than the swap agreed.
  *
@@ -843,9 +1233,9 @@ declare class LockupAmountMismatchError extends Error {
  * server at submit — but it turns "reported claimed, nothing landed, the
  * solver refunds hours later" into an immediate failure.
  */
-declare function pushClaim(ark: ClaimArkProvider, input: {
-    /** The receive-direction covenant (see `receiveVtxoScript`). */
-    script: InstanceType<typeof VHTLC.ScriptV2>;
+declare function pushClaim(operator: SwapOperator, input: {
+    /** The receive-direction covenant (see `lightningReceiveContract`). */
+    contract: InstanceType<typeof VHTLC.ScriptV2>;
     /** The trader's `receiver` signer. Build it from the swap's `secrets`
      * with `contractSigner` — on an HD wallet that resolves
      * from the seed, with no stored key bytes anywhere. */
@@ -865,7 +1255,7 @@ declare function pushClaim(ark: ClaimArkProvider, input: {
      * the remainder. */
     partiallyClaimed?: boolean;
 }): Promise<{
-    arkTxid: string;
+    txid: string;
     amount: number;
 }>;
 /**
@@ -892,13 +1282,13 @@ declare function awaitLockupFunding(indexer: RefundIndexer, swapPkScript: Uint8A
  * rest lands is safe — and that is also the answer to a genuinely underfunded
  * lockup, which never gets past the gate at all.
  */
-declare function claimReceiveLockup(indexer: RefundIndexer, ark: ClaimArkProvider, input: Parameters<typeof pushClaim>[1] & {
+declare function claimReceiveLockup(indexer: RefundIndexer, operator: SwapOperator, input: Parameters<typeof pushClaim>[1] & {
     /** The covenant's scriptPubKey, from the request flow's `swapPkScript`. */
     swapPkScript: Uint8Array;
     pollMs?: number;
     deadline?: number;
 }): Promise<{
-    arkTxid: string;
+    txid: string;
     amount: number;
 }>;
 
@@ -965,7 +1355,7 @@ declare function senderIdentityForSwapRecord(wallet: IWallet, record: {
  */
 
 interface ArkadeRefunderDeps {
-    ark: RefundArkProvider;
+    operator: SwapOperator;
     indexer: RefundIndexer;
     /** Asked for the descriptor's signer; never asked to mint a key. */
     wallet: IWallet;
@@ -981,7 +1371,7 @@ interface ArkadeRefunderDeps {
  *
  * @example
  * manager.setCallbacks({
- *     refundArkade: arkadeRefunder({ ark, indexer, wallet, repository }),
+ *     refundArkade: arkadeRefunder({ operator, indexer, wallet, repository }),
  *     saveSwap,
  * });
  */
@@ -1109,7 +1499,7 @@ interface RfqSwapActivityDeps {
     repository: Pick<AssetSwapRepository, "getAllRfqSwaps">;
     /**
      * Consulted only for what a record cannot answer: a record written before
-     * `fundingArkTxid` existed, and the counterparty's spend on a swap that
+     * `fundingTxid` existed, and the counterparty's spend on a swap that
      * ended without a refund of ours.
      *
      * Optional because the stored fields are the primary source — cheaper, and
@@ -1123,7 +1513,7 @@ interface RfqSwapActivityDeps {
  * groups on.
  *
  * The txids come from four places, in order of preference: the record's own
- * `fundingArkTxid` and `refundArkTxid`, the corridor's `activityTxids` (the
+ * `fundingTxid` and `refundTxid`, the corridor's `activityTxids` (the
  * receive leg's Arkade claim, the onchain leg's L1 one), and — only when the
  * first two cannot answer — one read of the lockup's VTXOs.
  *
@@ -1133,4 +1523,110 @@ interface RfqSwapActivityDeps {
  */
 declare function rfqSwapActivityInputs(deps: RfqSwapActivityDeps): Promise<SwapActivityInput[]>;
 
-export { ArkadeRefundResult, type ArkadeRefunderDeps, AssetSwap, AssetSwapRepository, ChainSource, type ClaimArkProvider, type ClaimPacketInput, type DiscoverMarketsOptions, IndexedDbAssetSwapRepository, InvoiceFacts, type LightningReceiveProfile, type LightningSendProfile, LockupAmountMismatchError, LockupContractMissing, type LockupContractReader, type LockupContractWriter, LockupRegistrationFailed, LockupSpendIndexer, LockupVtxo, MarketsCacheEntry, OFFER_PACKET_TYPE, type Offer, type OfferContractRetirer, type OfferSwapWatcher, OnchainHtlc, OnchainHtlcParams, OnchainNetwork, type OnchainSendProfile, type PlanError, QUOTE_OPTIONS, RefundArkProvider, type RefundBlockedReason, RefundIndexer, RefundNotLocallyPossibleError, type RestoreIndexer, type RfqClaimSecretProjection, type RfqHashlockProjection, type RfqSignerProjection, RfqSwap, type RfqSwapActivityDeps, RfqSwapRecord, RfqSwapState, RfqTransport, SOLVER_LIGHTNING_RAIL, SOLVER_ONCHAIN_RAIL, SWAP_LOCKUP_CONTRACT_KIND, SWAP_LOCKUP_CONTRACT_LABEL, SWAP_LOCKUP_CONTRACT_TYPE, type SealedClaimPacket, type SolverLightningRailDeps, type SolverLightningSend, type SolverOnchainRailDeps, type SolverOnchainSend, type SolverRendezvous, type SpendKind, type SwapActivityInput, SwapSecretsProjection, type Tx, type WatchOfferSwapsParams, arkadeRefunder, awaitLockupFunding, cancelOffer, chainSourceFrom, claimReceiveLockup, classifyDepositSpend, classifySpend, createOffer, decodeOffer, discoverMarkets, encodeOffer, findMarket, lockupContractParams, makeCachedFeedFetch, offerVtxoScript, onchainSendProfile, pushClaim, registerLockupContract, requestLightningSend, requestOnchainSend, restoreAssetSwaps, retireSettledOfferContracts, rfqClaimSecretOf, rfqSecretsProfile, rfqSignerOf, rfqSwapActivityInputs, sealClaimPacket, senderIdentityForSwapRecord, solverLightningRail, solverLightningRendezvous, solverOnchainRail, solverOnchainRendezvous, solverRendezvous, spendTxidsOf, spendUpdate, swapActivityResolver, swapPrograms, validatePlan, watchOfferSwaps };
+interface SwapQuoteInput {
+    /** Which side of the market the trader deposits. */
+    give: "base" | "quote";
+    /** Size on the named side ("give" = exact-in, "receive" = exact-out).
+     * Spot: display string or atomic bigint; corridors: sats. A lightning
+     * send takes its amount from the invoice instead. */
+    amount?: string | number | bigint;
+    amountOn?: "give" | "receive";
+    /** Required when the receive side is lightning. */
+    invoice?: InvoiceFacts;
+    /** Trader's x-only L1 claim key; required when the receive side is onchain. */
+    payoutPubkey?: Uint8Array;
+    /**
+     * The L1 address the claim PAYS to, when the receive side is onchain.
+     *
+     * Distinct from {@link payoutPubkey}, which only AUTHORISES the claim: the
+     * claim's output is the spender's own choice, and nothing on the wire names
+     * it. Omitted, the claim pays the trader's own `payoutPubkey` as a key-path
+     * P2TR — the conservative default, since that is the one destination the
+     * trader is already known to hold the key for.
+     */
+    payoutAddress?: string;
+    preimage?: Uint8Array;
+    maxPayAmount?: number;
+}
+interface SpotQuote {
+    kind: "spot";
+    market: DiscoveredMarket;
+    plan: OfferPlan;
+}
+interface LightningSendQuote {
+    kind: "ln_send";
+    market: DiscoveredMarket;
+    request: Awaited<ReturnType<typeof requestLightningSend>>;
+}
+interface LightningReceiveQuote {
+    kind: "ln_receive";
+    market: DiscoveredMarket;
+    request: Awaited<ReturnType<typeof requestLightningReceive>>;
+    /** The solver's hold invoice, for the payer. */
+    invoice: string;
+}
+interface OnchainSendQuote {
+    kind: "onchain_send";
+    market: DiscoveredMarket;
+    request: Awaited<ReturnType<typeof requestOnchainSend>>;
+    /** Where the claim pays, resolved at quote time from `payoutAddress` (or
+     * defaulted to the trader's own claim key) and persisted with the record:
+     * `buildHtlcClaim` needs it and nothing else gives it back. */
+    payoutPkScript: Uint8Array;
+}
+type SwapQuote = SpotQuote | LightningSendQuote | LightningReceiveQuote | OnchainSendQuote;
+type UnifiedSwap = {
+    family: "offer";
+    swap: AssetSwap;
+} | {
+    family: "rfq";
+    swap: RfqSwap;
+};
+interface SwapClientDeps {
+    /** The server connection too: every provider below defaults to this
+     * wallet's own, so no server URL is passed in (arkade-os/ts-sdk#734). */
+    wallet: IWallet;
+    repository: AssetSwapRepository;
+    /** The rendezvous for a corridor market; never called for a spot one.
+     *
+     * The market's own `base_corridor`/`quote_corridor` are what route a swap
+     * here rather than to the offer path, so whoever publishes the market
+     * chooses which backend you are asked to open a transport to. Resolve one
+     * only for markets from an index you trust — this client does not, and
+     * cannot, check that a market named a corridor honestly. */
+    transportFor: (market: DiscoveredMarket) => RfqTransport;
+    discovery: Omit<DiscoverMarketsOptions, "repository">;
+    /** BOLT11 decoder for the solver's hold invoice; required to quote lightning receives. */
+    decodeInvoice?: (bolt11: string) => InvoiceFacts;
+    /** covclaimd's 33-byte compressed pubkey — the lightning-receive claim
+     * packet seals to it; required to quote lightning receives. */
+    covclaimdPubkey?: Uint8Array;
+    /** L1 access; required to quote onchain sends. */
+    chain?: ChainSource;
+    /** L1 claim callback (fee rate and signing are environment-specific);
+     * without it the manager reports onchain claims as blocked. */
+    claimOnchain?: RfqSwapManagerCallbacks["claimOnchain"];
+    emulatorPubkey?: string;
+    /** Overrides the wallet's own connection; for tests and for a caller that
+     * must reach a different operator. */
+    ark?: SwapOperator;
+    indexer?: LockupSpendIndexer;
+}
+interface SwapClient {
+    markets(useCache?: boolean): Promise<DiscoveredMarket[]>;
+    quote(market: DiscoveredMarket, input: SwapQuoteInput): Promise<SwapQuote>;
+    accept(quote: SwapQuote): Promise<UnifiedSwap>;
+    /** Spot only: the covenant's cooperative reclaim. */
+    cancel(fundingTxid: string): Promise<void>;
+    /** Every swap this client knows of, both families and both live and ended
+     * — not a live-only view. The RFQ half is bounded by what the manager has
+     * loaded and by `RFQ_SWAP_RETENTION_SECONDS`. */
+    swaps(): Promise<UnifiedSwap[]>;
+    onUpdate(listener: (swap: UnifiedSwap) => void): () => void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    readonly manager: RfqSwapManager;
+}
+declare function createSwapClient(deps: SwapClientDeps): SwapClient;
+
+export { ArkadeRefundResult, type ArkadeRefunderDeps, AssetSwap, AssetSwapRepository, AssetSwapStatus, ChainSource, type ClaimPacketInput, type DiscoverMarketsOptions, IndexedDbAssetSwapRepository, InvoiceFacts, LIGHTNING_RAIL, type LightningReceiveProfile, type LightningReceiveQuote, type LightningSendProfile, type LightningSendQuote, LockupAmountMismatchError, LockupContractMissing, type LockupContractReader, type LockupContractWriter, LockupRegistrationFailed, LockupSpendIndexer, LockupVtxo, MarketsCacheEntry, NoSpendableDepositError, OFFER_PACKET_TYPE, ONCHAIN_SWAP_RAIL, type Offer, type OfferContractRetirer, OfferCovenantMismatchError, type OfferSwapWatcher, OnchainHtlc, OnchainHtlcParams, OnchainNetwork, type OnchainSendProfile, type OnchainSendQuote, type OnchainSwapRailDeps, PAYMENT_STATUS, type PlanError, QUOTE_OPTIONS, type RefundBlockedReason, RefundIndexer, RefundNotLocallyPossibleError, type RestoreIndexer, type RfqClaimSecretProjection, type RfqHashlockProjection, type RfqSignerProjection, RfqSwap, type RfqSwapActivityDeps, RfqSwapManager, RfqSwapManagerCallbacks, RfqSwapRecord, RfqSwapState, RfqTransport, SOLVER_LIGHTNING_RAIL, SOLVER_ONCHAIN_RAIL, SWAP_LOCKUP_CONTRACT_KIND, SWAP_LOCKUP_CONTRACT_LABEL, SWAP_LOCKUP_CONTRACT_TYPE, SWAP_ROUTER_PRIORITY, type SealedClaimPacket, type SolverLightningRailDeps, type SolverLightningSend, type SolverOnchainRailDeps, type SolverOnchainSend, type SolverRendezvous, type SpendKind, type SpotQuote, type SwapActivityInput, type SwapClient, type SwapClientDeps, SwapOperator, SwapPaymentFailedError, type SwapPaymentRouterConfig, type SwapQuote, type SwapQuoteInput, type SwapRailClient, SwapSecretsProjection, type Tx, type UnifiedSwap, type WatchOfferSwapsParams, arkadeRefunder, awaitLockupFunding, cancelOffer, chainSourceFrom, claimFeeSats, claimReceiveLockup, classifyDepositSpend, classifySpend, createOffer, createSwapClient, createSwapPaymentRouter, decodeOffer, discoverMarkets, encodeOffer, findMarket, isTerminalStatus, lightningRail, lockupContractParams, makeCachedFeedFetch, offerContract, onchainSendProfile, onchainSwapRail, paymentStatusOf, pushClaim, railAvailable, receiverExact, registerLockupContract, requestLightningReceive, requestLightningSend, requestOnchainSend, restoreAssetSwaps, retireSettledOfferContracts, rfqClaimSecretOf, rfqSecretsProfile, rfqSignerOf, rfqSwapActivityInputs, sealClaimPacket, senderIdentityForSwapRecord, solverLightningRail, solverLightningRendezvous, solverOnchainRail, solverOnchainRendezvous, solverRendezvous, spendTxidsOf, spendUpdate, swapActivityResolver, swapHandle, swapPrograms, validatePlan, watchOfferSwaps };