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

package/dist/{repository-B02vsgcV.d.cts → 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-DkckzRKK.cjs';
+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
@@ -370,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. */
@@ -501,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
@@ -514,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;
 }>;
 /**
@@ -536,7 +533,7 @@ type RefundOutcome =
 /** The trader took it back via `refundWithoutReceiver`. */
  | {
     outcome: "refunded";
-    arkTxid: string;
+    txid: string;
     amount: number;
     status: RfqStatus | null;
 }
@@ -619,9 +616,9 @@ type RefundOutcome =
  * 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: LockupSpendIndexer, 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;
     /**
@@ -787,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.
@@ -796,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
@@ -805,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},
@@ -872,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.
@@ -883,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
@@ -942,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;
 /**
@@ -993,7 +990,7 @@ interface RfqSwapManagerCallbacks {
          * funding that arrived piecemeal can still be swept. */
         partiallyClaimed: boolean;
     }) => Promise<{
-        arkTxid: string;
+        txid: string;
         amount: number;
     }>;
     /**
@@ -1107,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">;
 /**
@@ -1487,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>;
@@ -1648,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.
@@ -1692,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;
@@ -1795,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 {
@@ -1803,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;
 /**
@@ -1829,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.
@@ -1875,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
@@ -1885,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
@@ -1953,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 };

package/dist/{rfq-DkckzRKK.d.ts → rfq-CzCGjICq.d.cts}

@@ -1,4 +1,4 @@
-import { VHTLC, asset, IWallet, ProvisionedClaimSecret, ProvisionedKey } from '@arkade-os/sdk';
+import { VHTLC, IWallet, ProvisionedClaimSecret, ProvisionedKey, asset } from '@arkade-os/sdk';
 
 /** L1 confirmation-depth and reorg margin between dependent timelocks. */
 declare const ONCHAIN_ORDER_MARGIN_SECONDS: number;
@@ -251,6 +251,10 @@ type RfqRefusalReason = "unsupported_pair" | "unsupported_payload" | "amount_out
 declare const RFQ_TERMINAL_STATES: readonly ["settled", "refused", "expired", "refunded", "stuck"];
 /** A refusal from the solver, carrying its closed-set reason. */
 declare class SwapRefusal extends Error {
+    /** Literal-typed so the v2 error taxonomy's union discriminates on `name`
+     * — a `string` here collapses the discriminant for every member. Same value
+     * the constructor has always set, moved to a field initializer. */
+    readonly name = "SwapRefusal";
     readonly reason: string;
     readonly rfqId: string | undefined;
     constructor(reason: string, rfqId?: string);
@@ -297,7 +301,7 @@ interface RfqStatus {
 /** The rfq_request for the lightning send profile. A BOLT11 profile is always
  * exact-out: the invoice fixes the amount, so none is restated here.
  * `senderPubkey` is the trader's own key for the VHTLC's sender-side leaves
- * (see {@link lightningSendVtxoScript}) — required, never sent anywhere else,
+ * (see {@link lightningSendContract}) — required, never sent anywhere else,
  * never trusted by the solver as anything but a pubkey to bind into the
  * script. On the wire it's `client_refund_pubkey` (the payload schemas are
  * public at https://docs.arkadeos.com/intents/reference/rfq — the solver's schema
@@ -416,7 +420,7 @@ declare const SOLO_REFUND_HEADROOM_SECONDS: number;
  * exit delay exactly as the reference solver derives it — both sides read the
  * SAME server, so the derivation (not a quote field) is what keeps the two
  * scripts identical. */
-declare const unilateralClaimDelay: (serverExitDelaySeconds: number) => number;
+declare const unilateralClaimDelay: (operatorExitDelaySeconds: number) => number;
 /** VHTLC's `unilateralRefund` tier: sender + receiver, no server — LEVEL with
  * `claimDelay`, not above it. Neither party can spend a two-signature leaf
  * alone, so separating it buys no safety, and every second spent separating it
@@ -444,13 +448,13 @@ declare const unilateralRefundWithoutReceiverDelay: (claimDelay: number) => numb
  * needing no participant at all). Nine leaves in all, unless `legacy` says
  * otherwise.
  */
-declare function lightningSendVtxoScript(params: {
+declare function lightningSendContract(params: {
     /** Binding field #1: the solver's x-only key, from the quote. */
     solverPubkey: Uint8Array;
     /** Binding field #2: when the trader's refund path opens, from the quote. */
     refundLocktime: number;
     /** The Ark server's x-only key — the trader's OWN connection. */
-    serverPubkey: Uint8Array;
+    operatorPubkey: Uint8Array;
     /** BOLT11 payment hash, hex — from the trader's OWN invoice decode. */
     paymentHash: string;
     /** From {@link unilateralClaimDelay} over the trader's OWN server info.
@@ -477,9 +481,9 @@ declare function lightningSendVtxoScript(params: {
      * the quote's own address says the solver quoted that shape. */
     legacy?: "preTimelockedRefund";
 }): InstanceType<typeof VHTLC.ScriptV2>;
-/** Every input {@link lightningSendVtxoScript} builds from. Derived from the
+/** Every input {@link lightningSendContract} builds from. Derived from the
  * builder rather than restated, so the two cannot drift. */
-type LightningSendTreeParams = Parameters<typeof lightningSendVtxoScript>[0];
+type LightningSendContractParams = Parameters<typeof lightningSendContract>[0];
 /** The BOLT11 facts the trader read from its OWN decode — this module takes
  * the facts, not the decoder, so any wallet's existing decoder serves. */
 interface InvoiceFacts {
@@ -513,14 +517,15 @@ interface InvoiceFacts {
  * throws while nothing is funded. `RfqSwapManager` re-registers as a backstop
  * for older records; a repeat write is a no-op.
  *
- * The `sender` key is the wallet's identity key, reused by {@link
- * provisionRefundKey} — returned as `senderPubkey` plus `secrets`. `secrets`
- * holds only a public descriptor; the signer re-derives from the wallet, so
- * nothing secret is at rest. Persist `secrets` with the record anyway: it is
- * how the refund signer is found again. `nonInteractiveRefund` recovers the funds even without it — but it needs the SOLVER's active
- * cooperation, not just infrastructure uptime.
+ * The `sender` key is the wallet's identity key, as {@link provisionRefundKey}
+ * pins it — returned as `senderPubkey` plus `secrets`. `secrets` holds only a
+ * public descriptor; the signer re-derives from the wallet, so nothing secret
+ * is at rest. Persist `secrets` with the record anyway: it is how the refund
+ * signer is found again. `nonInteractiveRefund` recovers the funds even
+ * without it — but it needs the SOLVER's active cooperation, not just
+ * infrastructure uptime.
  */
-declare function requestLightningSend(wallet: IWallet, arkServerUrl: string, transport: RfqTransport, params: {
+declare function requestLightningSend(wallet: IWallet, transport: RfqTransport, params: {
     invoice: InvoiceFacts;
     rfqId?: string;
     /** Co-signer key override (33-byte compressed hex); see
@@ -553,7 +558,7 @@ declare function requestLightningSend(wallet: IWallet, arkServerUrl: string, tra
      *
      * Returned so a consumer can persist the swap without re-deriving any of
      * it. Half of these are not on the quote: `serverPubkey` and `claimDelay`
-     * come from this wallet's own `getInfo()`, `emulatorPubkey` from a
+     * come from this wallet's own `getArkadeInfo()`, `emulatorPubkey` from a
      * per-network pin, `refundPkScript` from `secrets` — decoded from the
      * refund address at provisioning time, the same address this call returns
      * as `refundAddress`.
@@ -565,7 +570,7 @@ declare function requestLightningSend(wallet: IWallet, arkServerUrl: string, tra
      * `VHTLCV2ContractHandler.serializeParams(script.options)`, the shape the
      * rebuild accepts.
      */
-    treeParams: LightningSendTreeParams;
+    contractParams: LightningSendContractParams;
 }>;
 /**
  * Map an arkade↔arkade quote onto `createOffer` terms. The trader takes the
@@ -648,7 +653,7 @@ declare function deriveOnchainSend(input: {
     quote: RfqQuote;
     paymentHash: string;
     payoutPubkey: Uint8Array;
-    serverPubkey: Uint8Array;
+    operatorPubkey: Uint8Array;
     emulatorPubkey: Uint8Array;
     claimDelay: number;
     hrp: string;
@@ -699,7 +704,7 @@ declare function deriveOnchainSend(input: {
  *   `claimOnchainFill`) before `htlc.refundLocktime`. Missing that window
  *   forfeits the fill and falls back to the Arkade covenant refund.
  */
-declare function requestOnchainSend(wallet: IWallet, arkServerUrl: string, transport: RfqTransport, params: {
+declare function requestOnchainSend(wallet: IWallet, transport: RfqTransport, params: {
     amount: number;
     amountSide: "from" | "to";
     /** User's x-only L1 key that will claim the HTLC. */
@@ -747,6 +752,11 @@ declare function requestOnchainSend(wallet: IWallet, arkServerUrl: string, trans
     /** `profile.min_confirmations`; gates when the L1 fill becomes claimable,
      * and part of what a restored swap needs to drive its own claim. */
     minConfirmations: number;
+    /** The arkade lockup's refund deadline, as the covenant was built with it.
+     * Read this rather than `quote.refund_locktime`: that field is optional on
+     * the wire, a solver may carry the value in `profile` instead, and
+     * `deriveOnchainSend` is what settles which one this contract used. */
+    refundLocktime: number;
     /** The VHTLC `sender` x-only key, bound into the covenant. Public. */
     senderPubkey: Uint8Array;
     /** How the preimage and the `sender` key are recovered later — map it
@@ -813,12 +823,12 @@ declare const assertReceivable: (input: {
     maxPayAmount?: number;
 }) => void;
 /** Compile the RECEIVE-direction VHTLC: the same suite-carrying tree as {@link
- * lightningSendVtxoScript} with the roles inverted — the trader is the
+ * lightningSendContract} with the roles inverted — the trader is the
  * `receiver` (it generated `P` and claims the lockup with it), the solver is
  * the `sender` (it funds the lockup and holds the refund recourse). One
  * function shared by both receive corridors, mirroring the send legs' sharing
- * of `lightningSendVtxoScript`. */
-declare function receiveVtxoScript(params: {
+ * of `lightningSendContract`. */
+declare function lightningReceiveContract(params: {
     /** Binding field #1: the solver's x-only key, from the quote — VHTLC's
      * `sender` role on the receive corridors. */
     solverPubkey: Uint8Array;
@@ -826,7 +836,7 @@ declare function receiveVtxoScript(params: {
      * the quote — after it the solver may reclaim an unclaimed lockup. */
     refundLocktime: number;
     /** The Ark server's x-only key — the trader's OWN connection. */
-    serverPubkey: Uint8Array;
+    operatorPubkey: Uint8Array;
     /** `sha256(P)`, hex — the trader's OWN preimage hash. */
     paymentHash: string;
     /** From {@link unilateralClaimDelay} over the trader's OWN server info. */
@@ -846,9 +856,9 @@ declare function receiveVtxoScript(params: {
     /** LEGACY REBUILD ONLY — see {@link lightningSendVtxoScript}'s `legacy`. */
     legacy?: "preTimelockedRefund";
 }): InstanceType<typeof VHTLC.ScriptV2>;
-/** Every input {@link receiveVtxoScript} builds from; see
- * {@link LightningSendTreeParams}. */
-type LightningReceiveTreeParams = Parameters<typeof receiveVtxoScript>[0];
+/** Every input {@link lightningReceiveContract} builds from; see
+ * {@link LightningSendContractParams}. */
+type LightningReceiveContractParams = Parameters<typeof lightningReceiveContract>[0];
 /**
  * The pure core of {@link requestLightningReceive}: derive the solver-funded
  * covenant locally from the quote's binding fields plus the trader's own data
@@ -862,7 +872,7 @@ declare function deriveLightningReceive(input: {
     paymentHash: string;
     payoutPubkey: Uint8Array;
     payoutAddress: string;
-    serverPubkey: Uint8Array;
+    operatorPubkey: Uint8Array;
     emulatorPubkey: Uint8Array;
     claimDelay: number;
     hrp: string;
@@ -875,7 +885,7 @@ declare function deriveLightningReceive(input: {
     refundLocktime: number;
     /** Every input the covenant was built from — see the same field on
      * `requestLightningSend`'s result for why a consumer needs them. */
-    treeParams: LightningReceiveTreeParams;
+    contractParams: LightningReceiveContractParams;
 };
 /**
  * The `lightning:BTC->arkade:BTC` user flow: quote → derive the covenant
@@ -908,7 +918,7 @@ declare function deriveLightningReceive(input: {
  * Pay before `invoiceExpiresAt`: the hold-invoice window is minutes, not the
  * quote's `valid_until`.
  */
-declare function requestLightningReceive(wallet: IWallet, arkServerUrl: string, transport: RfqTransport, params: {
+declare function requestLightningReceive(wallet: IWallet, transport: RfqTransport, params: {
     amount: number;
     amountSide: "from" | "to";
     /** Co-signer key override (33-byte compressed hex); see
@@ -953,7 +963,7 @@ declare function requestLightningReceive(wallet: IWallet, arkServerUrl: string,
     secrets: ProvisionedClaimSecret;
     /** Every input the covenant was built from; see the same field on
      * `requestLightningSend`'s result. */
-    treeParams: LightningReceiveTreeParams;
+    contractParams: LightningReceiveContractParams;
 }>;
 /**
  * The pure core of {@link requestOnchainReceive}: derive BOTH contracts
@@ -969,7 +979,7 @@ declare function deriveOnchainReceive(input: {
     payoutAddress: string;
     /** The trader's own x-only L1 key — the HTLC's refund role. */
     refundPubkey: Uint8Array;
-    serverPubkey: Uint8Array;
+    operatorPubkey: Uint8Array;
     emulatorPubkey: Uint8Array;
     claimDelay: number;
     hrp: string;
@@ -997,7 +1007,7 @@ declare function deriveOnchainReceive(input: {
  * `refundPubkey`) opens at `htlc.refundLocktime` — `buildHtlcRefund` takes it
  * back from there.
  */
-declare function requestOnchainReceive(wallet: IWallet, arkServerUrl: string, transport: RfqTransport, params: {
+declare function requestOnchainReceive(wallet: IWallet, transport: RfqTransport, params: {
     amount: number;
     amountSide: "from" | "to";
     /** Co-signer key override (33-byte compressed hex); see
@@ -1030,4 +1040,4 @@ declare function requestOnchainReceive(wallet: IWallet, arkServerUrl: string, tr
     secrets: ProvisionedClaimSecret;
 }>;
 
-export { newRfqId as $, ARKADE_ASSET as A, arkadeAssetLeg as B, type ChainSource as C, arkadeSwapRequest as D, assertFundable as E, assertReceivable as F, awaitOnchainFill as G, type HtlcUtxo as H, type InvoiceFacts as I, buildHtlcClaim as J, buildHtlcRefund as K, LIGHTNING_BTC as L, MAX_MIN_CONFIRMATIONS as M, claimOnchainFill as N, type OnchainNetwork as O, classifyOnchainHtlc as P, deriveLightningReceive as Q, RFQ_TERMINAL_STATES as R, SOLO_REFUND_HEADROOM_SECONDS as S, deriveOnchainReceive as T, deriveOnchainSend as U, extractPreimage as V, httpTransport as W, lightningReceiveRequest as X, lightningSendRequest as Y, lightningSendVtxoScript as Z, newPreimage as _, type OnchainHtlc as a, offerTermsFromQuote as a0, onchainHtlcScript as a1, onchainReceiveRequest as a2, onchainSendRequest as a3, paymentHashOf as a4, receiveVtxoScript as a5, relayTransport as a6, requestLightningReceive as a7, requestLightningSend as a8, requestOnchainReceive as a9, requestOnchainSend as aa, rfqPair as ab, unilateralClaimDelay as ac, unilateralRefundDelay as ad, unilateralRefundWithoutReceiverDelay as ae, verifyLockupAddress as af, verifyReceiveInvoice as ag, type OnchainHtlcParams as b, ARKADE_BTC as c, AddressMismatch as d, type ChainUtxo as e, LIGHTNING_RECEIVE_PAIR as f, LIGHTNING_SEND_PAIR as g, LOCKTIME_THRESHOLD as h, type LightningReceiveTreeParams as i, type LightningSendTreeParams as j, MIN_CLAIM_WINDOW_SECONDS as k, MIN_HEADROOM_SECONDS as l, ONCHAIN_BTC as m, ONCHAIN_CLAIM_MARGIN_SECONDS as n, ONCHAIN_DUST_SATS as o, ONCHAIN_ORDER_MARGIN_SECONDS as p, ONCHAIN_RECEIVE_PAIR as q, ONCHAIN_SECONDS_PER_BLOCK as r, ONCHAIN_SEND_PAIR as s, type OnchainHtlcPhase as t, type RelaySocket as u, type RfqQuote as v, type RfqRefusalReason as w, type RfqStatus as x, type RfqTransport as y, SwapRefusal as z };
+export { lightningReceiveRequest as $, ARKADE_ASSET as A, type RfqRefusalReason as B, type ChainSource as C, type RfqStatus as D, SwapRefusal as E, arkadeAssetLeg as F, arkadeSwapRequest as G, type HtlcUtxo as H, type InvoiceFacts as I, assertFundable as J, assertReceivable as K, LIGHTNING_BTC as L, MAX_MIN_CONFIRMATIONS as M, awaitOnchainFill as N, type OnchainNetwork as O, buildHtlcClaim as P, buildHtlcRefund as Q, type RfqTransport as R, SOLO_REFUND_HEADROOM_SECONDS as S, claimOnchainFill as T, classifyOnchainHtlc as U, deriveLightningReceive as V, deriveOnchainReceive as W, deriveOnchainSend as X, extractPreimage as Y, httpTransport as Z, lightningReceiveContract as _, type OnchainHtlc as a, lightningSendContract as a0, lightningSendRequest as a1, newPreimage as a2, newRfqId as a3, offerTermsFromQuote as a4, onchainHtlcScript as a5, onchainReceiveRequest as a6, onchainSendRequest as a7, paymentHashOf as a8, relayTransport as a9, requestOnchainReceive as aa, rfqPair as ab, unilateralClaimDelay as ac, unilateralRefundDelay as ad, unilateralRefundWithoutReceiverDelay as ae, verifyLockupAddress as af, verifyReceiveInvoice as ag, type OnchainHtlcParams as b, requestLightningSend as c, requestOnchainSend as d, ARKADE_BTC as e, AddressMismatch as f, type ChainUtxo as g, LIGHTNING_RECEIVE_PAIR as h, LIGHTNING_SEND_PAIR as i, LOCKTIME_THRESHOLD as j, type LightningReceiveContractParams as k, type LightningSendContractParams as l, MIN_CLAIM_WINDOW_SECONDS as m, MIN_HEADROOM_SECONDS as n, ONCHAIN_BTC as o, ONCHAIN_CLAIM_MARGIN_SECONDS as p, ONCHAIN_DUST_SATS as q, requestLightningReceive as r, ONCHAIN_ORDER_MARGIN_SECONDS as s, ONCHAIN_RECEIVE_PAIR as t, ONCHAIN_SECONDS_PER_BLOCK as u, ONCHAIN_SEND_PAIR as v, type OnchainHtlcPhase as w, RFQ_TERMINAL_STATES as x, type RelaySocket as y, type RfqQuote as z };