@arkade-os/swap 0.0.10 → 0.1.0-rc.0

package/dist/index.d.cts

@@ -1,9 +1,9 @@
-import { ProvisionedKey, ProvisionedClaimSecret, asset, IWallet, arkade, RestIndexerProvider, Transaction, IContractManager, 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-C8FXlmHY.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-C8FXlmHY.cjs';
+import { ProvisionedKey, ProvisionedClaimSecret, asset, RelativeTimelock, IWallet, arkade, RestIndexerProvider, Transaction, IContractManager, 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 RefundIndexer, L as LockupVtxo, c as SwapOperator, d as RfqSwap, e as ArkadeRefundResult, f as LockupSpendIndexer, g as RfqSwapState, h as RfqSwapManager, i as RfqSwapManagerCallbacks } from './repository-BWP1UstE.cjs';
+export { j as AssetSwapStatus, k as AvailableRfqSwapManagerCallbacks, B as BTC_ASSET_ID, I as InMemoryAssetSwapRepository, l as LightningReceiveSwap, m as LightningSendSwap, n as LockupFate, o as LockupNeedsRecoveryError, p as LockupParams, q as LockupSpend, O as OnchainSendAction, r as OnchainSendSwap, P as PersistableRfqSwap, s as PreimageBlockedReason, t as PreimageNotRecoverableError, u as REFUND_MTP_LAG_SECONDS, v as RFQ_RESOLVED_STATES, w as RFQ_SWAP_RETENTION_SECONDS, x as RFQ_SWAP_TERMINAL_STATES, y as RefundOutcome, z as RfqRestoreFailure, C as RfqRestoreOptions, D as RfqRestoreResult, E as RfqSwapActionName, F as RfqSwapLockup, 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 normalizeRfqSwapRecord, a3 as preimageForSwapRecord, a4 as pushRefundWithoutReceiver, a5 as readLockupFate, a6 as rebuildRfqSwap, a7 as refundIfUnresolved, a8 as rfqSwapOriginOf, a9 as shouldRetainRfqSwap, aa as swapSecretsToRecord, ab as updateAssetSwap, ac as updateAssetSwapBestEffort, ad as updateRfqSwapRecord } from './repository-BWP1UstE.cjs';
 import { Network, LocalCardInput, DiscoveredMarket, Side, OfferPlan } from '@arkade-os/solver-discovery';
-import { O as OnchainNetwork, a as OnchainHtlc, b as OnchainHtlcParams } from './rfq-DglvHMNC.cjs';
-export { A as ARKADE_ASSET, c as ARKADE_BTC, d as AddressMismatch, C as ChainSource, e as ChainUtxo, H as HtlcUtxo, I as InvoiceFacts, L as LIGHTNING_BTC, f as LIGHTNING_RECEIVE_PAIR, g as LIGHTNING_SEND_PAIR, h as LOCKTIME_THRESHOLD, i as LightningReceiveTreeParams, j as LightningSendTreeParams, M as MAX_MIN_CONFIRMATIONS, k as MIN_CLAIM_WINDOW_SECONDS, l as MIN_HEADROOM_SECONDS, m as ONCHAIN_BTC, n as ONCHAIN_CLAIM_MARGIN_SECONDS, o as ONCHAIN_DUST_SATS, p as ONCHAIN_ORDER_MARGIN_SECONDS, q as ONCHAIN_RECEIVE_PAIR, r as ONCHAIN_SECONDS_PER_BLOCK, s as ONCHAIN_SEND_PAIR, t as OnchainHtlcPhase, R as RFQ_TERMINAL_STATES, u as RelaySocket, v as RfqQuote, w as RfqRefusalReason, x as RfqStatus, y as RfqTransport, S as SOLO_REFUND_HEADROOM_SECONDS, z as SwapRefusal, B as arkadeAssetLeg, D as arkadeSwapRequest, E as assertFundable, F as assertReceivable, G as awaitOnchainFill, J as buildHtlcClaim, K as buildHtlcRefund, N as claimOnchainFill, P as classifyOnchainHtlc, Q as deriveLightningReceive, T as deriveOnchainReceive, U as deriveOnchainSend, V as extractPreimage, W as httpTransport, X as lightningReceiveRequest, Y as lightningSendRequest, Z as lightningSendVtxoScript, _ as newPreimage, $ as newRfqId, a0 as offerTermsFromQuote, a1 as onchainHtlcScript, a2 as onchainReceiveRequest, a3 as onchainSendRequest, a4 as paymentHashOf, a5 as receiveVtxoScript, a6 as relayTransport, a7 as requestLightningReceive, a8 as requestLightningSend, a9 as requestOnchainReceive, aa as requestOnchainSend, ab as rfqPair, ac as unilateralClaimDelay, ad as unilateralRefundDelay, ae as unilateralRefundWithoutReceiverDelay, af as verifyLockupAddress, ag as verifyReceiveInvoice } from './rfq-DglvHMNC.cjs';
+import { O as OnchainNetwork, a as OnchainHtlc, b as OnchainHtlcParams, r as requestLightningReceive, c as requestLightningSend, d as requestOnchainSend, I as InvoiceFacts, R as RfqTransport, C as ChainSource } from './rfq-CzCGjICq.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 lightningReceiveContract, $ as lightningReceiveRequest, a0 as lightningSendContract, a1 as lightningSendRequest, a2 as newPreimage, a3 as newRfqId, a4 as offerTermsFromQuote, a5 as onchainHtlcScript, a6 as onchainReceiveRequest, a7 as onchainSendRequest, a8 as paymentHashOf, a9 as relayTransport, aa as requestOnchainReceive, ab as rfqPair, ac as unilateralClaimDelay, ad as unilateralRefundDelay, ae as unilateralRefundWithoutReceiverDelay, af as verifyLockupAddress, ag as verifyReceiveInvoice } from './rfq-CzCGjICq.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> {
@@ -182,7 +182,18 @@ declare function onchainSendProfile(result: {
     minConfirmations: number;
 }): Omit<OnchainSendProfile, "signer" | "hashlock">;
 
-/** The contracts — pure data, shared verbatim with any other implementation. */
+/**
+ * The contracts, one per WANT side — pure data, shared verbatim with any other
+ * implementation.
+ *
+ * **These are the base: an offer carrying an exit delay compiles to a third
+ * closure that is not in either file.** The tree is not fixed-shape — the
+ * protocol defines the exit as `iff ExitDelay`, and solverd appends it the same
+ * way (`pkg/swap/contract/offer.go`, `VtxoScript`) — so it cannot be a function
+ * in a static artifact without splitting these into one file per exit variant.
+ * {@link withExitClosure} owns that step, and the golden in `offer.test.ts`
+ * pins the artifact it produces so the whole contract is still readable as data.
+ */
 declare const swapPrograms: Record<"wantAsset" | "wantBtc", ReturnType<typeof arkade.parseArtifact>>;
 /** A full-fill offer. Exactly one field names an asset: `wantAsset` set = the
  * fill must deliver that asset (the deposit may be BTC or another asset,
@@ -203,9 +214,17 @@ interface Offer {
     makerPublicKey: Uint8Array;
     /** Covenant co-signer (emulator) x-only key (32 bytes). */
     emulatorPubkey: Uint8Array;
+    /** Partial-fill numerator. Reserved wire space in V1: carried through the
+     * codec so an offer that sets it decodes, never interpreted here. */
+    ratioNum?: bigint;
+    /** Partial-fill denominator. Set with {@link Offer.ratioNum} or not at all. */
+    ratioDen?: bigint;
+    /** The maker's unilateral exit path. Present adds a third closure to the
+     * taproot tree, so it changes `swapPkScript` — see {@link offerVtxoScript}. */
+    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). */
@@ -217,11 +236,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] })
@@ -233,14 +252,28 @@ declare function decodeOffer(data: Uint8Array): Offer;
  * funding rather than after: nothing is at stake yet, so a failure can throw
  * and be retried, where the same failure after `wallet.send` would leave a
  * funded deposit unwatched with no way to notice.
+ *
+ * **The maker's unilateral exit closure is built by default**, at the server's
+ * own `unilateralExitDelay` — the same thing solverd does. Without it `cancel`
+ * is the only way back out, and `cancel` needs the server's signature: a server
+ * that will not co-sign leaves the deposit stuck at the swap address until the
+ * VTXO expires and the operator sweeps it. An offer has no expiry of its own,
+ * 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;
     /** Co-signer key override (33-byte compressed hex); see
      * {@link resolveEmulatorPubkey}. */
     emulatorPubkey?: string;
+    /** Override the exit closure's delay. Defaults to the server's own
+     * `unilateralExitDelay`, which is the delay solverd uses too. */
+    exitDelay?: RelativeTimelock;
+    /** Publish without the exit closure, leaving `cancel` — which needs the
+     * server — as the only way back out. See the note on this function. */
+    noExit?: boolean;
 }): Promise<{
     /** The encoded offer, hex. **Persist this** — it is the only input
      * `cancelOffer` needs to rebuild the covenant, and the restore scan reads
@@ -263,19 +296,23 @@ declare function createOffer(wallet: IWallet, arkServerUrl: string, params: {
 /**
  * Cancel an offer: spend the swap VTXO back to the user. Returns the ark txid.
  *
- * This is the refund path — how a user takes back a deposit no solver filled.
- * **Neither program carries a timelock**, so an unfilled deposit keeps its
- * place at the swap address rather than expiring: no deadline to miss and no
- * "expired" state to unwind, at the cost of the refund being something the
+ * This is the cooperative refund path — how a user takes back a deposit no
+ * solver filled. **No path here is on a deadline**, so an unfilled deposit
+ * keeps its place at the swap address rather than expiring: nothing to miss and
+ * no "expired" state to unwind, at the cost of the refund being something the
  * user asks for rather than something a clock delivers.
  *
- * Both paths out of the covenant are deliberately asymmetric:
+ * The routes out of the covenant are deliberately asymmetric:
  *   - `fulfill` is signed by the **server alone**, but the covenant constrains
  *     it to pay output 0 to `makerWP` for at least `wantAmount` — a solver
  *     cannot take the deposit without delivering.
  *   - `cancel` is a **2-of-2 of the user and the server**, so cancelling is
  *     cooperative: the server co-signs. No solver signature is involved, so the
  *     refund never depends on the counterparty being reachable.
+ *   - `exit` is the user **alone** after a relative timelock, present unless the
+ *     offer was created with `noExit`. It is the route that survives a server
+ *     that will not co-sign this one, and it is reached by unrolling the VTXO
+ *     onchain rather than through this function.
  *
  * Cancel therefore races a fill rather than pre-empting it. An offer the solver
  * is filling in the same moment may be spent by `fulfill` first, in which case
@@ -291,8 +328,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.
  *
@@ -313,8 +350,13 @@ 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;
@@ -393,8 +435,7 @@ 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;
     private readonly connection;
@@ -451,10 +492,19 @@ type SpendKind = "cancelled" | "fulfilled" | "indeterminate";
 /**
  * Classify a spend by the covenant leaf it took.
  *
- * The covenant's whole vocabulary is two leaves: `cancel` returns the deposit
- * to the user, `fulfill` is the solver paying for it. A submitted ark tx keeps
- * each input's `tapLeafScript`, so the spend *states* which one it used — this
- * reads an answer rather than inferring one.
+ * The vocabulary is what became of the deposit, not which key moved it:
+ * `fulfill` is the solver paying for it, and everything else returns it to the
+ * user. A submitted ark tx keeps each input's `tapLeafScript`, so the spend
+ * *states* which one it used — this reads an answer rather than inferring one.
+ *
+ * **`exit` reports `cancelled`, like `cancel` does.** The two differ in who had
+ * to agree — `cancel` is cooperative with the signer, `exit` is the maker alone
+ * after a delay — but not in outcome: the deposit went back unfilled either
+ * way, which is the question this answers. Reporting the exit leaf as
+ * `indeterminate` instead would be worse than imprecise: no status is written,
+ * so the swap stays `pending`, `restoreAssetSwaps` re-queues it on every scan,
+ * and `retireOfferContract` never runs — leaving a dead script in the
+ * subscription and the failsafe poll for the life of the wallet.
  *
  * **Hand it the transaction that actually spends the deposit outpoint, which is
  * the checkpoint, not the ark tx.** A spend is two linked transactions: the
@@ -474,12 +524,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;
@@ -500,7 +550,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;
@@ -525,12 +575,12 @@ 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[];
@@ -558,9 +608,6 @@ interface OfferSwapWatcher {
 }
 interface WatchOfferSwapsParams {
     wallet: IWallet;
-    /** Same URL `createOffer`/`cancelOffer` take; used to read a spending tx
-     * when the exact classifier cannot answer. */
-    arkServerUrl: string;
     repository: AssetSwapRepository;
     /** Called after a change is persisted. A notification, not a store. */
     onUpdate?: (swap: AssetSwap) => void;
@@ -576,7 +623,7 @@ 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({ wallet, repository, onUpdate, }: WatchOfferSwapsParams): Promise<OfferSwapWatcher>;
 
 /**
  * Coverage: whether an offer's script is in the wallet's watched set.
@@ -644,8 +691,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.
  *
@@ -688,9 +733,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. */
@@ -710,7 +755,7 @@ declare function pushClaim(ark: ClaimArkProvider, input: {
      * the remainder. */
     partiallyClaimed?: boolean;
 }): Promise<{
-    arkTxid: string;
+    txid: string;
     amount: number;
 }>;
 /**
@@ -737,13 +782,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;
 }>;
 
@@ -810,7 +855,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;
@@ -826,7 +871,7 @@ interface ArkadeRefunderDeps {
  *
  * @example
  * manager.setCallbacks({
- *     refundArkade: arkadeRefunder({ ark, indexer, wallet, repository }),
+ *     refundArkade: arkadeRefunder({ operator, indexer, wallet, repository }),
  *     saveSwap,
  * });
  */
@@ -954,7 +999,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
@@ -968,7 +1013,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.
  *
@@ -978,4 +1023,96 @@ interface RfqSwapActivityDeps {
  */
 declare function rfqSwapActivityInputs(deps: RfqSwapActivityDeps): Promise<SwapActivityInput[]>;
 
-export { ArkadeRefundResult, type ArkadeRefunderDeps, AssetSwap, AssetSwapRepository, type ClaimArkProvider, type ClaimPacketInput, type DiscoverMarketsOptions, IndexedDbAssetSwapRepository, 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, SWAP_LOCKUP_CONTRACT_KIND, SWAP_LOCKUP_CONTRACT_LABEL, SWAP_LOCKUP_CONTRACT_TYPE, type SealedClaimPacket, type SpendKind, type SwapActivityInput, SwapSecretsProjection, type Tx, type WatchOfferSwapsParams, arkadeRefunder, awaitLockupFunding, cancelOffer, claimReceiveLockup, classifyDepositSpend, classifySpend, createOffer, decodeOffer, discoverMarkets, encodeOffer, findMarket, lockupContractParams, makeCachedFeedFetch, offerVtxoScript, onchainSendProfile, pushClaim, registerLockupContract, restoreAssetSwaps, retireSettledOfferContracts, rfqClaimSecretOf, rfqSecretsProfile, rfqSignerOf, rfqSwapActivityInputs, sealClaimPacket, senderIdentityForSwapRecord, 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;
+    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>>;
+}
+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, ChainSource, type ClaimPacketInput, type DiscoverMarketsOptions, IndexedDbAssetSwapRepository, InvoiceFacts, type LightningReceiveProfile, type LightningReceiveQuote, type LightningSendProfile, type LightningSendQuote, 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 OnchainSendQuote, type PlanError, QUOTE_OPTIONS, type RefundBlockedReason, RefundIndexer, RefundNotLocallyPossibleError, type RestoreIndexer, type RfqClaimSecretProjection, type RfqHashlockProjection, type RfqSignerProjection, RfqSwap, type RfqSwapActivityDeps, RfqSwapManager, RfqSwapManagerCallbacks, RfqSwapRecord, RfqSwapState, RfqTransport, SWAP_LOCKUP_CONTRACT_KIND, SWAP_LOCKUP_CONTRACT_LABEL, SWAP_LOCKUP_CONTRACT_TYPE, type SealedClaimPacket, type SpendKind, type SpotQuote, type SwapActivityInput, type SwapClient, type SwapClientDeps, SwapOperator, type SwapQuote, type SwapQuoteInput, SwapSecretsProjection, type Tx, type UnifiedSwap, type WatchOfferSwapsParams, arkadeRefunder, awaitLockupFunding, cancelOffer, claimReceiveLockup, classifyDepositSpend, classifySpend, createOffer, createSwapClient, decodeOffer, discoverMarkets, encodeOffer, findMarket, lockupContractParams, makeCachedFeedFetch, offerContract, onchainSendProfile, pushClaim, registerLockupContract, requestLightningReceive, requestLightningSend, requestOnchainSend, restoreAssetSwaps, retireSettledOfferContracts, rfqClaimSecretOf, rfqSecretsProfile, rfqSignerOf, rfqSwapActivityInputs, sealClaimPacket, senderIdentityForSwapRecord, spendTxidsOf, spendUpdate, swapActivityResolver, swapPrograms, validatePlan, watchOfferSwaps };