@arkade-os/swap 0.0.3 → 0.0.5

package/dist/nostr.d.ts

@@ -1,7 +1,6 @@
-import { b as RfqTransport } from './rfq-CCAFoFtR.js';
+import { a as RfqTransport } from './rfq-BH2yvo3O.js';
 import { SimplePool } from 'nostr-tools';
 import '@arkade-os/sdk';
-import '@arkade-os/solver-discovery';
 
 /**
  * The Nostr RFQ transport — the PRODUCTION one (docs/rfq-protocol.md § 3.1 in
@@ -71,6 +70,18 @@ declare class RelayUnavailable extends Error {
     readonly reasons: string[];
     constructor(reasons: string[]);
 }
+/**
+ * `close()` was called while a negotiation was still waiting on a reply.
+ *
+ * Distinct from both a timeout and {@link RelayUnavailable}, which describe the
+ * wire; this describes a decision on our own side of it. A caller that closed
+ * deliberately — a user leaving the screen, a flow abandoning its request — can
+ * match on this and stay quiet, rather than reporting a solver failure that
+ * never happened.
+ */
+declare class TransportClosed extends Error {
+    constructor();
+}
 interface NostrRfqOptions {
     /** Relay URLs from the solver's card. The rendezvous, not solver endpoints. */
     relays: string[];
@@ -96,4 +107,4 @@ interface NostrRfqOptions {
  */
 declare const nostrRfqTransport: (options: NostrRfqOptions) => RfqTransport;
 
-export { type NostrRfqOptions, RFQ_AD_KIND, RFQ_DIRECTED_KIND, RelayUnavailable, nostrRfqTransport };
+export { type NostrRfqOptions, RFQ_AD_KIND, RFQ_DIRECTED_KIND, RelayUnavailable, TransportClosed, nostrRfqTransport };

package/dist/nostr.js

@@ -1,6 +1,6 @@
 import {
   SwapRefusal
-} from "./chunk-HLMMA3LJ.js";
+} from "./chunk-Q4FAYBXS.js";
 
 // src/nostr.ts
 import {
@@ -21,6 +21,12 @@ var RelayUnavailable = class extends Error {
     this.reasons = reasons;
   }
 };
+var TransportClosed = class extends Error {
+  constructor() {
+    super("transport closed before the solver replied");
+    this.name = "TransportClosed";
+  }
+};
 var closeReasons = (raw) => raw.map((entry) => {
   if (typeof entry === "string") return entry;
   const { url, reason } = entry ?? {};
@@ -120,9 +126,10 @@ var nostrRfqTransport = (options) => {
     },
     async close() {
       closed = true;
-      subscription.close();
+      for (const waiter of waiters.values()) waiter.reject(new TransportClosed());
       waiters.clear();
       if (ownsPool) pool.close(relays);
+      else subscription.close();
     }
   };
 };
@@ -130,5 +137,6 @@ export {
   RFQ_AD_KIND,
   RFQ_DIRECTED_KIND,
   RelayUnavailable,
+  TransportClosed,
   nostrRfqTransport
 };

package/dist/{rfq-CCAFoFtR.d.cts → rfq-BH2yvo3O.d.cts}

@@ -1,150 +1,4 @@
-import { ReadonlyIdentity, IWallet, Identity, asset, VHTLC } from '@arkade-os/sdk';
-import { DiscoveredMarket } from '@arkade-os/solver-discovery';
-
-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.
- * Lives here with the {@link AssetSwap} fields it describes so the market and
- * restore layers share one spelling instead of re-typing the literal. */
-declare const BTC_ASSET_ID = "btc";
-interface AssetSwapFallbackSecretsV1 {
-    version: 1;
-    type: "stored";
-    senderPrivateKeyHex: string;
-    /** Onchain-send only. A lightning send's preimage belongs to the payee. */
-    preimageHex?: string;
-}
-type AssetSwapFallbackSecrets = AssetSwapFallbackSecretsV1;
-interface AssetSwap {
-    /** Funding txid — the swap's identity. */
-    id: string;
-    /** 'btc' or a 68-hex asset id. */
-    fromAsset: string;
-    toAsset: string;
-    /** Atomic amounts as strings (bigint is not JSON-safe). */
-    fromAmount: string;
-    /** The covenant wantAmount — a floor, the fill pays >= this. */
-    toAmount: string;
-    swapAddress: string;
-    /** Hex pkScript of the swap contract — the indexer monitoring key. */
-    swapPkScript: string;
-    /** TLV offer — needed to rebuild the contract for cancel. */
-    offerHex: string;
-    fundingTxid: string;
-    spentTxid?: string;
-    status: AssetSwapStatus;
-    createdAt: number;
-    completedAt?: number;
-    /** RFQ pair string, e.g. `arkade:BTC->onchain:BTC`. */
-    pair?: string;
-    /** `sha256(P)`, hex. Public, and how a restore confirms a candidate
-     * derivation is the right one. */
-    paymentHash?: string;
-    /**
-     * The HD descriptor this swap's secrets derive from. Public — it is what
-     * lets the record carry no secrets at all. Present iff the swap was
-     * created on a wallet that can allocate.
-     */
-    signingDescriptor?: string;
-    /** P, hex, when the user supplied a preimage that is not seed-derived. */
-    preimageHex?: string;
-    /**
-     * Complete stored-arm secrets for wallets that cannot derive. Versioned
-     * and discriminated so restore can rebuild both the sender identity and,
-     * for onchain sends, P.
-     */
-    fallbackSecrets?: AssetSwapFallbackSecrets;
-    /** The L1 HTLC's pkScript, hex — the chain-watch key. */
-    htlcPkScriptHex?: string;
-    htlcLocktime?: number;
-    /** The L1 funding txid, once observed. */
-    l1Txid?: string;
-}
-/** All swaps, newest-first. Insertion order is not chronological — the restore
- * scan rebuilds records in tx-scan order — so sort at read to keep
- * newest-first canonical for every consumer. */
-declare const getAssetSwapsOrThrow: (repository: AssetSwapRepository) => Promise<AssetSwap[]>;
-/** The consumer read: a broken backend reads as no swaps rather than crashing
- * a history view. Mutations must use {@link getAssetSwapsOrThrow} instead —
- * swallowing the read there would let "the backend is gone" masquerade as "no
- * such swap" and skip the write silently. */
-declare const getAssetSwaps: (repository: AssetSwapRepository) => Promise<AssetSwap[]>;
-/** Add a swap; no-op if the id is already stored. Returns the updated list.
- * THROWS on a failed write — nothing irreversible may happen until this record
- * is durable, so the caller must not fund on a failure. */
-declare const addAssetSwap: (repository: AssetSwapRepository, swap: AssetSwap) => Promise<AssetSwap[]>;
-/** Merge changes into a swap by id. Returns the updated list.
- * THROWS on a failed read or write, like {@link addAssetSwap} — use this for a
- * write that gates something irreversible. Transitions written *after* the
- * irreversible act belong on {@link updateAssetSwapBestEffort}. */
-declare const updateAssetSwap: (repository: AssetSwapRepository, id: string, changes: Partial<Omit<AssetSwap, "id">>) => Promise<AssetSwap[]>;
-/**
- * {@link updateAssetSwap} for transitions that follow an irreversible action (a
- * broadcast claim, a spent lockup): failing the caller there would report as
- * failed a swap whose funds already moved, and a stale status is recoverable —
- * crash recovery re-derives the true state from the chain
- * (`classifyOnchainHtlc`).
- *
- * `persisted` is the part that must not be hidden: a caller that notifies on a
- * change, or treats one as terminal, has to know the store did not agree.
- */
-declare const updateAssetSwapBestEffort: (repository: AssetSwapRepository, id: string, changes: Partial<Omit<AssetSwap, "id">>) => Promise<{
-    swaps: AssetSwap[];
-    persisted: boolean;
-}>;
-
-/** A registry discovery result held for reuse. Refetchable — unlike a swap
- * record, losing it costs one network round trip — but it must survive a cold
- * boot: serving it stale is what keeps quoting alive while a registry is down. */
-interface MarketsCacheEntry {
-    markets: DiscoveredMarket[];
-    fetchedAt: number;
-}
-/**
- * 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.
- *
- * Durable records (swaps) and rebuildable state (the restore scan's txid
- * cursor, the markets cache) live side by side because they share a
- * lifetime: all three belong to one wallet on one device, and a consumer
- * 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.
- */
-interface AssetSwapRepository extends AsyncDisposable {
-    readonly version: 1;
-    /** Insert or replace a swap by id. Store the record whole: `fallbackSecrets`
-     * is secret-bearing, and a field-mapped backend that drops it loses the
-     * stored arm's claim and refund keys. */
-    saveSwap(swap: AssetSwap): Promise<void>;
-    /** All stored swaps, in no particular order — `getAssetSwaps` is the
-     * canonical newest-first read. */
-    getAllSwaps(): Promise<AssetSwap[]>;
-    /** Sent txids already checked for offer packets (see restore.ts). */
-    getScannedTxids(): Promise<Set<string>>;
-    markTxidsScanned(txids: Iterable<string>): Promise<void>;
-    /** Cached registry markets, or undefined on a miss. */
-    getCachedMarkets(network: string, registry: string): Promise<MarketsCacheEntry | undefined>;
-    saveCachedMarkets(network: string, registry: string, entry: MarketsCacheEntry): Promise<void>;
-    clear(): Promise<void>;
-}
-declare class InMemoryAssetSwapRepository implements AssetSwapRepository {
-    readonly version: 1;
-    private readonly swaps;
-    private readonly scanned;
-    private readonly markets;
-    saveSwap(swap: AssetSwap): Promise<void>;
-    getAllSwaps(): Promise<AssetSwap[]>;
-    getScannedTxids(): Promise<Set<string>>;
-    markTxidsScanned(txids: Iterable<string>): Promise<void>;
-    getCachedMarkets(network: string, registry: string): Promise<MarketsCacheEntry | undefined>;
-    saveCachedMarkets(network: string, registry: string, entry: MarketsCacheEntry): Promise<void>;
-    clear(): Promise<void>;
-    [Symbol.asyncDispose](): Promise<void>;
-}
+import { asset, VHTLC, IWallet, ProvisionedClaimSecret, ProvisionedKey } from '@arkade-os/sdk';
 
 /** L1 confirmation-depth and reorg margin between dependent timelocks. */
 declare const ONCHAIN_ORDER_MARGIN_SECONDS: number;
@@ -356,168 +210,6 @@ declare function classifyOnchainHtlc(chain: ChainSource, input: {
     };
 }): Promise<OnchainHtlcPhase>;
 
-/**
- * Domain separator for the preimage derivation.
- *
- * NArk scopes its tag by protocol+provider (`Arkade-Boltz-Preimage-v1`,
- * `SwapsManagementService.cs:128`) so any Arkade SDK reproduces the same
- * preimage. NArk has no RFQ corridor yet, so this tag defines the scheme
- * rather than mirroring one; it is deliberately distinct from the Boltz tag,
- * or the same wallet key would derive one preimage for both corridors.
- */
-declare const RFQ_PREIMAGE_TAG = "Arkade-RFQ-Preimage-v1";
-/**
- * `TAG ‖ xonly(32) ‖ u32le(index)` — the message that gets BIP-340 signed.
- *
- * Anchored on the canonical x-only key rather than the descriptor string:
- * restore reconstructs a bare descriptor that serialises differently from the
- * signing descriptor used at create time, and only the key agrees across both.
- */
-declare function buildPreimageMessage(xonly: Uint8Array, index: number): Uint8Array;
-/** No secrets at rest: everything re-derives from the seed plus this. */
-interface DerivedSwapSecrets {
-    derivable: true;
-    /** Public. Persist it on the swap record; it is what restore keys off. */
-    signingDescriptor: string;
-    /** Onchain-send only, when the caller supplied P instead of deriving it. */
-    preimage?: Uint8Array;
-}
-/** The wallet could not allocate. These are real secrets — persist them. */
-interface StoredSwapSecrets {
-    derivable: false;
-    senderPrivateKey: Uint8Array;
-    /** Onchain-send only. A lightning send's preimage belongs to the payee. */
-    preimage?: Uint8Array;
-}
-/**
- * Which arm a swap got. The discriminant makes the persistence obligation a
- * type-level fact: a consumer written against {@link DerivedSwapSecrets} alone
- * fails to compile when handed the stored arm.
- */
-type SwapSecrets = DerivedSwapSecrets | StoredSwapSecrets;
-/**
- * Allocate a descriptor for one swap, or `undefined` when the wallet cannot.
- *
- * Allocates — never peeks. `getCurrentSigningDescriptor` returns the same
- * descriptor until the wallet rotates, and two swaps sharing a descriptor
- * derive the *identical* preimage, so one solver learning its own preimage
- * would learn the other swap's.
- *
- * Cost of allocating: the index is consumed even when the quote is later
- * refused, and a swap index never turns into a funded receive contract, so a
- * long run of swaps widens the "unused" gap a seed-only `restore()` scan sees
- * (see the README's gap-limit note). Restores that keep the swap repository
- * are unaffected — `adoptSwapDescriptor` re-claims each record's index.
- */
-declare function deriveSwapSecrets(wallet: IWallet): Promise<DerivedSwapSecrets | undefined>;
-/**
- * The fallback arm. Separate from {@link deriveSwapSecrets} so nothing can
- * fabricate a preimage while probing for a derived one.
- */
-declare function randomSwapSecrets(opts?: {
-    preimage?: boolean | Uint8Array;
-}): StoredSwapSecrets;
-/**
- * Serialize or restore the secrets arm a persisted record describes. Normal
- * HD swaps store only `signingDescriptor`; caller-supplied preimages add
- * `preimageHex`; fallback swaps use `fallbackSecrets` so both P and the
- * sender identity survive a restart.
- */
-declare function rfqSecretsToRecord(secrets: SwapSecrets): {
-    signingDescriptor?: string;
-    preimageHex?: string;
-    fallbackSecrets?: AssetSwapFallbackSecrets;
-};
-declare function rfqSecretsOfRecord(record: {
-    signingDescriptor?: string;
-    preimageHex?: string;
-    fallbackSecrets?: AssetSwapFallbackSecrets;
-}): SwapSecrets | undefined;
-/**
- * Claim a restored swap's index so a later allocation cannot reissue it —
- * which would derive that swap's preimage a second time, for a different swap.
- * Monotonic; a no-op on a wallet that cannot allocate.
- */
-declare function adoptSwapDescriptor(wallet: IWallet, signingDescriptor: string): Promise<void>;
-/** Why a wallet cannot produce a swap's sender key. Different instructions to
- * a user: restore the other wallet, or accept that this record never carried
- * the secrets at all. */
-type RefundBlockedReason = 
-/** The record names no arm: neither `signingDescriptor` nor `fallbackSecrets`. */
-"no-secrets"
-/** It names an arm this version cannot read. */
- | "unreadable-secrets"
-/** The descriptor belongs to another seed, or this wallet is static. */
- | "foreign-descriptor";
-/**
- * The wallet cannot produce this swap's sender key, so no local refund is
- * possible: not a failure to retry, a capability this wallet does not have.
- *
- * Thrown where the cause is discovered rather than translated at the edge, so
- * a `refundArkade` wired through {@link senderIdentityForSwapRecord} reports it
- * to `RfqSwapManager` unwrapped — which is what stops the manager grinding
- * against a push that can never work for the whole refund window.
- */
-declare class RefundNotLocallyPossibleError extends Error {
-    readonly reason: RefundBlockedReason;
-    readonly name = "RefundNotLocallyPossibleError";
-    constructor(reason: RefundBlockedReason, message: string, options?: {
-        cause?: unknown;
-    });
-}
-/**
- * The VHTLC `sender` identity — the signer for every interactive refund.
- *
- * The capability probe is not the check that matters: `signerForDescriptor`
- * falls back to the plain wallet identity for a descriptor it cannot derive —
- * a different seed, a static wallet — and that identity signs happily with the
- * wrong key, which surfaces only as a solver rejection or a dead claim script.
- * So the check is on what comes back: only a descriptor-bound signer carries
- * `signSchnorrDeterministic`.
- */
-declare function senderIdentityForRfqSecrets(wallet: IWallet, secrets: SwapSecrets): Promise<Identity>;
-/**
- * The VHTLC `sender` identity for a stored swap record, or a typed refusal.
- *
- * The record→identity composition {@link rfqSecretsOfRecord} deliberately does
- * not do: it stays total so history iteration can call it, so *this* is where
- * "no secrets on the record" becomes a refusal rather than an `undefined` the
- * caller has to remember to check.
- *
- * **Wire `refundArkade` here, not to {@link senderIdentityForRfqSecrets}.**
- * Only two of the three causes are throws; a caller one level down would skip
- * the third silently and turn it into a `TypeError` at the push site, which
- * `RfqSwapManager` then treats as retryable and grinds against for the whole
- * refund window.
- *
- * Takes the record shape structurally, matching {@link rfqSecretsOfRecord}, so
- * either record type can be passed.
- */
-declare function senderIdentityForSwapRecord(wallet: IWallet, record: {
-    signingDescriptor?: string;
-    preimageHex?: string;
-    fallbackSecrets?: AssetSwapFallbackSecrets;
-}): Promise<Identity>;
-/** The `sender` x-only pubkey, the only half the request flow needs. */
-declare function senderPubkeyForRfqSecrets(wallet: IWallet, secrets: SwapSecrets): Promise<Uint8Array>;
-/**
- * An identity that signs with `aux_rand = 0`, which is what makes the
- * derivation reproducible. `DescriptorIdentity` satisfies it and throws rather
- * than degrading to a random-aux signer.
- */
-interface DeterministicSigner extends ReadonlyIdentity {
-    signSchnorrDeterministic(messageHash: Uint8Array): Promise<Uint8Array>;
-}
-declare function isDeterministicSigner(value: unknown): value is DeterministicSigner;
-/**
- * `sha256(sign(sha256(msg)))`, with the signing key and the message key being
- * the same identity — passing a key in separately is how this silently derives
- * an unrecoverable preimage.
- */
-declare function derivePreimage(signer: DeterministicSigner): Promise<Uint8Array>;
-/** The onchain-send preimage, re-derived or read back off the stored arm. */
-declare function preimageForRfqSecrets(wallet: IWallet, secrets: SwapSecrets): Promise<Uint8Array>;
-
 /** Legs are `<corridor>:<asset>`; a pair is directional, `from->to`. Arkade
  * asset legs stay coarse (`arkade:ASSET`) — the exact asset ids ride the
  * request profile, mirroring how the offer TLV identifies assets. */
@@ -663,20 +355,38 @@ declare const relayTransport: (relayUrl: string, options: {
     WebSocketCtor?: new (url: string) => RelaySocket;
     timeoutMs?: number;
 }) => RfqTransport;
+/**
+ * How long the sender's SOLO refund opens after the receiver's claim, seconds.
+ *
+ * This is the window in which a claimant holding the preimage must be able to
+ * finish taking their money before the funder could take it back. On a live
+ * Arkade server that is one collaborative spend; with the server gone it is a
+ * full unilateral exit — an unroll broadcast per chain step, each waiting on a
+ * confirmation, then the CSV spend.
+ *
+ * 4096s (eight 512s units, ~68 minutes) is sized for that worst case. It is
+ * REASONED, not measured, and it mirrors `SOLO_REFUND_HEADROOM_SECONDS` in the
+ * reference solver's `src/core/timelocks.ts` — the two must move together or a
+ * trader derives an address the solver never quoted.
+ *
+ * A multiple of the granularity on purpose: BIP68 would round anything else,
+ * making the encoded timelock differ from the number written here.
+ */
+declare const SOLO_REFUND_HEADROOM_SECONDS: number;
 /** The solver's unilateral-claim delay, derived from the Ark server's reported
  * 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;
-/** VHTLC's `unilateralRefund` tier: sender + solver, no server, one 512s step
- * past `claimDelay` — the middle rung between the fully-collaborative paths
- * and the sender's last-resort `unilateralRefundWithoutReceiver`. Same
- * already-rounded `claimDelay` input as {@link unilateralClaimDelay}
- * produces — one rounding, shared across all three tiers. */
+/** 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
+ * is a second taken off the headroom that does matter. */
 declare const unilateralRefundDelay: (claimDelay: number) => number;
-/** VHTLC's `unilateralRefundWithoutReceiver` tier: sender alone, needs
- * nobody — two 512s steps past `claimDelay`, past {@link
- * unilateralRefundDelay}. */
+/** VHTLC's `unilateralRefundWithoutReceiver` tier: sender alone, needing
+ * nobody. The only leaf whose timing can steal — a funder able to refund
+ * before the claimant can claim takes money from someone holding the preimage
+ * — so it opens last, by {@link SOLO_REFUND_HEADROOM_SECONDS}. */
 declare const unilateralRefundWithoutReceiverDelay: (claimDelay: number) => number;
 /** Compile the lightning-send VHTLC from the quote's binding fields plus the
  * trader's own data. `paymentHash` is the BOLT11 payment hash (`sha256(P)`,
@@ -754,13 +464,13 @@ interface InvoiceFacts {
  * throws while nothing is funded. `RfqSwapManager` re-registers as a backstop
  * for older records; a repeat write is a no-op.
  *
- * Allocates a fresh `sender` key per call and returns it as `senderPubkey`
- * plus `secrets`. On an HD wallet `secrets` holds only a public descriptor and
- * nothing needs protecting; otherwise it holds the raw key and the caller MUST
- * persist it, or every interactive refund path is gone. `nonInteractiveRefund`
- * still recovers the funds without it — but it needs the SOLVER's active
- * cooperation, not just infrastructure uptime, so losing the key with an
- * unwilling solver is a total loss.
+ * The `sender` key comes from the wallet — a fresh HD descriptor per call, or
+ * the wallet's static key — and is 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: {
     invoice: InvoiceFacts;
@@ -786,9 +496,9 @@ declare function requestLightningSend(wallet: IWallet, arkServerUrl: string, tra
     refundAddress: string;
     /** The VHTLC `sender` x-only key, bound into the covenant. Public. */
     senderPubkey: Uint8Array;
-    /** How the `sender` key is recovered later. Persist it with the record —
-     * on the derivable arm it holds nothing secret. */
-    secrets: SwapSecrets;
+    /** How the `sender` key is recovered later. Persist it with the record;
+     * it holds nothing secret. */
+    secrets: ProvisionedKey;
 }>;
 /**
  * Map an arkade↔arkade quote onto `createOffer` terms. The trader takes the
@@ -939,9 +649,10 @@ declare function requestOnchainSend(wallet: IWallet, arkServerUrl: string, trans
     htlc: OnchainHtlc;
     /** The VHTLC `sender` x-only key, bound into the covenant. Public. */
     senderPubkey: Uint8Array;
-    /** How the preimage and the `sender` key are recovered later. Persist it
-     * with the record BEFORE funding. */
-    secrets: SwapSecrets;
+    /** How the preimage and the `sender` key are recovered later — map it
+     * through `swapSecretsToRecord` and persist BEFORE funding. Public unless
+     * `mustPersistPreimage` says the wallet could not derive P. */
+    secrets: ProvisionedClaimSecret;
 }>;
 /** Default floor for the window between the last moment the hold invoice can
  * be paid and the solver's refund leaf opening. */
@@ -1128,9 +839,10 @@ declare function requestLightningReceive(wallet: IWallet, arkServerUrl: string,
     payoutAddress: string;
     /** The trader's covenant `receiver` key, bound into the tree. Public. */
     payoutPubkey: Uint8Array;
-    /** How the preimage and the payout key are recovered later. Persist it
-     * with the record BEFORE paying the invoice. */
-    secrets: SwapSecrets;
+    /** How the preimage and the payout key are recovered later — map it
+     * through `swapSecretsToRecord` and persist BEFORE paying the invoice.
+     * Public unless `mustPersistPreimage` says the wallet could not derive P. */
+    secrets: ProvisionedClaimSecret;
 }>;
 /**
  * The pure core of {@link requestOnchainReceive}: derive BOTH contracts
@@ -1201,7 +913,10 @@ declare function requestOnchainReceive(wallet: IWallet, arkServerUrl: string, tr
     htlc: OnchainHtlc;
     payoutAddress: string;
     payoutPubkey: Uint8Array;
-    secrets: SwapSecrets;
+    /** How the preimage and the payout key are recovered later — map it
+     * through `swapSecretsToRecord` and persist BEFORE funding. Public unless
+     * `mustPersistPreimage` says the wallet could not derive P. */
+    secrets: ProvisionedClaimSecret;
 }>;
 
-export { buildPreimageMessage as $, type AssetSwapRepository as A, BTC_ASSET_ID as B, type ChainSource as C, type DerivedSwapSecrets as D, RFQ_TERMINAL_STATES as E, type RefundBlockedReason as F, RefundNotLocallyPossibleError as G, type HtlcUtxo as H, InMemoryAssetSwapRepository as I, type RelaySocket as J, type RfqQuote as K, LIGHTNING_BTC as L, type MarketsCacheEntry as M, type RfqRefusalReason as N, type OnchainHtlc as O, SwapRefusal as P, type SwapSecrets as Q, type RfqStatus as R, type StoredSwapSecrets as S, addAssetSwap as T, adoptSwapDescriptor as U, arkadeSwapRequest as V, assertFundable as W, assertReceivable as X, awaitOnchainFill as Y, buildHtlcClaim as Z, buildHtlcRefund as _, type AssetSwap as a, claimOnchainFill as a0, classifyOnchainHtlc as a1, deriveLightningReceive as a2, deriveOnchainReceive as a3, deriveOnchainSend as a4, derivePreimage as a5, deriveSwapSecrets as a6, extractPreimage as a7, getAssetSwaps as a8, getAssetSwapsOrThrow as a9, unilateralClaimDelay as aA, unilateralRefundDelay as aB, unilateralRefundWithoutReceiverDelay as aC, updateAssetSwap as aD, updateAssetSwapBestEffort as aE, verifyLockupAddress as aF, verifyReceiveInvoice as aG, httpTransport as aa, isDeterministicSigner as ab, lightningReceiveRequest as ac, lightningSendRequest as ad, lightningSendVtxoScript as ae, newPreimage as af, newRfqId as ag, offerTermsFromQuote as ah, onchainHtlcScript as ai, onchainReceiveRequest as aj, onchainSendRequest as ak, paymentHashOf as al, preimageForRfqSecrets as am, randomSwapSecrets as an, receiveVtxoScript as ao, relayTransport as ap, requestLightningReceive as aq, requestLightningSend as ar, requestOnchainReceive as as, requestOnchainSend as at, rfqPair as au, rfqSecretsOfRecord as av, rfqSecretsToRecord as aw, senderIdentityForRfqSecrets as ax, senderIdentityForSwapRecord as ay, senderPubkeyForRfqSecrets as az, type RfqTransport as b, type ChainUtxo as c, type OnchainHtlcPhase as d, ARKADE_ASSET as e, ARKADE_BTC as f, AddressMismatch as g, type AssetSwapFallbackSecrets as h, type AssetSwapStatus as i, type DeterministicSigner as j, type InvoiceFacts as k, LIGHTNING_RECEIVE_PAIR as l, LIGHTNING_SEND_PAIR as m, MAX_MIN_CONFIRMATIONS as n, MIN_CLAIM_WINDOW_SECONDS as o, MIN_HEADROOM_SECONDS as p, ONCHAIN_BTC as q, ONCHAIN_CLAIM_MARGIN_SECONDS as r, ONCHAIN_DUST_SATS as s, ONCHAIN_ORDER_MARGIN_SECONDS as t, ONCHAIN_RECEIVE_PAIR as u, ONCHAIN_SECONDS_PER_BLOCK as v, ONCHAIN_SEND_PAIR as w, type OnchainHtlcParams as x, type OnchainNetwork as y, RFQ_PREIMAGE_TAG as z };
+export { onchainSendRequest as $, ARKADE_ASSET as A, awaitOnchainFill as B, type ChainSource as C, buildHtlcClaim as D, buildHtlcRefund as E, claimOnchainFill as F, classifyOnchainHtlc as G, type HtlcUtxo as H, type InvoiceFacts as I, deriveLightningReceive as J, deriveOnchainReceive as K, LIGHTNING_BTC as L, MAX_MIN_CONFIRMATIONS as M, deriveOnchainSend as N, type OnchainHtlc as O, extractPreimage as P, httpTransport as Q, type RfqStatus as R, SOLO_REFUND_HEADROOM_SECONDS as S, lightningReceiveRequest as T, lightningSendRequest as U, lightningSendVtxoScript as V, newPreimage as W, newRfqId as X, offerTermsFromQuote as Y, onchainHtlcScript as Z, onchainReceiveRequest as _, type RfqTransport as a, paymentHashOf as a0, receiveVtxoScript as a1, relayTransport as a2, requestLightningReceive as a3, requestLightningSend as a4, requestOnchainReceive as a5, requestOnchainSend as a6, rfqPair as a7, unilateralClaimDelay as a8, unilateralRefundDelay as a9, unilateralRefundWithoutReceiverDelay as aa, verifyLockupAddress as ab, verifyReceiveInvoice as ac, type ChainUtxo as b, type OnchainHtlcPhase as c, ARKADE_BTC as d, AddressMismatch as e, LIGHTNING_RECEIVE_PAIR as f, LIGHTNING_SEND_PAIR as g, MIN_CLAIM_WINDOW_SECONDS as h, MIN_HEADROOM_SECONDS as i, ONCHAIN_BTC as j, ONCHAIN_CLAIM_MARGIN_SECONDS as k, ONCHAIN_DUST_SATS as l, ONCHAIN_ORDER_MARGIN_SECONDS as m, ONCHAIN_RECEIVE_PAIR as n, ONCHAIN_SECONDS_PER_BLOCK as o, ONCHAIN_SEND_PAIR as p, type OnchainHtlcParams as q, type OnchainNetwork as r, RFQ_TERMINAL_STATES as s, type RelaySocket as t, type RfqQuote as u, type RfqRefusalReason as v, SwapRefusal as w, arkadeSwapRequest as x, assertFundable as y, assertReceivable as z };