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

package/dist/index.d.cts

@@ -1,9 +1,9 @@
 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 RefundArkProvider, c as RefundIndexer, L as LockupVtxo, d as RfqSwap, e as ArkadeRefundResult, f as LockupSpendIndexer, g as RfqSwapState } from './repository-B02vsgcV.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-B02vsgcV.cjs';
+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-DkckzRKK.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-DkckzRKK.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> {
@@ -224,7 +224,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). */
@@ -236,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] })
@@ -261,7 +261,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;
@@ -328,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.
  *
@@ -350,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;
@@ -430,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;
@@ -520,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;
@@ -546,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;
@@ -571,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[];
@@ -604,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;
@@ -622,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.
@@ -690,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.
  *
@@ -734,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. */
@@ -756,7 +755,7 @@ declare function pushClaim(ark: ClaimArkProvider, input: {
      * the remainder. */
     partiallyClaimed?: boolean;
 }): Promise<{
-    arkTxid: string;
+    txid: string;
     amount: number;
 }>;
 /**
@@ -783,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;
 }>;
 
@@ -856,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;
@@ -872,7 +871,7 @@ interface ArkadeRefunderDeps {
  *
  * @example
  * manager.setCallbacks({
- *     refundArkade: arkadeRefunder({ ark, indexer, wallet, repository }),
+ *     refundArkade: arkadeRefunder({ operator, indexer, wallet, repository }),
  *     saveSwap,
  * });
  */
@@ -1000,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
@@ -1014,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.
  *
@@ -1024,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 };