@arkade-os/swap 0.0.4 → 0.0.5

package/dist/index.d.cts

@@ -1,14 +1,47 @@
-import { ProvisionedKey, ProvisionedClaimSecret, asset, IWallet, arkade, RestIndexerProvider, Transaction, IContractManager, RestArkProvider, VHTLC, Identity } from '@arkade-os/sdk';
+import { IWallet, ProvisionedKey, ProvisionedClaimSecret, asset, arkade, RestIndexerProvider, Transaction, IContractManager, RestArkProvider, VHTLC, Identity } from '@arkade-os/sdk';
 import { DiscoveredMarket, Network, LocalCardInput, Side, OfferPlan } from '@arkade-os/solver-discovery';
-import { R as RfqStatus, a as RfqTransport, O as OnchainHtlc, C as ChainSource, b as ChainUtxo, c as OnchainHtlcPhase } from './rfq-DjZlesr4.cjs';
-export { A as ARKADE_ASSET, d as ARKADE_BTC, e as AddressMismatch, H as HtlcUtxo, I as InvoiceFacts, L as LIGHTNING_BTC, f as LIGHTNING_RECEIVE_PAIR, g as LIGHTNING_SEND_PAIR, M as MAX_MIN_CONFIRMATIONS, h as MIN_CLAIM_WINDOW_SECONDS, i as MIN_HEADROOM_SECONDS, j as ONCHAIN_BTC, k as ONCHAIN_CLAIM_MARGIN_SECONDS, l as ONCHAIN_DUST_SATS, m as ONCHAIN_ORDER_MARGIN_SECONDS, n as ONCHAIN_RECEIVE_PAIR, o as ONCHAIN_SECONDS_PER_BLOCK, p as ONCHAIN_SEND_PAIR, q as OnchainHtlcParams, r as OnchainNetwork, s as RFQ_TERMINAL_STATES, t as RelaySocket, u as RfqQuote, v as RfqRefusalReason, S as SwapRefusal, w as arkadeSwapRequest, x as assertFundable, y as assertReceivable, z as awaitOnchainFill, B as buildHtlcClaim, D as buildHtlcRefund, E as claimOnchainFill, F as classifyOnchainHtlc, G as deriveLightningReceive, J as deriveOnchainReceive, K as deriveOnchainSend, N as extractPreimage, P as httpTransport, Q as lightningReceiveRequest, T as lightningSendRequest, U as lightningSendVtxoScript, V as newPreimage, W as newRfqId, X as offerTermsFromQuote, Y as onchainHtlcScript, Z as onchainReceiveRequest, _ as onchainSendRequest, $ as paymentHashOf, a0 as receiveVtxoScript, a1 as relayTransport, a2 as requestLightningReceive, a3 as requestLightningSend, a4 as requestOnchainReceive, a5 as requestOnchainSend, a6 as rfqPair, a7 as unilateralClaimDelay, a8 as unilateralRefundDelay, a9 as unilateralRefundWithoutReceiverDelay, aa as verifyLockupAddress, ab as verifyReceiveInvoice } from './rfq-DjZlesr4.cjs';
+import { R as RfqStatus, a as RfqTransport, O as OnchainHtlc, C as ChainSource, b as ChainUtxo, c as OnchainHtlcPhase } from './rfq-BH2yvo3O.cjs';
+export { A as ARKADE_ASSET, d as ARKADE_BTC, e as AddressMismatch, H as HtlcUtxo, I as InvoiceFacts, L as LIGHTNING_BTC, f as LIGHTNING_RECEIVE_PAIR, g as LIGHTNING_SEND_PAIR, M as MAX_MIN_CONFIRMATIONS, h as MIN_CLAIM_WINDOW_SECONDS, i as MIN_HEADROOM_SECONDS, j as ONCHAIN_BTC, k as ONCHAIN_CLAIM_MARGIN_SECONDS, l as ONCHAIN_DUST_SATS, m as ONCHAIN_ORDER_MARGIN_SECONDS, n as ONCHAIN_RECEIVE_PAIR, o as ONCHAIN_SECONDS_PER_BLOCK, p as ONCHAIN_SEND_PAIR, q as OnchainHtlcParams, r as OnchainNetwork, s as RFQ_TERMINAL_STATES, t as RelaySocket, u as RfqQuote, v as RfqRefusalReason, S as SOLO_REFUND_HEADROOM_SECONDS, w as SwapRefusal, x as arkadeSwapRequest, y as assertFundable, z as assertReceivable, B as awaitOnchainFill, D as buildHtlcClaim, E as buildHtlcRefund, F as claimOnchainFill, G as classifyOnchainHtlc, J as deriveLightningReceive, K as deriveOnchainReceive, N as deriveOnchainSend, P as extractPreimage, Q as httpTransport, T as lightningReceiveRequest, U as lightningSendRequest, V as lightningSendVtxoScript, W as newPreimage, X as newRfqId, Y as offerTermsFromQuote, Z as onchainHtlcScript, _ as onchainReceiveRequest, $ as onchainSendRequest, a0 as paymentHashOf, a1 as receiveVtxoScript, a2 as relayTransport, a3 as requestLightningReceive, a4 as requestLightningSend, a5 as requestOnchainReceive, a6 as requestOnchainSend, a7 as rfqPair, a8 as unilateralClaimDelay, a9 as unilateralRefundDelay, aa as unilateralRefundWithoutReceiverDelay, ab as verifyLockupAddress, ac as verifyReceiveInvoice } from './rfq-BH2yvo3O.cjs';
 
 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 AssetSwap {
+/**
+ * The record fields a wallet-provisioned secret becomes — what
+ * {@link swapSecretsToRecord} emits, and what every record type carrying swap
+ * secrets embeds.
+ *
+ * A named type rather than four fields restated per record: the mapper and the
+ * records it feeds must agree exactly, and a record that silently omits one of
+ * these round-trips a swap whose preimage cannot be re-derived. Embedding makes
+ * the omission a compile error instead.
+ *
+ * **Only `preimageHex` is secret.** `signingDescriptor` and `preimageSaltHex`
+ * are public derivation inputs — they must survive a field-mapped backend, but
+ * they leak nothing without the seed.
+ */
+interface SwapSecretsProjection {
+    /**
+     * The wallet descriptor this swap's sender key comes from — a fresh HD
+     * child, or a static wallet's `tr(pubkey)`. Public — the signer
+     * re-derives from the wallet, so the record carries no key material.
+     */
+    signingDescriptor?: string;
+    /** P, hex, when it cannot be re-derived from the seed at all: the user
+     * supplied it, or the signer cannot sign deterministically. The swap's only
+     * claim secret when present. */
+    preimageHex?: string;
+    /**
+     * The salt P derives from, hex, on the salted arm — what a static wallet
+     * gets instead of storing P. **Public**, and unlike every other field here
+     * it is minted per swap: it is what stops one repeating key from handing
+     * every swap the same preimage.
+     */
+    preimageSaltHex?: string;
+}
+interface AssetSwap extends SwapSecretsProjection {
     /** Funding txid — the swap's identity. */
     id: string;
     /** 'btc' or a 68-hex asset id. */
@@ -33,16 +66,6 @@ interface AssetSwap {
     /** `sha256(P)`, hex. Public, and how a restore confirms a candidate
      * derivation is the right one. */
     paymentHash?: string;
-    /**
-     * The wallet descriptor this swap's sender key comes from — a fresh HD
-     * child, or a static wallet's `tr(pubkey)`. Public — the signer
-     * re-derives from the wallet, so the record carries no key material.
-     */
-    signingDescriptor?: string;
-    /** P, hex, when it cannot be re-derived from the seed: the user supplied
-     * it, or the descriptor is static (shared across swaps, so a derived
-     * preimage would collide). The swap's only claim secret when present. */
-    preimageHex?: string;
     /** The L1 HTLC's pkScript, hex — the chain-watch key. */
     htlcPkScriptHex?: string;
     htlcLocktime?: number;
@@ -85,13 +108,70 @@ declare const updateAssetSwapBestEffort: (repository: AssetSwapRepository, id: s
  * The record fields a wallet-provisioned secret becomes.
  *
  * `signingDescriptor` is public and always stored — it is what recovers the
- * signer. `preimageHex` is stored only when the wallet says it cannot
- * re-derive P, and is then the swap's only claim secret.
+ * signer. Then at most one of: `preimageHex`, when the wallet says it cannot
+ * re-derive P and it becomes the swap's only claim secret; or
+ * `preimageSaltHex`, the public input a derivable-but-repeating key needs.
  */
-declare const swapSecretsToRecord: (secrets: ProvisionedKey | ProvisionedClaimSecret) => {
+declare const swapSecretsToRecord: (secrets: ProvisionedKey | ProvisionedClaimSecret) => SwapSecretsProjection & {
     signingDescriptor: string;
-    preimageHex?: string;
 };
+/** Why a wallet cannot produce a swap's preimage. */
+type PreimageBlockedReason = 
+/** The record carries no `signingDescriptor`. */
+"no-secrets"
+/** `preimageHex` or `preimageSaltHex` is present but not 32 bytes of hex. */
+ | "malformed-record"
+/**
+ * Nothing to derive from: a descriptor that repeats across swaps, with
+ * neither a stored preimage nor a salt — or one this wallet holds no key
+ * for. Merged deliberately: `contractSigner` reports a key it does not
+ * hold as a plain `Error` for static wallets and a `ForeignDescriptorError`
+ * for HD ones, so splitting the two here would mean matching on message
+ * text, which is the thing this type exists to avoid. The `cause` carries
+ * whichever it was.
+ */
+ | "not-derivable"
+/** Derived, but it does not hash to the record's `paymentHash`. */
+ | "hash-mismatch";
+/**
+ * The wallet cannot produce this swap's preimage, and which of the four ways
+ * is `reason`.
+ *
+ * Deliberately **not** {@link RefundNotLocallyPossibleError}: that one means
+ * "no local refund is possible", and `RfqSwapManager` acts on it by reporting
+ * `needs_counterparty`. A claim-path read failure is a different verdict, and
+ * borrowing the refund error would have the manager announce one for the
+ * other.
+ */
+declare class PreimageNotRecoverableError extends Error {
+    readonly reason: PreimageBlockedReason;
+    readonly name = "PreimageNotRecoverableError";
+    constructor(reason: PreimageBlockedReason, message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * The preimage a swap record claims with — stored, or re-derived from the
+ * wallet.
+ *
+ * The record-shaped inverse of {@link swapSecretsToRecord}, and the one place
+ * that knows which of a record's fields `contractPreimage` needs. Wire claim
+ * paths here rather than composing it by hand: a caller that forgets to pass
+ * `preimageSaltHex` gets a *wrong* preimage from a wallet that can derive,
+ * not an error.
+ *
+ * Verifies the result against `paymentHash` when the record carries one. The
+ * salted arm has two inputs that can be wrong — the key and the salt — where
+ * the HD arm had one, and a wrong P otherwise surfaces as an opaque script
+ * failure at claim time, long after the mistake.
+ *
+ * Every refusal is a {@link PreimageNotRecoverableError} carrying a `reason`,
+ * so a caller can tell "this record predates the descriptor" from "the salt is
+ * corrupt" without reading message text.
+ */
+declare const preimageForSwapRecord: (wallet: IWallet, record: SwapSecretsProjection & {
+    paymentHash?: string;
+}) => Promise<Uint8Array>;
 
 /** 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
@@ -116,11 +196,12 @@ interface MarketsCacheEntry {
  * subset queries.
  */
 interface AssetSwapRepository extends AsyncDisposable {
-    readonly version: 1;
+    readonly version: 2;
     /** Insert or replace a swap by id. Store the record whole: `preimageHex`
-     * is secret-bearing — the only claim secret of a swap whose descriptor is
-     * not per-swap — and a field-mapped backend that drops it leaves the swap
-     * unclaimable. */
+     * and `preimageSaltHex` both leave the swap unclaimable if a field-mapped
+     * backend drops them — the first is the only claim secret of a swap whose
+     * signer cannot derive, the second the public input every other static
+     * wallet's preimage derives from. */
     saveSwap(swap: AssetSwap): Promise<void>;
     /** All stored swaps, in no particular order — `getAssetSwaps` is the
      * canonical newest-first read. */
@@ -134,7 +215,7 @@ interface AssetSwapRepository extends AsyncDisposable {
     clear(): Promise<void>;
 }
 declare class InMemoryAssetSwapRepository implements AssetSwapRepository {
-    readonly version: 1;
+    readonly version: 2;
     private readonly swaps;
     private readonly scanned;
     private readonly markets;
@@ -363,7 +444,7 @@ declare const validatePlan: (plan: OfferPlan, giveBalance: bigint, dust: bigint)
  * infrastructure the wallet already uses for its Boltz swap repository. */
 declare class IndexedDbAssetSwapRepository implements AssetSwapRepository {
     private readonly dbName;
-    readonly version: 1;
+    readonly version: 2;
     private dbPromise;
     constructor(dbName?: string);
     private ensureDb;
@@ -1929,4 +2010,4 @@ interface RfqSwapOutcome {
     txid?: string;
 }
 
-export { type ArkadeRefundResult, type AssetSwap, type AssetSwapRepository, type AssetSwapStatus, BTC_ASSET_ID, ChainSource, ChainUtxo, type ClaimArkProvider, type ClaimPacketInput, type DiscoverMarketsOptions, InMemoryAssetSwapRepository, IndexedDbAssetSwapRepository, type LightningReceiveSwap, type LightningSendSwap, LockupAmountMismatchError, type LockupContractWriter, type LockupFate, LockupNeedsRecoveryError, LockupRegistrationFailed, type LockupSpendIndexer, type LockupVtxo, type MarketsCacheEntry, OFFER_PACKET_TYPE, type Offer, type OfferContractRetirer, type OfferSwapWatcher, OnchainHtlc, OnchainHtlcPhase, type OnchainSendAction, type OnchainSendSwap, type PlanError, QUOTE_OPTIONS, REFUND_MTP_LAG_SECONDS, RFQ_RESOLVED_STATES, RFQ_SWAP_TERMINAL_STATES, type RefundArkProvider, type RefundBlockedReason, type RefundIndexer, RefundNotLocallyPossibleError, type RefundOutcome, type RestoreIndexer, RfqStatus, type RfqSwap, type RfqSwapActionName, type RfqSwapLockup, RfqSwapManager, type RfqSwapManagerCallbacks, type RfqSwapManagerConfig, type RfqSwapManagerDeps, type RfqSwapManagerEvents, type RfqSwapOutcome, type RfqSwapState, RfqTransport, SWAP_LOCKUP_CONTRACT_KIND, SWAP_LOCKUP_CONTRACT_LABEL, SWAP_LOCKUP_CONTRACT_TYPE, type SealedClaimPacket, type SpendKind, type SwapContractRegistry, type Tx, type WatchOfferSwapsParams, addAssetSwap, awaitLockupFunding, awaitRfqResolution, cancelOffer, claimReceiveLockup, classifyDepositSpend, classifySpend, createOffer, decodeOffer, discoverMarkets, encodeOffer, findLockupVtxos, findMarket, getAssetSwaps, getAssetSwapsOrThrow, isRfqSwapTerminal, isRfqTerminal, makeCachedFeedFetch, nextOnchainAction, offerVtxoScript, pushClaim, pushRefundWithoutReceiver, readLockupFate, refundIfUnresolved, registerLockupContract, restoreAssetSwaps, retireSettledOfferContracts, sealClaimPacket, senderIdentityForSwapRecord, spendTxidsOf, spendUpdate, swapPrograms, swapSecretsToRecord, updateAssetSwap, updateAssetSwapBestEffort, validatePlan, watchOfferSwaps };
+export { type ArkadeRefundResult, type AssetSwap, type AssetSwapRepository, type AssetSwapStatus, BTC_ASSET_ID, ChainSource, ChainUtxo, type ClaimArkProvider, type ClaimPacketInput, type DiscoverMarketsOptions, InMemoryAssetSwapRepository, IndexedDbAssetSwapRepository, type LightningReceiveSwap, type LightningSendSwap, LockupAmountMismatchError, type LockupContractWriter, type LockupFate, LockupNeedsRecoveryError, LockupRegistrationFailed, type LockupSpendIndexer, type LockupVtxo, type MarketsCacheEntry, OFFER_PACKET_TYPE, type Offer, type OfferContractRetirer, type OfferSwapWatcher, OnchainHtlc, OnchainHtlcPhase, type OnchainSendAction, type OnchainSendSwap, type PlanError, type PreimageBlockedReason, PreimageNotRecoverableError, QUOTE_OPTIONS, REFUND_MTP_LAG_SECONDS, RFQ_RESOLVED_STATES, RFQ_SWAP_TERMINAL_STATES, type RefundArkProvider, type RefundBlockedReason, type RefundIndexer, RefundNotLocallyPossibleError, type RefundOutcome, type RestoreIndexer, RfqStatus, type RfqSwap, type RfqSwapActionName, type RfqSwapLockup, RfqSwapManager, type RfqSwapManagerCallbacks, type RfqSwapManagerConfig, type RfqSwapManagerDeps, type RfqSwapManagerEvents, type RfqSwapOutcome, type RfqSwapState, RfqTransport, SWAP_LOCKUP_CONTRACT_KIND, SWAP_LOCKUP_CONTRACT_LABEL, SWAP_LOCKUP_CONTRACT_TYPE, type SealedClaimPacket, type SpendKind, type SwapContractRegistry, type SwapSecretsProjection, type Tx, type WatchOfferSwapsParams, addAssetSwap, awaitLockupFunding, awaitRfqResolution, cancelOffer, claimReceiveLockup, classifyDepositSpend, classifySpend, createOffer, decodeOffer, discoverMarkets, encodeOffer, findLockupVtxos, findMarket, getAssetSwaps, getAssetSwapsOrThrow, isRfqSwapTerminal, isRfqTerminal, makeCachedFeedFetch, nextOnchainAction, offerVtxoScript, preimageForSwapRecord, pushClaim, pushRefundWithoutReceiver, readLockupFate, refundIfUnresolved, registerLockupContract, restoreAssetSwaps, retireSettledOfferContracts, sealClaimPacket, senderIdentityForSwapRecord, spendTxidsOf, spendUpdate, swapPrograms, swapSecretsToRecord, updateAssetSwap, updateAssetSwapBestEffort, validatePlan, watchOfferSwaps };

package/dist/index.d.ts

@@ -1,14 +1,47 @@
-import { ProvisionedKey, ProvisionedClaimSecret, asset, IWallet, arkade, RestIndexerProvider, Transaction, IContractManager, RestArkProvider, VHTLC, Identity } from '@arkade-os/sdk';
+import { IWallet, ProvisionedKey, ProvisionedClaimSecret, asset, arkade, RestIndexerProvider, Transaction, IContractManager, RestArkProvider, VHTLC, Identity } from '@arkade-os/sdk';
 import { DiscoveredMarket, Network, LocalCardInput, Side, OfferPlan } from '@arkade-os/solver-discovery';
-import { R as RfqStatus, a as RfqTransport, O as OnchainHtlc, C as ChainSource, b as ChainUtxo, c as OnchainHtlcPhase } from './rfq-DjZlesr4.js';
-export { A as ARKADE_ASSET, d as ARKADE_BTC, e as AddressMismatch, H as HtlcUtxo, I as InvoiceFacts, L as LIGHTNING_BTC, f as LIGHTNING_RECEIVE_PAIR, g as LIGHTNING_SEND_PAIR, M as MAX_MIN_CONFIRMATIONS, h as MIN_CLAIM_WINDOW_SECONDS, i as MIN_HEADROOM_SECONDS, j as ONCHAIN_BTC, k as ONCHAIN_CLAIM_MARGIN_SECONDS, l as ONCHAIN_DUST_SATS, m as ONCHAIN_ORDER_MARGIN_SECONDS, n as ONCHAIN_RECEIVE_PAIR, o as ONCHAIN_SECONDS_PER_BLOCK, p as ONCHAIN_SEND_PAIR, q as OnchainHtlcParams, r as OnchainNetwork, s as RFQ_TERMINAL_STATES, t as RelaySocket, u as RfqQuote, v as RfqRefusalReason, S as SwapRefusal, w as arkadeSwapRequest, x as assertFundable, y as assertReceivable, z as awaitOnchainFill, B as buildHtlcClaim, D as buildHtlcRefund, E as claimOnchainFill, F as classifyOnchainHtlc, G as deriveLightningReceive, J as deriveOnchainReceive, K as deriveOnchainSend, N as extractPreimage, P as httpTransport, Q as lightningReceiveRequest, T as lightningSendRequest, U as lightningSendVtxoScript, V as newPreimage, W as newRfqId, X as offerTermsFromQuote, Y as onchainHtlcScript, Z as onchainReceiveRequest, _ as onchainSendRequest, $ as paymentHashOf, a0 as receiveVtxoScript, a1 as relayTransport, a2 as requestLightningReceive, a3 as requestLightningSend, a4 as requestOnchainReceive, a5 as requestOnchainSend, a6 as rfqPair, a7 as unilateralClaimDelay, a8 as unilateralRefundDelay, a9 as unilateralRefundWithoutReceiverDelay, aa as verifyLockupAddress, ab as verifyReceiveInvoice } from './rfq-DjZlesr4.js';
+import { R as RfqStatus, a as RfqTransport, O as OnchainHtlc, C as ChainSource, b as ChainUtxo, c as OnchainHtlcPhase } from './rfq-BH2yvo3O.js';
+export { A as ARKADE_ASSET, d as ARKADE_BTC, e as AddressMismatch, H as HtlcUtxo, I as InvoiceFacts, L as LIGHTNING_BTC, f as LIGHTNING_RECEIVE_PAIR, g as LIGHTNING_SEND_PAIR, M as MAX_MIN_CONFIRMATIONS, h as MIN_CLAIM_WINDOW_SECONDS, i as MIN_HEADROOM_SECONDS, j as ONCHAIN_BTC, k as ONCHAIN_CLAIM_MARGIN_SECONDS, l as ONCHAIN_DUST_SATS, m as ONCHAIN_ORDER_MARGIN_SECONDS, n as ONCHAIN_RECEIVE_PAIR, o as ONCHAIN_SECONDS_PER_BLOCK, p as ONCHAIN_SEND_PAIR, q as OnchainHtlcParams, r as OnchainNetwork, s as RFQ_TERMINAL_STATES, t as RelaySocket, u as RfqQuote, v as RfqRefusalReason, S as SOLO_REFUND_HEADROOM_SECONDS, w as SwapRefusal, x as arkadeSwapRequest, y as assertFundable, z as assertReceivable, B as awaitOnchainFill, D as buildHtlcClaim, E as buildHtlcRefund, F as claimOnchainFill, G as classifyOnchainHtlc, J as deriveLightningReceive, K as deriveOnchainReceive, N as deriveOnchainSend, P as extractPreimage, Q as httpTransport, T as lightningReceiveRequest, U as lightningSendRequest, V as lightningSendVtxoScript, W as newPreimage, X as newRfqId, Y as offerTermsFromQuote, Z as onchainHtlcScript, _ as onchainReceiveRequest, $ as onchainSendRequest, a0 as paymentHashOf, a1 as receiveVtxoScript, a2 as relayTransport, a3 as requestLightningReceive, a4 as requestLightningSend, a5 as requestOnchainReceive, a6 as requestOnchainSend, a7 as rfqPair, a8 as unilateralClaimDelay, a9 as unilateralRefundDelay, aa as unilateralRefundWithoutReceiverDelay, ab as verifyLockupAddress, ac as verifyReceiveInvoice } from './rfq-BH2yvo3O.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.
  * 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 AssetSwap {
+/**
+ * The record fields a wallet-provisioned secret becomes — what
+ * {@link swapSecretsToRecord} emits, and what every record type carrying swap
+ * secrets embeds.
+ *
+ * A named type rather than four fields restated per record: the mapper and the
+ * records it feeds must agree exactly, and a record that silently omits one of
+ * these round-trips a swap whose preimage cannot be re-derived. Embedding makes
+ * the omission a compile error instead.
+ *
+ * **Only `preimageHex` is secret.** `signingDescriptor` and `preimageSaltHex`
+ * are public derivation inputs — they must survive a field-mapped backend, but
+ * they leak nothing without the seed.
+ */
+interface SwapSecretsProjection {
+    /**
+     * The wallet descriptor this swap's sender key comes from — a fresh HD
+     * child, or a static wallet's `tr(pubkey)`. Public — the signer
+     * re-derives from the wallet, so the record carries no key material.
+     */
+    signingDescriptor?: string;
+    /** P, hex, when it cannot be re-derived from the seed at all: the user
+     * supplied it, or the signer cannot sign deterministically. The swap's only
+     * claim secret when present. */
+    preimageHex?: string;
+    /**
+     * The salt P derives from, hex, on the salted arm — what a static wallet
+     * gets instead of storing P. **Public**, and unlike every other field here
+     * it is minted per swap: it is what stops one repeating key from handing
+     * every swap the same preimage.
+     */
+    preimageSaltHex?: string;
+}
+interface AssetSwap extends SwapSecretsProjection {
     /** Funding txid — the swap's identity. */
     id: string;
     /** 'btc' or a 68-hex asset id. */
@@ -33,16 +66,6 @@ interface AssetSwap {
     /** `sha256(P)`, hex. Public, and how a restore confirms a candidate
      * derivation is the right one. */
     paymentHash?: string;
-    /**
-     * The wallet descriptor this swap's sender key comes from — a fresh HD
-     * child, or a static wallet's `tr(pubkey)`. Public — the signer
-     * re-derives from the wallet, so the record carries no key material.
-     */
-    signingDescriptor?: string;
-    /** P, hex, when it cannot be re-derived from the seed: the user supplied
-     * it, or the descriptor is static (shared across swaps, so a derived
-     * preimage would collide). The swap's only claim secret when present. */
-    preimageHex?: string;
     /** The L1 HTLC's pkScript, hex — the chain-watch key. */
     htlcPkScriptHex?: string;
     htlcLocktime?: number;
@@ -85,13 +108,70 @@ declare const updateAssetSwapBestEffort: (repository: AssetSwapRepository, id: s
  * The record fields a wallet-provisioned secret becomes.
  *
  * `signingDescriptor` is public and always stored — it is what recovers the
- * signer. `preimageHex` is stored only when the wallet says it cannot
- * re-derive P, and is then the swap's only claim secret.
+ * signer. Then at most one of: `preimageHex`, when the wallet says it cannot
+ * re-derive P and it becomes the swap's only claim secret; or
+ * `preimageSaltHex`, the public input a derivable-but-repeating key needs.
  */
-declare const swapSecretsToRecord: (secrets: ProvisionedKey | ProvisionedClaimSecret) => {
+declare const swapSecretsToRecord: (secrets: ProvisionedKey | ProvisionedClaimSecret) => SwapSecretsProjection & {
     signingDescriptor: string;
-    preimageHex?: string;
 };
+/** Why a wallet cannot produce a swap's preimage. */
+type PreimageBlockedReason = 
+/** The record carries no `signingDescriptor`. */
+"no-secrets"
+/** `preimageHex` or `preimageSaltHex` is present but not 32 bytes of hex. */
+ | "malformed-record"
+/**
+ * Nothing to derive from: a descriptor that repeats across swaps, with
+ * neither a stored preimage nor a salt — or one this wallet holds no key
+ * for. Merged deliberately: `contractSigner` reports a key it does not
+ * hold as a plain `Error` for static wallets and a `ForeignDescriptorError`
+ * for HD ones, so splitting the two here would mean matching on message
+ * text, which is the thing this type exists to avoid. The `cause` carries
+ * whichever it was.
+ */
+ | "not-derivable"
+/** Derived, but it does not hash to the record's `paymentHash`. */
+ | "hash-mismatch";
+/**
+ * The wallet cannot produce this swap's preimage, and which of the four ways
+ * is `reason`.
+ *
+ * Deliberately **not** {@link RefundNotLocallyPossibleError}: that one means
+ * "no local refund is possible", and `RfqSwapManager` acts on it by reporting
+ * `needs_counterparty`. A claim-path read failure is a different verdict, and
+ * borrowing the refund error would have the manager announce one for the
+ * other.
+ */
+declare class PreimageNotRecoverableError extends Error {
+    readonly reason: PreimageBlockedReason;
+    readonly name = "PreimageNotRecoverableError";
+    constructor(reason: PreimageBlockedReason, message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * The preimage a swap record claims with — stored, or re-derived from the
+ * wallet.
+ *
+ * The record-shaped inverse of {@link swapSecretsToRecord}, and the one place
+ * that knows which of a record's fields `contractPreimage` needs. Wire claim
+ * paths here rather than composing it by hand: a caller that forgets to pass
+ * `preimageSaltHex` gets a *wrong* preimage from a wallet that can derive,
+ * not an error.
+ *
+ * Verifies the result against `paymentHash` when the record carries one. The
+ * salted arm has two inputs that can be wrong — the key and the salt — where
+ * the HD arm had one, and a wrong P otherwise surfaces as an opaque script
+ * failure at claim time, long after the mistake.
+ *
+ * Every refusal is a {@link PreimageNotRecoverableError} carrying a `reason`,
+ * so a caller can tell "this record predates the descriptor" from "the salt is
+ * corrupt" without reading message text.
+ */
+declare const preimageForSwapRecord: (wallet: IWallet, record: SwapSecretsProjection & {
+    paymentHash?: string;
+}) => Promise<Uint8Array>;
 
 /** 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
@@ -116,11 +196,12 @@ interface MarketsCacheEntry {
  * subset queries.
  */
 interface AssetSwapRepository extends AsyncDisposable {
-    readonly version: 1;
+    readonly version: 2;
     /** Insert or replace a swap by id. Store the record whole: `preimageHex`
-     * is secret-bearing — the only claim secret of a swap whose descriptor is
-     * not per-swap — and a field-mapped backend that drops it leaves the swap
-     * unclaimable. */
+     * and `preimageSaltHex` both leave the swap unclaimable if a field-mapped
+     * backend drops them — the first is the only claim secret of a swap whose
+     * signer cannot derive, the second the public input every other static
+     * wallet's preimage derives from. */
     saveSwap(swap: AssetSwap): Promise<void>;
     /** All stored swaps, in no particular order — `getAssetSwaps` is the
      * canonical newest-first read. */
@@ -134,7 +215,7 @@ interface AssetSwapRepository extends AsyncDisposable {
     clear(): Promise<void>;
 }
 declare class InMemoryAssetSwapRepository implements AssetSwapRepository {
-    readonly version: 1;
+    readonly version: 2;
     private readonly swaps;
     private readonly scanned;
     private readonly markets;
@@ -363,7 +444,7 @@ declare const validatePlan: (plan: OfferPlan, giveBalance: bigint, dust: bigint)
  * infrastructure the wallet already uses for its Boltz swap repository. */
 declare class IndexedDbAssetSwapRepository implements AssetSwapRepository {
     private readonly dbName;
-    readonly version: 1;
+    readonly version: 2;
     private dbPromise;
     constructor(dbName?: string);
     private ensureDb;
@@ -1929,4 +2010,4 @@ interface RfqSwapOutcome {
     txid?: string;
 }
 
-export { type ArkadeRefundResult, type AssetSwap, type AssetSwapRepository, type AssetSwapStatus, BTC_ASSET_ID, ChainSource, ChainUtxo, type ClaimArkProvider, type ClaimPacketInput, type DiscoverMarketsOptions, InMemoryAssetSwapRepository, IndexedDbAssetSwapRepository, type LightningReceiveSwap, type LightningSendSwap, LockupAmountMismatchError, type LockupContractWriter, type LockupFate, LockupNeedsRecoveryError, LockupRegistrationFailed, type LockupSpendIndexer, type LockupVtxo, type MarketsCacheEntry, OFFER_PACKET_TYPE, type Offer, type OfferContractRetirer, type OfferSwapWatcher, OnchainHtlc, OnchainHtlcPhase, type OnchainSendAction, type OnchainSendSwap, type PlanError, QUOTE_OPTIONS, REFUND_MTP_LAG_SECONDS, RFQ_RESOLVED_STATES, RFQ_SWAP_TERMINAL_STATES, type RefundArkProvider, type RefundBlockedReason, type RefundIndexer, RefundNotLocallyPossibleError, type RefundOutcome, type RestoreIndexer, RfqStatus, type RfqSwap, type RfqSwapActionName, type RfqSwapLockup, RfqSwapManager, type RfqSwapManagerCallbacks, type RfqSwapManagerConfig, type RfqSwapManagerDeps, type RfqSwapManagerEvents, type RfqSwapOutcome, type RfqSwapState, RfqTransport, SWAP_LOCKUP_CONTRACT_KIND, SWAP_LOCKUP_CONTRACT_LABEL, SWAP_LOCKUP_CONTRACT_TYPE, type SealedClaimPacket, type SpendKind, type SwapContractRegistry, type Tx, type WatchOfferSwapsParams, addAssetSwap, awaitLockupFunding, awaitRfqResolution, cancelOffer, claimReceiveLockup, classifyDepositSpend, classifySpend, createOffer, decodeOffer, discoverMarkets, encodeOffer, findLockupVtxos, findMarket, getAssetSwaps, getAssetSwapsOrThrow, isRfqSwapTerminal, isRfqTerminal, makeCachedFeedFetch, nextOnchainAction, offerVtxoScript, pushClaim, pushRefundWithoutReceiver, readLockupFate, refundIfUnresolved, registerLockupContract, restoreAssetSwaps, retireSettledOfferContracts, sealClaimPacket, senderIdentityForSwapRecord, spendTxidsOf, spendUpdate, swapPrograms, swapSecretsToRecord, updateAssetSwap, updateAssetSwapBestEffort, validatePlan, watchOfferSwaps };
+export { type ArkadeRefundResult, type AssetSwap, type AssetSwapRepository, type AssetSwapStatus, BTC_ASSET_ID, ChainSource, ChainUtxo, type ClaimArkProvider, type ClaimPacketInput, type DiscoverMarketsOptions, InMemoryAssetSwapRepository, IndexedDbAssetSwapRepository, type LightningReceiveSwap, type LightningSendSwap, LockupAmountMismatchError, type LockupContractWriter, type LockupFate, LockupNeedsRecoveryError, LockupRegistrationFailed, type LockupSpendIndexer, type LockupVtxo, type MarketsCacheEntry, OFFER_PACKET_TYPE, type Offer, type OfferContractRetirer, type OfferSwapWatcher, OnchainHtlc, OnchainHtlcPhase, type OnchainSendAction, type OnchainSendSwap, type PlanError, type PreimageBlockedReason, PreimageNotRecoverableError, QUOTE_OPTIONS, REFUND_MTP_LAG_SECONDS, RFQ_RESOLVED_STATES, RFQ_SWAP_TERMINAL_STATES, type RefundArkProvider, type RefundBlockedReason, type RefundIndexer, RefundNotLocallyPossibleError, type RefundOutcome, type RestoreIndexer, RfqStatus, type RfqSwap, type RfqSwapActionName, type RfqSwapLockup, RfqSwapManager, type RfqSwapManagerCallbacks, type RfqSwapManagerConfig, type RfqSwapManagerDeps, type RfqSwapManagerEvents, type RfqSwapOutcome, type RfqSwapState, RfqTransport, SWAP_LOCKUP_CONTRACT_KIND, SWAP_LOCKUP_CONTRACT_LABEL, SWAP_LOCKUP_CONTRACT_TYPE, type SealedClaimPacket, type SpendKind, type SwapContractRegistry, type SwapSecretsProjection, type Tx, type WatchOfferSwapsParams, addAssetSwap, awaitLockupFunding, awaitRfqResolution, cancelOffer, claimReceiveLockup, classifyDepositSpend, classifySpend, createOffer, decodeOffer, discoverMarkets, encodeOffer, findLockupVtxos, findMarket, getAssetSwaps, getAssetSwapsOrThrow, isRfqSwapTerminal, isRfqTerminal, makeCachedFeedFetch, nextOnchainAction, offerVtxoScript, preimageForSwapRecord, pushClaim, pushRefundWithoutReceiver, readLockupFate, refundIfUnresolved, registerLockupContract, restoreAssetSwaps, retireSettledOfferContracts, sealClaimPacket, senderIdentityForSwapRecord, spendTxidsOf, spendUpdate, swapPrograms, swapSecretsToRecord, updateAssetSwap, updateAssetSwapBestEffort, validatePlan, watchOfferSwaps };

package/dist/index.js

@@ -17,6 +17,7 @@ import {
   ONCHAIN_SECONDS_PER_BLOCK,
   ONCHAIN_SEND_PAIR,
   RFQ_TERMINAL_STATES,
+  SOLO_REFUND_HEADROOM_SECONDS,
   SWAP_LOCKUP_CONTRACT_KIND,
   SWAP_LOCKUP_CONTRACT_LABEL,
   SWAP_LOCKUP_CONTRACT_TYPE,
@@ -58,7 +59,7 @@ import {
   unilateralRefundWithoutReceiverDelay,
   verifyLockupAddress,
   verifyReceiveInvoice
-} from "./chunk-DLM6BVTB.js";
+} from "./chunk-Q4FAYBXS.js";
 
 // src/offer.ts
 import { hex as hex2 } from "@scure/base";
@@ -203,6 +204,8 @@ async function retireSettledOfferContracts(manager, swaps) {
 
 // src/store.ts
 import { hex } from "@scure/base";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { contractPreimage } from "@arkade-os/sdk";
 var BTC_ASSET_ID = "btc";
 var byNewest = (a, b) => b.createdAt - a.createdAt;
 var getAssetSwapsOrThrow = async (repository) => {
@@ -257,8 +260,61 @@ var updateAssetSwapBestEffort = async (repository, id, changes) => {
 };
 var swapSecretsToRecord = (secrets) => ({
   signingDescriptor: secrets.descriptor,
-  ..."mustPersistPreimage" in secrets && secrets.mustPersistPreimage ? { preimageHex: hex.encode(secrets.preimage) } : {}
+  ..."mustPersistPreimage" in secrets && secrets.mustPersistPreimage ? { preimageHex: hex.encode(secrets.preimage) } : {},
+  ..."preimageSalt" in secrets && secrets.preimageSalt ? { preimageSaltHex: hex.encode(secrets.preimageSalt) } : {}
 });
+var decodeHex32 = (value, field) => {
+  const bytes = hex.decode(value);
+  if (bytes.length !== 32) {
+    throw new Error(`${field} must be 32 bytes, got ${bytes.length}`);
+  }
+  return bytes;
+};
+var PreimageNotRecoverableError = class extends Error {
+  constructor(reason, message, options) {
+    super(message, options);
+    this.reason = reason;
+  }
+  reason;
+  name = "PreimageNotRecoverableError";
+};
+var preimageForSwapRecord = async (wallet, record) => {
+  if (!record.signingDescriptor) {
+    throw new PreimageNotRecoverableError(
+      "no-secrets",
+      "this swap record carries no signing descriptor"
+    );
+  }
+  let stored;
+  let salt;
+  try {
+    stored = record.preimageHex ? decodeHex32(record.preimageHex, "preimageHex") : void 0;
+    salt = record.preimageSaltHex ? decodeHex32(record.preimageSaltHex, "preimageSaltHex") : void 0;
+  } catch (cause) {
+    throw new PreimageNotRecoverableError(
+      "malformed-record",
+      `this swap record's secrets projection is unreadable: ${String(cause)}`,
+      { cause }
+    );
+  }
+  let preimage;
+  try {
+    preimage = await contractPreimage(wallet, record.signingDescriptor, { stored, salt });
+  } catch (cause) {
+    throw new PreimageNotRecoverableError(
+      "not-derivable",
+      `this wallet cannot produce the preimage for ${record.signingDescriptor}`,
+      { cause }
+    );
+  }
+  if (record.paymentHash && hex.encode(sha256(preimage)) !== record.paymentHash.toLowerCase()) {
+    throw new PreimageNotRecoverableError(
+      "hash-mismatch",
+      "the derived preimage does not match this swap's payment hash: wrong wallet, or a tampered salt"
+    );
+  }
+  return preimage;
+};
 
 // src/offer.ts
 var swapPrograms = {
@@ -637,7 +693,7 @@ var validatePlan = (plan, giveBalance, dust) => {
 // src/repository.ts
 var marketsCacheKey = (network, registry) => `arkade-intents-markets-${network}-${registry}`;
 var InMemoryAssetSwapRepository = class {
-  version = 1;
+  version = 2;
   swaps = /* @__PURE__ */ new Map();
   scanned = /* @__PURE__ */ new Set();
   markets = /* @__PURE__ */ new Map();
@@ -699,7 +755,7 @@ var IndexedDbAssetSwapRepository = class {
     this.dbName = dbName;
   }
   dbName;
-  version = 1;
+  version = 2;
   // the promise, not the resolved database: openDatabase bumps a refcount on
   // every call including cache hits, while dispose closes once, so two
   // concurrent first calls would strand the refcount above zero and leak the
@@ -1025,7 +1081,7 @@ async function watchOfferSwaps({
 // src/claim.ts
 import { hex as hex6 } from "@scure/base";
 import { ripemd160 } from "@noble/hashes/legacy.js";
-import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+import { sha256 as sha2563 } from "@noble/hashes/sha2.js";
 import {
   CSVMultisigTapscript as CSVMultisigTapscript2,
   claimWithPreimageIdentity,
@@ -1034,7 +1090,7 @@ import {
 
 // src/refund.ts
 import { base64 as base643, hex as hex5 } from "@scure/base";
-import { sha256 } from "@noble/hashes/sha2.js";
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
 import {
   CSVMultisigTapscript,
   ConditionWitness,
@@ -1115,7 +1171,7 @@ async function findLockupVtxos(indexer, swapPkScript) {
   }
   return out;
 }
-var hashesTo = (candidate, paymentHash) => hex5.encode(sha256(candidate)) === paymentHash;
+var hashesTo = (candidate, paymentHash) => hex5.encode(sha2562(candidate)) === paymentHash;
 var candidateWitnessItems = (tx, inputIndex) => [
   ...getArkPsbtFields(tx, inputIndex, ConditionWitness).flat(),
   ...tx.getInput(inputIndex).finalScriptWitness ?? []
@@ -1284,7 +1340,7 @@ async function pushClaim(ark, input) {
     }
   }
   const committed = input.script.options.preimageHash;
-  if (hex6.encode(ripemd160(sha2562(input.preimage))) !== hex6.encode(committed)) {
+  if (hex6.encode(ripemd160(sha2563(input.preimage))) !== hex6.encode(committed)) {
     throw new Error("preimage does not match the covenant's payment hash");
   }
   const info = await ark.getInfo();
@@ -2175,6 +2231,7 @@ export {
   ONCHAIN_RECEIVE_PAIR,
   ONCHAIN_SECONDS_PER_BLOCK,
   ONCHAIN_SEND_PAIR,
+  PreimageNotRecoverableError,
   QUOTE_OPTIONS,
   REFUND_MTP_LAG_SECONDS,
   RFQ_RESOLVED_STATES,
@@ -2182,6 +2239,7 @@ export {
   RFQ_TERMINAL_STATES,
   RefundNotLocallyPossibleError,
   RfqSwapManager,
+  SOLO_REFUND_HEADROOM_SECONDS,
   SWAP_LOCKUP_CONTRACT_KIND,
   SWAP_LOCKUP_CONTRACT_LABEL,
   SWAP_LOCKUP_CONTRACT_TYPE,
@@ -2229,6 +2287,7 @@ export {
   onchainReceiveRequest,
   onchainSendRequest,
   paymentHashOf,
+  preimageForSwapRecord,
   pushClaim,
   pushRefundWithoutReceiver,
   readLockupFate,

package/dist/nostr.cjs

@@ -33,6 +33,7 @@ __export(nostr_exports, {
   RFQ_AD_KIND: () => RFQ_AD_KIND,
   RFQ_DIRECTED_KIND: () => RFQ_DIRECTED_KIND,
   RelayUnavailable: () => RelayUnavailable,
+  TransportClosed: () => TransportClosed,
   nostrRfqTransport: () => nostrRfqTransport
 });
 module.exports = __toCommonJS(nostr_exports);
@@ -90,6 +91,8 @@ var SwapRefusal = class extends Error {
   }
 };
 var MIN_HEADROOM_SECONDS = 90 * 60;
+var SEQUENCE_GRANULARITY_SECONDS = 512;
+var SOLO_REFUND_HEADROOM_SECONDS = 8 * SEQUENCE_GRANULARITY_SECONDS;
 var MIN_CLAIM_WINDOW_SECONDS = 30 * 60;
 
 // src/nostr.ts
@@ -105,6 +108,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 ?? {};
@@ -204,6 +213,7 @@ var nostrRfqTransport = (options) => {
     },
     async close() {
       closed = true;
+      for (const waiter of waiters.values()) waiter.reject(new TransportClosed());
       waiters.clear();
       if (ownsPool) pool.close(relays);
       else subscription.close();
@@ -215,5 +225,6 @@ var nostrRfqTransport = (options) => {
   RFQ_AD_KIND,
   RFQ_DIRECTED_KIND,
   RelayUnavailable,
+  TransportClosed,
   nostrRfqTransport
 });

package/dist/nostr.d.cts

@@ -1,4 +1,4 @@
-import { a as RfqTransport } from './rfq-DjZlesr4.cjs';
+import { a as RfqTransport } from './rfq-BH2yvo3O.cjs';
 import { SimplePool } from 'nostr-tools';
 import '@arkade-os/sdk';
 
@@ -70,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[];
@@ -95,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.d.ts

@@ -1,4 +1,4 @@
-import { a as RfqTransport } from './rfq-DjZlesr4.js';
+import { a as RfqTransport } from './rfq-BH2yvo3O.js';
 import { SimplePool } from 'nostr-tools';
 import '@arkade-os/sdk';
 
@@ -70,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[];
@@ -95,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 };