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

package/dist/{repository-Cw2EvvZG.d.ts → repository-DLpH41ZO.d.ts}

@@ -1,6 +1,6 @@
 import { DiscoveredMarket } from '@arkade-os/solver-discovery';
-import { IWallet, ProvisionedKey, ProvisionedClaimSecret, RestArkProvider, RestIndexerProvider, VHTLC, Identity, IContractManager } from '@arkade-os/sdk';
-import { x as RfqStatus, y as RfqTransport, a as OnchainHtlc, e as ChainUtxo, C as ChainSource, t as OnchainHtlcPhase } from './rfq-DglvHMNC.js';
+import { IWallet, ProvisionedKey, ProvisionedClaimSecret, ArkProvider, RestIndexerProvider, VHTLC, Identity, IContractManager } from '@arkade-os/sdk';
+import { D as RfqStatus, R as RfqTransport, a as OnchainHtlc, g as ChainUtxo, C as ChainSource, w as OnchainHtlcPhase } from './rfq-CzCGjICq.js';
 
 type AssetSwapStatus = "pending" | "cancelling" | "fulfilled" | "cancelled" | "recoverable" | "awaiting_fill" | "claimable" | "claimed" | "refunded_l1";
 /** The sentinel asset id for BTC itself, as opposed to a 68-hex asset id.
@@ -210,10 +210,17 @@ declare function awaitRfqResolution(transport: RfqTransport, rfqId: string, opti
     pollMs?: number;
     deadline?: number;
 }): Promise<RfqStatus>;
-/** The Ark surface the refund push needs — narrower than a full provider, and
- * satisfied by {@link RestArkProvider}. Same seam style as `RestoreIndexer`. */
-type RefundArkProvider = Pick<RestArkProvider, "getInfo" | "submitTx" | "finalizeTx">;
 /** The indexer surface the lockup lookup needs. */
+/**
+ * What a push needs from the operator: the broadcast pair, plus the info read
+ * that supplies `checkpointTapscript`.
+ *
+ * Narrow on purpose. A wallet's own connection satisfies it —
+ * `getArkadeBroadcaster()` for the pair and `getArkadeInfo()` for the read — so
+ * a plugin composes one from the wallet it already has and never opens a second
+ * connection of its own (#734). A full `ArkProvider` still fits, structurally.
+ */
+type SwapOperator = Pick<ArkProvider, "getInfo" | "submitTx" | "finalizeTx">;
 type RefundIndexer = Pick<RestIndexerProvider, "getVtxos">;
 /** A still-refundable virtual output sitting at the swap lockup. */
 interface LockupVtxo {
@@ -237,12 +244,6 @@ interface LockupVtxo {
      * Opposite, but not exhaustive: an unrolled output satisfies neither, and
      * {@link findLockupVtxos} drops those before they reach this type at all.
      *
-     * `packages/boltz-swap` splits on exactly this fact rather than working
-     * around it: `settleRefundWithoutReceiver` sends a live VTXO through an
-     * offchain tx and a recoverable one through `joinBatch` — "a swept
-     * (recoverable) VTXO is no longer a live leaf, so it can only be reclaimed
-     * by re-registering it into a batch".
-     *
      * So the remedy is recovery (renewing the output into a fresh batch),
      * after which the ordinary CLTV refund works again. This package does not
      * build that round — see {@link pushRefundWithoutReceiver}, which refuses
@@ -260,8 +261,7 @@ interface LockupVtxo {
  *
  * **The remedy already exists; this package does not reimplement it.** The SDK
  * recovers swept outputs by re-registering them into a fresh batch, through
- * `IVtxoManager.recoverVtxos()` — the same batch round `packages/boltz-swap`
- * reaches via its own `joinBatch`. It reads the wallet's registered-contract
+ * `IVtxoManager.recoverVtxos()`. It reads the wallet's registered-contract
  * snapshot (`recoverVtxos` → `wallet.getVtxos({ withRecoverable: true })` →
  * `contractSnapshot()` → `contractManager.getContractsWithVtxos()`), so it
  * covers a swap lockup as soon as that lockup is registered as a contract —
@@ -278,8 +278,7 @@ interface LockupVtxo {
  *   recovery round including this VTXO earlier is rejected. `recoverVtxos`
  *   sweeps every recoverable output in ONE settlement and has no CLTV
  *   awareness, so recovering early can fail the whole batch rather than just
- *   this output. `packages/boltz-swap` encodes the same rule as "pre-CLTV
- *   recoverable → skipped".
+ *   this output.
  */
 declare class LockupNeedsRecoveryError extends Error {
     readonly name = "LockupNeedsRecoveryError";
@@ -292,11 +291,10 @@ declare class LockupNeedsRecoveryError extends Error {
      * into one settlement with no CLTV awareness, so an early attempt can fail
      * the whole batch — including unrelated outputs that were otherwise fine.
      *
-     * Exposed as a value, not only inside the message, so a caller can encode
-     * `packages/boltz-swap`'s "pre-CLTV recoverable → skipped" rule without
-     * parsing prose. Seconds-based locktimes mature against the chain tip's
-     * timestamp rather than wall clock, so treat this as a floor to wait past,
-     * not an exact alarm.
+     * Exposed as a value, not only inside the message, so a caller can skip
+     * pre-CLTV recoverable outputs without parsing prose. Seconds-based
+     * locktimes mature against the chain tip's timestamp rather than wall
+     * clock, so treat this as a floor to wait past, not an exact alarm.
      */
     readonly recoverableAfter: bigint;
     constructor(outpoints: string[], recoverableAfter: bigint);
@@ -315,8 +313,7 @@ declare class LockupNeedsRecoveryError extends Error {
  * sat unresolved — which are precisely the ones most likely to have got there.
  * Reading only the spendable set would report `nothing_to_refund` over money
  * that is still sitting at the script, which is worse than an error: it looks
- * like a resolved swap. `packages/boltz-swap` merges the same two queries for
- * the same reason (`arkade-swaps.ts`'s `refundableVtxos`).
+ * like a resolved swap.
  *
  * **Visible is not the same as refundable.** A `recoverable` output cannot be
  * spent offchain at all — see {@link LockupVtxo.recoverable} — so this set is
@@ -332,9 +329,11 @@ declare class LockupNeedsRecoveryError extends Error {
  * defensively rather than assumed. It costs the two waiting callers nothing
  * they wanted: `awaitLockupFunding` keeps waiting for a claimable lockup
  * instead of publishing `P` into a spend that cannot land, and
- * `refundIfUnresolved` reports `nothing_to_refund` instead of grinding a doomed
- * push to its deadline. The manager reads the exit through
- * {@link readLockupFate}, which queries unfiltered and reports it as `exited`.
+ * `refundIfUnresolved` reports rather than grinding a doomed push to its
+ * deadline. Both that function and `RfqSwapManager` name the exit through
+ * {@link readLockupFate}, which queries unfiltered and reports it as `exited`;
+ * this drop is the second line, and what still refuses the push on a pass where
+ * the fate read learned nothing.
  *
  * This read — not the RFQ's reported state — is the authority on whether
  * there is anything left at the lockup.
@@ -368,7 +367,7 @@ interface LockupSpend {
     checkpointTxid: string;
     /** The ark transaction that spent the above checkpoint output. What
      * history correlation matches on; absent when the indexer omitted it. */
-    arkTxid?: string;
+    txid?: string;
 }
 type LockupFate = 
 /** At least one output at the lockup is still unspent. Not over. */
@@ -499,8 +498,8 @@ declare function readLockupFate(indexer: LockupSpendIndexer, input: {
  * outpoints, rather than submitted and rejected. Filtering them out silently
  * would be worse still: it would report success over money that never moved.
  */
-declare function pushRefundWithoutReceiver(ark: RefundArkProvider, input: {
-    script: InstanceType<typeof VHTLC.ScriptV2>;
+declare function pushRefundWithoutReceiver(operator: SwapOperator, input: {
+    contract: InstanceType<typeof VHTLC.ScriptV2>;
     /** The `sender` signer. Build it from the swap record with
      * {@link senderIdentityForSwapRecord} — on an HD wallet that resolves
      * from the seed, with no stored key bytes anywhere, and every way the
@@ -512,7 +511,7 @@ declare function pushRefundWithoutReceiver(ark: RefundArkProvider, input: {
     /** Defaults to the contract's own committed refund destination. */
     refundPkScript?: Uint8Array;
 }): Promise<{
-    arkTxid: string;
+    txid: string;
     amount: number;
 }>;
 /**
@@ -534,7 +533,7 @@ type RefundOutcome =
 /** The trader took it back via `refundWithoutReceiver`. */
  | {
     outcome: "refunded";
-    arkTxid: string;
+    txid: string;
     amount: number;
     status: RfqStatus | null;
 }
@@ -555,6 +554,21 @@ type RefundOutcome =
     outpoints: string[];
     vtxos: LockupVtxo[];
     status: RfqStatus | null;
+}
+/**
+ * The lockup was unilaterally exited: its outputs sit onchain under the VHTLC
+ * script, where no offchain refund can reach them. Returned rather than
+ * retried: no amount of waiting changes where the money lives. Complete the
+ * unroll and spend the outputs onchain — then there is nothing left to refund.
+ *
+ * Distinct from {@link RefundOutcome} `needs_recovery` on purpose: that
+ * variant's remedy is recovery into a fresh batch, which is a spend no batch
+ * can make for an output that is already onchain.
+ */
+ | {
+    outcome: "exited";
+    outpoints: string[];
+    status: RfqStatus | null;
 };
 /**
  * Ask first, then fall back: watch the swap for the solver to resolve it, and
@@ -583,16 +597,36 @@ type RefundOutcome =
  *   is gone the CLTV refund is not "not yet" but "not this way", so it returns
  *   `needs_recovery` naming the outpoints rather than retrying until the
  *   deadline. Recover them and call again.
+ * - **An exited lockup ends it the same way, and is checked first.** Each pass
+ *   past the deadline asks {@link readLockupFate} before reading what is
+ *   refundable, so an output that has been unilaterally exited returns `exited`
+ *   instead of feeding a push that cannot land. It costs one extra `getVtxos`
+ *   per such pass (three where there were two), plus a `getVirtualTxs` on a
+ *   fully-spent lockup; only the pass that returns `exited` saves the other two.
+ *   Paid to prevent a push that would otherwise be retried to the deadline and
+ *   then rethrown. A failing fate read is swallowed, not raised: it is a
+ *   shortcut, and losing it must not end a wait the ordinary path could answer.
+ *
+ *   A lockup funded in two sends of which only one exited reports `exited` for
+ *   the whole thing and leaves the live half unrefunded. That is deliberate:
+ *   `RfqSwapManager` reports the same lockup `exited` on the same any-output
+ *   rule, and the two must not disagree.
  *
  * Safe to call late, and safe to call again: a caller recovering from a crash
  * well past the deadline skips straight to the push, and a lockup that is
  * already empty comes back as `nothing_to_refund` instead of an error.
  */
-declare function refundIfUnresolved(transport: RfqTransport, ark: RefundArkProvider, indexer: RefundIndexer, input: {
+declare function refundIfUnresolved(transport: RfqTransport, operator: SwapOperator, indexer: LockupSpendIndexer, input: {
     rfqId: string;
-    script: InstanceType<typeof VHTLC.ScriptV2>;
+    contract: InstanceType<typeof VHTLC.ScriptV2>;
     /** @see pushRefundWithoutReceiver */
     sender: Identity;
+    /**
+     * `sha256(P)`, hex — the quote's `payment_hash`, as {@link readLockupFate}
+     * takes it. Not derivable from `script`, whose `preimageHash` is a
+     * `hash160` of the same secret.
+     */
+    paymentHash: string;
     /** `refund_locktime` from the quote, unix seconds. */
     refundLocktime: number;
     /** Defaults to the contract's own committed refund destination. */
@@ -750,7 +784,7 @@ interface RfqSwapCommon {
     createdAt: number;
     updatedAt: number;
     /** Set once the trader's own `refundWithoutReceiver` push landed. */
-    refundArkTxid?: string;
+    refundTxid?: string;
     /**
      * The ark transactions that SPENT the lockup, stamped from the chain read
      * that ended the swap — `LockupFate.spends`, whichever verdict it reached.
@@ -759,8 +793,8 @@ interface RfqSwapCommon {
      * a solver reclaim on a receive, and — the exception — the trader's own
      * claim when a receive settles. What they have in common is that no local
      * action produced them, so nothing else on this record can name them:
-     * {@link refundArkTxid} names only a push this wallet made, and
-     * `claimArkTxid` only a submission it made.
+     * {@link refundTxid} names only a push this wallet made, and
+     * `claimTxid` only a submission it made.
      *
      * Stamped so a terminal record answers "which transaction ended this" from
      * storage. Without it the only source is another read of the lockup — a
@@ -768,10 +802,10 @@ interface RfqSwapCommon {
      * has to pay on the offline-first path where it is least affordable.
      *
      * Absent when the swap ended without a chain verdict, or when the indexer
-     * named the checkpoint but not the ark transaction — the same `arkTxid`
+     * named the checkpoint but not the ark transaction — the same `txid`
      * `LockupSpend` declares optional, for the same reason.
      */
-    lockupSpendArkTxids?: string[];
+    lockupSpendTxids?: string[];
     /** Why `state` is `failed`. */
     failure?: string;
     /** Why `state` is `needs_counterparty`. Distinct from {@link failure},
@@ -835,7 +869,7 @@ interface LightningReceiveSwap extends RfqSwapCommon {
     expectedAmount: number;
     /** Our Arkade claim's txid, once submitted. Set from the callback's return
      * and never from a chain read — the chain's answer is `settled`. */
-    claimArkTxid?: string;
+    claimTxid?: string;
 }
 /**
  * A monitored swap.
@@ -846,8 +880,8 @@ interface LightningReceiveSwap extends RfqSwapCommon {
  * writes and rebuilds these itself, through
  * {@link RfqSwapManager.restoreFromRepository}. A caller keeping its own store
  * projects it in {@link RfqSwapManagerCallbacks.saveSwap} instead, rebuilds it
- * on restart the way it was made — `lightningSendVtxoScript` /
- * `receiveVtxoScript` / `onchainHtlcScript` over the quote's binding fields —
+ * on restart the way it was made — `lightningSendContract` /
+ * `lightningReceiveContract` / `onchainHtlcScript` over the quote's binding fields —
  * and hands the result to {@link RfqSwapManager.start}.
  *
  * **`onchain:BTC->arkade:BTC` is deliberately not a member yet.** Its Arkade
@@ -905,7 +939,7 @@ declare function nextOnchainAction(input: {
 /** What the trader's own `refundWithoutReceiver` push returned, or `null` when
  * the lockup held nothing to return. */
 type ArkadeRefundResult = {
-    arkTxid: string;
+    txid: string;
     amount: number;
 } | null;
 /**
@@ -956,7 +990,7 @@ interface RfqSwapManagerCallbacks {
          * funding that arrived piecemeal can still be swept. */
         partiallyClaimed: boolean;
     }) => Promise<{
-        arkTxid: string;
+        txid: string;
         amount: number;
     }>;
     /**
@@ -1070,7 +1104,7 @@ interface RfqSwapManagerConfig {
 }
 /** The contract-manager surface this needs, narrowed for injection — the same
  * seam style as {@link LockupSpendIndexer} and `refund.ts`'s
- * {@link RefundArkProvider}, and satisfied structurally by a real
+ * `RefundIndexer`, and satisfied structurally by a real
  * `ContractManager` (`await wallet.getContractManager()`). */
 type SwapContractRegistry = Pick<IContractManager, "createContract" | "getContracts" | "onContractEvent" | "setContractWatchState">;
 /**
@@ -1450,6 +1484,17 @@ declare class RfqSwapManager {
     removeSwap(rfqId: string): Promise<void>;
     /** Every swap still being monitored. */
     getPendingSwaps(): Promise<RfqSwap[]>;
+    /**
+     * Every swap this manager holds — {@link getPendingSwaps} plus the ones
+     * that already ended. The two sets are disjoint: a swap leaves `monitored`
+     * as it enters `finished`.
+     *
+     * The finished half is what this process has seen, which after
+     * {@link restoreFromRepository} is the stored history minus what retention
+     * pruned. A manager that has restored nothing answers with the live swaps
+     * alone.
+     */
+    getAllSwaps(): Promise<RfqSwap[]>;
     hasSwap(rfqId: string): Promise<boolean>;
     /** True while an action for this swap holds the per-swap lock. */
     isProcessing(rfqId: string): Promise<boolean>;
@@ -1611,7 +1656,7 @@ declare class RfqSwapManager {
     /**
      * Record which ark transactions ended the lockup.
      *
-     * Only the ones the indexer actually named: `LockupSpend.arkTxid` is
+     * Only the ones the indexer actually named: `LockupSpend.txid` is
      * optional, and a checkpoint txid is not what history correlates on — a
      * record carrying one would name a transaction the wallet's own activity
      * never shows. Fewer txids is the right failure here.
@@ -1655,10 +1700,9 @@ declare class RfqSwapManager {
     /**
      * Drop a terminal swap from monitoring and report it exactly once.
      *
-     * `onSwapCompleted` and `onSwapFailed` are mutually exclusive here, unlike
-     * Boltz's manager, which fires completion for every swap that leaves
-     * monitoring including the failed ones — a listener named "completed" that
-     * also fires on failure is a trap worth not inheriting.
+     * `onSwapCompleted` and `onSwapFailed` are mutually exclusive here: a
+     * listener named "completed" that also fires on failure is a trap, so a
+     * swap that leaves monitoring reports through exactly one of them.
      */
     private finalize;
     private settleWaiters;
@@ -1758,7 +1802,7 @@ interface RfqSwapOrigin {
      * learns it. So it is written once at record creation, like {@link amount},
      * and no corridor `project` emits it.
      */
-    fundingArkTxid?: string;
+    fundingTxid?: string;
 }
 /** The stored record: the origin plus the manager's mutable state. */
 interface RfqSwapRecord extends RfqSwapOrigin {
@@ -1766,14 +1810,37 @@ interface RfqSwapRecord extends RfqSwapOrigin {
     state: RfqSwapState;
     createdAt: number;
     updatedAt: number;
-    refundArkTxid?: string;
+    refundTxid?: string;
     /** The ark transactions that spent the lockup, stamped by the manager from
      * the chain read that ended the swap. See
-     * `RfqSwapCommon.lockupSpendArkTxids`. */
-    lockupSpendArkTxids?: string[];
+     * `RfqSwapCommon.lockupSpendTxids`. */
+    lockupSpendTxids?: string[];
     failure?: string;
     blockedReason?: string;
 }
+/**
+ * A stored record read under the current field names.
+ *
+ * Four fields were renamed after `0.0.9`: `fundingArkTxid`, `refundArkTxid`,
+ * `lockupSpendArkTxids`, and the receive corridor's `profile.claimArkTxid`. All
+ * four arrived together with record persistence itself in `0.0.8`, so `0.0.8`
+ * and `0.0.9` are the only versions that ever wrote them. Backends store the
+ * record WHOLE, so such a store still holds the old names on disk and the
+ * current code reads every one of them as `undefined`.
+ *
+ * Called by every function here that takes a record, so a consumer needs no
+ * boot-time migration of its own; and because the old keys never reach the
+ * object handed back, the next write persists the record without them.
+ *
+ * What it buys, in descending order of sharpness: a receive leg with a partial
+ * claim already out keeps its `claimTxid`, so the value gate stays disarmed
+ * rather than re-blocking the rest of a lockup whose preimage is public;
+ * `refunded` swaps report an outcome txid again; and activity answers from the
+ * record instead of falling back to a lockup read per query. It is NOT a
+ * re-refund fix — `refunded` is terminal, and `restoreFromRepository` puts a
+ * terminal record straight into `finished` without ever driving it.
+ */
+declare function normalizeRfqSwapRecord(record: RfqSwapRecord): RfqSwapRecord;
 /** First write, at the moment the caller hands the swap to the manager. */
 declare function createRfqSwapRecord(origin: RfqSwapOrigin, swap: PersistableRfqSwap): RfqSwapRecord;
 /**
@@ -1792,7 +1859,7 @@ declare function updateRfqSwapRecord(record: RfqSwapRecord, swap: PersistableRfq
  * A record IS an origin plus manager state, so `record` where an
  * {@link RfqSwapOrigin} is wanted type-checks — and is a bug. Spread into
  * {@link createRfqSwapRecord} it carries the OLD state's `failure`,
- * `blockedReason` and `refundArkTxid` past `managerState`, which omits a field
+ * `blockedReason` and `refundTxid` past `managerState`, which omits a field
  * the live swap no longer has and therefore cannot clear one. That is the same
  * trap {@link updateRfqSwapRecord} strips those three fields to avoid; this is
  * how a caller holding only a record gets an origin that is safe to keep.
@@ -1838,9 +1905,8 @@ interface MarketsCacheEntry {
 }
 /**
  * Everything the package persists, following the monorepo repository
- * convention (versioned interface, AsyncDisposable, one backend per
- * platform — see the Boltz plugin's SwapRepository). Consumers construct
- * exactly one of these; there is no second storage seam.
+ * convention: versioned interface, AsyncDisposable, one backend per platform.
+ * Consumers construct exactly one of these; there is no second storage seam.
  *
  * Durable records (swaps) and rebuildable state (the restore scan's txid
  * cursor, the markets cache) live side by side because they share a
@@ -1848,8 +1914,7 @@ interface MarketsCacheEntry {
  * that wipes one wants all three gone.
  *
  * ponytail: no query filters — every consumer reads all swaps and filters
- * in memory; mirror the Boltz plugin's GetSwapsFilter when a consumer needs
- * subset queries.
+ * in memory; add a filter type when a consumer needs subset queries.
  */
 interface AssetSwapRepository extends AsyncDisposable {
     /** 4 adds `getRfqSwap`. 3 added the other RFQ methods below; 2 was the
@@ -1916,4 +1981,4 @@ declare class InMemoryAssetSwapRepository implements AssetSwapRepository {
     [Symbol.asyncDispose](): Promise<void>;
 }
 
-export { isRfqSwapTerminal as $, type AssetSwapRepository as A, BTC_ASSET_ID as B, type RfqSwapActionName as C, type RfqSwapLockup as D, RfqSwapManager as E, type RfqSwapManagerCallbacks as F, type RfqSwapManagerConfig as G, type RfqSwapManagerDeps as H, InMemoryAssetSwapRepository as I, type RfqSwapManagerEvents as J, type RfqSwapOrigin as K, type LockupVtxo as L, type MarketsCacheEntry as M, RfqSwapOriginRequired as N, type OnchainSendAction as O, type PersistableRfqSwap as P, type RfqSwapOutcome as Q, type RfqSwapRecord as R, type SwapSecretsProjection as S, type RfqSwapRecordStore as T, type SwapContractRegistry as U, addAssetSwap as V, awaitRfqResolution as W, createRfqSwapRecord as X, findLockupVtxos as Y, getAssetSwaps as Z, getAssetSwapsOrThrow as _, type AssetSwap as a, isRfqTerminal as a0, nextOnchainAction as a1, preimageForSwapRecord as a2, pushRefundWithoutReceiver as a3, readLockupFate as a4, rebuildRfqSwap as a5, refundIfUnresolved as a6, rfqSwapOriginOf as a7, shouldRetainRfqSwap as a8, swapSecretsToRecord as a9, updateAssetSwap as aa, updateAssetSwapBestEffort as ab, updateRfqSwapRecord as ac, type RefundArkProvider as b, type RefundIndexer as c, type RfqSwap as d, type ArkadeRefundResult as e, type LockupSpendIndexer as f, type RfqSwapState as g, type AssetSwapStatus as h, type AvailableRfqSwapManagerCallbacks as i, type LightningReceiveSwap as j, type LightningSendSwap as k, type LockupFate as l, LockupNeedsRecoveryError as m, type LockupParams as n, type LockupSpend as o, type OnchainSendSwap as p, type PreimageBlockedReason as q, PreimageNotRecoverableError as r, REFUND_MTP_LAG_SECONDS as s, RFQ_RESOLVED_STATES as t, RFQ_SWAP_RETENTION_SECONDS as u, RFQ_SWAP_TERMINAL_STATES as v, type RefundOutcome as w, type RfqRestoreFailure as x, type RfqRestoreOptions as y, type RfqRestoreResult as z };
+export { isRfqSwapTerminal as $, type AssetSwapRepository as A, BTC_ASSET_ID as B, type RfqRestoreOptions as C, type RfqRestoreResult as D, type RfqSwapActionName as E, type RfqSwapLockup as F, type RfqSwapManagerConfig as G, type RfqSwapManagerDeps as H, InMemoryAssetSwapRepository as I, type RfqSwapManagerEvents as J, type RfqSwapOrigin as K, type LockupVtxo as L, type MarketsCacheEntry as M, RfqSwapOriginRequired as N, type OnchainSendAction as O, type PersistableRfqSwap as P, type RfqSwapOutcome as Q, type RfqSwapRecord as R, type SwapSecretsProjection as S, type RfqSwapRecordStore as T, type SwapContractRegistry as U, addAssetSwap as V, awaitRfqResolution as W, createRfqSwapRecord as X, findLockupVtxos as Y, getAssetSwaps as Z, getAssetSwapsOrThrow as _, type AssetSwap as a, isRfqTerminal as a0, nextOnchainAction as a1, normalizeRfqSwapRecord as a2, preimageForSwapRecord as a3, pushRefundWithoutReceiver as a4, readLockupFate as a5, rebuildRfqSwap as a6, refundIfUnresolved as a7, rfqSwapOriginOf as a8, shouldRetainRfqSwap as a9, swapSecretsToRecord as aa, updateAssetSwap as ab, updateAssetSwapBestEffort as ac, updateRfqSwapRecord as ad, type RefundIndexer as b, type SwapOperator as c, type RfqSwap as d, type ArkadeRefundResult as e, type LockupSpendIndexer as f, type RfqSwapState as g, RfqSwapManager as h, type RfqSwapManagerCallbacks as i, type AssetSwapStatus as j, type AvailableRfqSwapManagerCallbacks as k, type LightningReceiveSwap as l, type LightningSendSwap as m, type LockupFate as n, LockupNeedsRecoveryError as o, type LockupParams as p, type LockupSpend as q, type OnchainSendSwap as r, type PreimageBlockedReason as s, PreimageNotRecoverableError as t, REFUND_MTP_LAG_SECONDS as u, RFQ_RESOLVED_STATES as v, RFQ_SWAP_RETENTION_SECONDS as w, RFQ_SWAP_TERMINAL_STATES as x, type RefundOutcome as y, type RfqRestoreFailure as z };