@arkade-os/swap 0.0.3 → 0.0.5

package/dist/index.js

@@ -16,31 +16,25 @@ import {
   ONCHAIN_RECEIVE_PAIR,
   ONCHAIN_SECONDS_PER_BLOCK,
   ONCHAIN_SEND_PAIR,
-  RFQ_PREIMAGE_TAG,
   RFQ_TERMINAL_STATES,
-  RefundNotLocallyPossibleError,
+  SOLO_REFUND_HEADROOM_SECONDS,
   SWAP_LOCKUP_CONTRACT_KIND,
   SWAP_LOCKUP_CONTRACT_LABEL,
   SWAP_LOCKUP_CONTRACT_TYPE,
   SwapRefusal,
-  adoptSwapDescriptor,
   arkadeSwapRequest,
   assertFundable,
   assertReceivable,
   awaitOnchainFill,
   buildHtlcClaim,
   buildHtlcRefund,
-  buildPreimageMessage,
   claimOnchainFill,
   classifyOnchainHtlc,
   deriveLightningReceive,
   deriveOnchainReceive,
   deriveOnchainSend,
-  derivePreimage,
-  deriveSwapSecrets,
   extractPreimage,
   httpTransport,
-  isDeterministicSigner,
   lightningReceiveRequest,
   lightningSendRequest,
   lightningSendVtxoScript,
@@ -51,8 +45,6 @@ import {
   onchainReceiveRequest,
   onchainSendRequest,
   paymentHashOf,
-  preimageForRfqSecrets,
-  randomSwapSecrets,
   receiveVtxoScript,
   registerLockupContract,
   relayTransport,
@@ -61,21 +53,16 @@ import {
   requestOnchainReceive,
   requestOnchainSend,
   rfqPair,
-  rfqSecretsOfRecord,
-  rfqSecretsToRecord,
   sealClaimPacket,
-  senderIdentityForRfqSecrets,
-  senderIdentityForSwapRecord,
-  senderPubkeyForRfqSecrets,
   unilateralClaimDelay,
   unilateralRefundDelay,
   unilateralRefundWithoutReceiverDelay,
   verifyLockupAddress,
   verifyReceiveInvoice
-} from "./chunk-HLMMA3LJ.js";
+} from "./chunk-Q4FAYBXS.js";
 
 // src/offer.ts
-import { hex } from "@scure/base";
+import { hex as hex2 } from "@scure/base";
 import { concatBytes } from "@scure/btc-signer/utils.js";
 import {
   ArkAddress,
@@ -216,6 +203,9 @@ 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) => {
@@ -268,6 +258,63 @@ var updateAssetSwapBestEffort = async (repository, id, changes) => {
     return { swaps, persisted: false };
   }
 };
+var swapSecretsToRecord = (secrets) => ({
+  signingDescriptor: secrets.descriptor,
+  ..."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 = {
@@ -405,14 +452,14 @@ async function registerOfferContract(wallet, arkServerUrl, network, binding, ser
     contractManager
   });
   const contract = new arkade.ArkadeContract(client, program, args, keys);
-  if (hex.encode(contract.pkScript) !== hex.encode(expectedPkScript)) {
+  if (hex2.encode(contract.pkScript) !== hex2.encode(expectedPkScript)) {
     throw new Error("derived covenant does not match the offer's swapPkScript");
   }
   await contract.register({
     label: OFFER_CONTRACT_LABEL,
     metadata: { genericallySpendable: false, kind: OFFER_CONTRACT_KIND }
   });
-  await promoteOfferContract(contractManager, hex.encode(expectedPkScript));
+  await promoteOfferContract(contractManager, hex2.encode(expectedPkScript));
 }
 async function createOffer(wallet, arkServerUrl, params) {
   if (Boolean(params.wantAsset) === Boolean(params.offerAsset)) {
@@ -423,9 +470,9 @@ async function createOffer(wallet, arkServerUrl, params) {
     wallet.getAddress(),
     wallet.identity.xOnlyPublicKey()
   ]);
-  const serverPubKey = hex.decode(toXOnlySignerHex(info.signerPubkey));
+  const serverPubKey = hex2.decode(toXOnlySignerHex(info.signerPubkey));
   const network = getNetwork(info.network);
-  const emuKey = hex.decode(
+  const emuKey = hex2.decode(
     toXOnlySignerHex(resolveEmulatorPubkey(network, params.emulatorPubkey))
   );
   const binding = {
@@ -448,7 +495,7 @@ async function createOffer(wallet, arkServerUrl, params) {
   );
   const payload = encodeOffer(offer);
   return {
-    offerHex: hex.encode(payload),
+    offerHex: hex2.encode(payload),
     extension: { type: OFFER_PACKET_TYPE, payload },
     // VtxoScript.address owns address construction; assembling an ArkAddress
     // from tweakedPublicKey here would silently miss any future step it gains
@@ -458,7 +505,7 @@ async function createOffer(wallet, arkServerUrl, params) {
 }
 async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
   const { repository, fundingTxid, swapAddress } = opts;
-  const offer = decodeOffer(hex.decode(offerHex));
+  const offer = decodeOffer(hex2.decode(offerHex));
   const contractManager = await wallet.getContractManager();
   const client = await arkade.Arkade.connect({
     arkade: new RestArkProvider(arkServerUrl),
@@ -475,7 +522,7 @@ async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
   const serverKey = swapAddress ? ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
   const { program, args, keys } = swapProgramBinding(offer, serverKey);
   const rebuilt = new arkade.ArkadeProgramScript(program, args, keys);
-  if (hex.encode(rebuilt.pkScript) !== hex.encode(offer.swapPkScript)) {
+  if (hex2.encode(rebuilt.pkScript) !== hex2.encode(offer.swapPkScript)) {
     throw new Error(
       "rebuilt covenant does not match the offer's swapPkScript \u2014 the server signing key has likely rotated since funding; pass swapAddress (the funded address) to pin the original key"
     );
@@ -508,7 +555,7 @@ async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
       spentTxid: txid
     });
     if (persisted) {
-      await retireOfferContract(contractManager, swaps, hex.encode(offer.swapPkScript));
+      await retireOfferContract(contractManager, swaps, hex2.encode(offer.swapPkScript));
     }
   }
   return txid;
@@ -646,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();
@@ -708,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
@@ -779,7 +826,7 @@ var IndexedDbAssetSwapRepository = class {
 };
 
 // src/restore.ts
-import { base64, hex as hex2 } from "@scure/base";
+import { base64, hex as hex3 } from "@scure/base";
 import {
   Extension,
   Transaction,
@@ -815,7 +862,7 @@ function classifySpend(offer, serverPubkey, spendTx, deposit) {
   let leaves;
   try {
     const script = offerVtxoScript(offer, serverPubkey);
-    if (hex2.encode(script.pkScript) !== hex2.encode(offer.swapPkScript)) return "indeterminate";
+    if (hex3.encode(script.pkScript) !== hex3.encode(offer.swapPkScript)) return "indeterminate";
     leaves = {
       cancel: script.functionByName("cancel")?.leafScript,
       fulfill: script.functionByName("fulfill")?.leafScript
@@ -826,11 +873,11 @@ function classifySpend(offer, serverPubkey, spendTx, deposit) {
   for (let i = 0; i < spendTx.inputsLength; i++) {
     const input = spendTx.getInput(i);
     if (!input.txid || input.index !== deposit.vout) continue;
-    if (hex2.encode(input.txid) !== deposit.txid) continue;
+    if (hex3.encode(input.txid) !== deposit.txid) continue;
     for (const leaf of input.tapLeafScript ?? []) {
-      const spent = hex2.encode(scriptFromTapLeafScript(leaf));
-      if (leaves.cancel && spent === hex2.encode(leaves.cancel)) return "cancelled";
-      if (leaves.fulfill && spent === hex2.encode(leaves.fulfill)) return "fulfilled";
+      const spent = hex3.encode(scriptFromTapLeafScript(leaf));
+      if (leaves.cancel && spent === hex3.encode(leaves.cancel)) return "cancelled";
+      if (leaves.fulfill && spent === hex3.encode(leaves.fulfill)) return "fulfilled";
     }
   }
   return "indeterminate";
@@ -865,13 +912,13 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
       found.push({
         fundingTx,
         offer: decodeOffer(payload),
-        offerHex: hex2.encode(payload)
+        offerHex: hex3.encode(payload)
       });
     } catch {
     }
   }
   if (found.length === 0) return { restored: [], scannedTxids: fetchedTxids };
-  const scripts = [...new Set(found.map((f) => hex2.encode(f.offer.swapPkScript)))];
+  const scripts = [...new Set(found.map((f) => hex3.encode(f.offer.swapPkScript)))];
   const { vtxos } = await indexer.getVtxos({ scripts });
   const vtxoByScriptAndTxid = new Map(vtxos.map((v) => [`${v.script}:${v.txid}`, v]));
   const txByAnyId = /* @__PURE__ */ new Map();
@@ -883,7 +930,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
   const spendTxids = /* @__PURE__ */ new Set();
   for (const { fundingTx, offer } of found) {
     const vtxo = vtxoByScriptAndTxid.get(
-      `${hex2.encode(offer.swapPkScript)}:${fundingTx.redeemTxid}`
+      `${hex3.encode(offer.swapPkScript)}:${fundingTx.redeemTxid}`
     );
     if (vtxo?.virtualStatus.state !== "spent") continue;
     for (const txid of spendTxidsOf(vtxo)) spendTxids.add(txid);
@@ -892,7 +939,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
   const restored = [];
   const unresolved = /* @__PURE__ */ new Set();
   for (const { fundingTx, offer, offerHex } of found) {
-    const swapPkScript = hex2.encode(offer.swapPkScript);
+    const swapPkScript = hex3.encode(offer.swapPkScript);
     const vtxo = vtxoByScriptAndTxid.get(`${swapPkScript}:${fundingTx.redeemTxid}`);
     if (!vtxo) {
       unresolved.add(fundingTx.redeemTxid);
@@ -949,7 +996,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
 }
 
 // src/watch.ts
-import { base64 as base642, hex as hex3 } from "@scure/base";
+import { base64 as base642, hex as hex4 } from "@scure/base";
 import {
   ArkAddress as ArkAddress2,
   RestIndexerProvider as RestIndexerProvider3,
@@ -988,7 +1035,7 @@ async function watchOfferSwaps({
       if (candidates.length === 0) return "indeterminate";
       const { txs } = await indexer.getVirtualTxs(candidates);
       return classifyDepositSpend(
-        decodeOffer(hex3.decode(swap.offerHex)),
+        decodeOffer(hex4.decode(swap.offerHex)),
         serverPubkey,
         txs.map((psbt) => Transaction2.fromPSBT(base642.decode(psbt))),
         { txid: vtxo.txid, vout: vtxo.vout }
@@ -1032,9 +1079,9 @@ async function watchOfferSwaps({
 }
 
 // src/claim.ts
-import { hex as hex5 } from "@scure/base";
+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,
@@ -1042,8 +1089,8 @@ import {
 } from "@arkade-os/sdk";
 
 // src/refund.ts
-import { base64 as base643, hex as hex4 } from "@scure/base";
-import { sha256 } from "@noble/hashes/sha2.js";
+import { base64 as base643, hex as hex5 } from "@scure/base";
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
 import {
   CSVMultisigTapscript,
   ConditionWitness,
@@ -1099,7 +1146,7 @@ var LockupNeedsRecoveryError = class extends Error {
   }
 };
 async function findLockupVtxos(indexer, swapPkScript) {
-  const scripts = [hex4.encode(swapPkScript)];
+  const scripts = [hex5.encode(swapPkScript)];
   const [spendable, recoverable] = await Promise.all([
     indexer.getVtxos({ scripts, spendableOnly: true }),
     indexer.getVtxos({ scripts, recoverableOnly: true })
@@ -1124,13 +1171,13 @@ async function findLockupVtxos(indexer, swapPkScript) {
   }
   return out;
 }
-var hashesTo = (candidate, paymentHash) => hex4.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 ?? []
 ];
 async function readLockupFate(indexer, input) {
-  const { vtxos } = await indexer.getVtxos({ scripts: [hex4.encode(input.swapPkScript)] });
+  const { vtxos } = await indexer.getVtxos({ scripts: [hex5.encode(input.swapPkScript)] });
   const all = vtxos ?? [];
   if (all.length === 0) return { fate: "unknown" };
   const spentBy = /* @__PURE__ */ new Set();
@@ -1153,7 +1200,7 @@ async function readLockupFate(indexer, input) {
     for (let i = 0; i < tx.inputsLength; i++) {
       const spent = tx.getInput(i);
       if (!spent.txid) continue;
-      const txid = hex4.encode(spent.txid);
+      const txid = hex5.encode(spent.txid);
       if (!all.some((vtxo) => vtxo.txid === txid && vtxo.vout === spent.index)) continue;
       for (const candidate of candidateWitnessItems(tx, i)) {
         if (hashesTo(candidate, input.paymentHash)) {
@@ -1182,7 +1229,7 @@ async function pushRefundWithoutReceiver(ark, input) {
   const info = await ark.getInfo();
   let serverUnrollScript;
   try {
-    serverUnrollScript = CSVMultisigTapscript.decode(hex4.decode(info.checkpointTapscript));
+    serverUnrollScript = CSVMultisigTapscript.decode(hex5.decode(info.checkpointTapscript));
   } catch {
     throw new Error("invalid checkpointTapscript from the Arkade server");
   }
@@ -1293,13 +1340,13 @@ async function pushClaim(ark, input) {
     }
   }
   const committed = input.script.options.preimageHash;
-  if (hex5.encode(ripemd160(sha2562(input.preimage))) !== hex5.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();
   let serverUnrollScript;
   try {
-    serverUnrollScript = CSVMultisigTapscript2.decode(hex5.decode(info.checkpointTapscript));
+    serverUnrollScript = CSVMultisigTapscript2.decode(hex6.decode(info.checkpointTapscript));
   } catch {
     throw new Error("invalid checkpointTapscript from the Arkade server");
   }
@@ -1352,8 +1399,50 @@ async function claimReceiveLockup(indexer, ark, input) {
   });
 }
 
+// src/refundBlocked.ts
+import {
+  ForeignDescriptorError,
+  WalletCannotSignError,
+  contractSigner
+} from "@arkade-os/sdk";
+var RefundNotLocallyPossibleError = class extends Error {
+  constructor(reason, message, options) {
+    super(message, options);
+    this.reason = reason;
+  }
+  reason;
+  name = "RefundNotLocallyPossibleError";
+};
+async function senderIdentityForSwapRecord(wallet, record) {
+  if (!record.signingDescriptor) {
+    throw new RefundNotLocallyPossibleError(
+      "no-secrets",
+      "this swap record carries no signing descriptor"
+    );
+  }
+  try {
+    return await contractSigner(wallet, record.signingDescriptor);
+  } catch (cause) {
+    if (cause instanceof WalletCannotSignError) {
+      throw new RefundNotLocallyPossibleError(
+        "unsignable-wallet",
+        `this wallet holds ${record.signingDescriptor} but cannot sign with it; attach its signer`,
+        { cause }
+      );
+    }
+    if (cause instanceof ForeignDescriptorError) {
+      throw new RefundNotLocallyPossibleError(
+        "foreign-descriptor",
+        `this wallet cannot derive ${record.signingDescriptor}; the swap was created on another wallet`,
+        { cause }
+      );
+    }
+    throw cause;
+  }
+}
+
 // src/swapManager.ts
-import { hex as hex6 } from "@scure/base";
+import { hex as hex7 } from "@scure/base";
 var RFQ_SWAP_TERMINAL_STATES = ["settled", "refunded", "failed"];
 var isRfqSwapTerminal = (state) => RFQ_SWAP_TERMINAL_STATES.includes(state);
 function nextOnchainAction(input) {
@@ -1621,7 +1710,7 @@ var RfqSwapManager = class {
   // ── internals ────────────────────────────────────────────────────────────
   track(swap) {
     this.monitored.set(swap.rfqId, swap);
-    this.byLockupScript.set(hex6.encode(swap.lockupPkScript), swap);
+    this.byLockupScript.set(hex7.encode(swap.lockupPkScript), swap);
   }
   /** Drops the swap from BOTH indexes. The event index is the one that stops
    * a late event finding a swap that is gone; `pollSwap`'s own
@@ -1630,7 +1719,7 @@ var RfqSwapManager = class {
    * them from silently re-driving a cancelled swap. */
   untrack(rfqId) {
     const swap = this.monitored.get(rfqId);
-    if (swap) this.byLockupScript.delete(hex6.encode(swap.lockupPkScript));
+    if (swap) this.byLockupScript.delete(hex7.encode(swap.lockupPkScript));
     this.monitored.delete(rfqId);
     this.refundRefused.delete(rfqId);
     this.lastClaimError.delete(rfqId);
@@ -1692,7 +1781,7 @@ var RfqSwapManager = class {
     if (!lockup) {
       try {
         const [existing] = await contracts.getContracts({
-          script: hex6.encode(swap.lockupPkScript)
+          script: hex7.encode(swap.lockupPkScript)
         });
         if (existing) {
           this.registered.set(swap.rfqId, true);
@@ -1711,13 +1800,13 @@ var RfqSwapManager = class {
       );
       return;
     }
-    const script = hex6.encode(lockup.script.pkScript);
-    if (script !== hex6.encode(swap.lockupPkScript)) {
+    const script = hex7.encode(lockup.script.pkScript);
+    if (script !== hex7.encode(swap.lockupPkScript)) {
       this.registered.set(swap.rfqId, false);
       this.emitFailed(
         swap,
         new Error(
-          `swap ${swap.rfqId} lockup script ${script} does not match its lockupPkScript ${hex6.encode(swap.lockupPkScript)}`
+          `swap ${swap.rfqId} lockup script ${script} does not match its lockupPkScript ${hex7.encode(swap.lockupPkScript)}`
         )
       );
       return;
@@ -1736,7 +1825,7 @@ var RfqSwapManager = class {
    * script for its whole life. Best-effort — the swap is over either way. */
   retireContract(swap) {
     if (!this.deps.contracts || !this.registered.get(swap.rfqId)) return;
-    void this.deps.contracts.setContractWatchState(hex6.encode(swap.lockupPkScript), "retained").catch((error) => this.emitFailed(swap, error));
+    void this.deps.contracts.setContractWatchState(hex7.encode(swap.lockupPkScript), "retained").catch((error) => this.emitFailed(swap, error));
   }
   arm() {
     if (!this.running) return;
@@ -2142,20 +2231,20 @@ export {
   ONCHAIN_RECEIVE_PAIR,
   ONCHAIN_SECONDS_PER_BLOCK,
   ONCHAIN_SEND_PAIR,
+  PreimageNotRecoverableError,
   QUOTE_OPTIONS,
   REFUND_MTP_LAG_SECONDS,
-  RFQ_PREIMAGE_TAG,
   RFQ_RESOLVED_STATES,
   RFQ_SWAP_TERMINAL_STATES,
   RFQ_TERMINAL_STATES,
   RefundNotLocallyPossibleError,
   RfqSwapManager,
+  SOLO_REFUND_HEADROOM_SECONDS,
   SWAP_LOCKUP_CONTRACT_KIND,
   SWAP_LOCKUP_CONTRACT_LABEL,
   SWAP_LOCKUP_CONTRACT_TYPE,
   SwapRefusal,
   addAssetSwap,
-  adoptSwapDescriptor,
   arkadeSwapRequest,
   assertFundable,
   assertReceivable,
@@ -2164,7 +2253,6 @@ export {
   awaitRfqResolution,
   buildHtlcClaim,
   buildHtlcRefund,
-  buildPreimageMessage,
   cancelOffer,
   claimOnchainFill,
   claimReceiveLockup,
@@ -2176,8 +2264,6 @@ export {
   deriveLightningReceive,
   deriveOnchainReceive,
   deriveOnchainSend,
-  derivePreimage,
-  deriveSwapSecrets,
   discoverMarkets,
   encodeOffer,
   extractPreimage,
@@ -2186,7 +2272,6 @@ export {
   getAssetSwaps,
   getAssetSwapsOrThrow,
   httpTransport,
-  isDeterministicSigner,
   isRfqSwapTerminal,
   isRfqTerminal,
   lightningReceiveRequest,
@@ -2202,10 +2287,9 @@ export {
   onchainReceiveRequest,
   onchainSendRequest,
   paymentHashOf,
-  preimageForRfqSecrets,
+  preimageForSwapRecord,
   pushClaim,
   pushRefundWithoutReceiver,
-  randomSwapSecrets,
   readLockupFate,
   receiveVtxoScript,
   refundIfUnresolved,
@@ -2218,15 +2302,12 @@ export {
   restoreAssetSwaps,
   retireSettledOfferContracts,
   rfqPair,
-  rfqSecretsOfRecord,
-  rfqSecretsToRecord,
   sealClaimPacket,
-  senderIdentityForRfqSecrets,
   senderIdentityForSwapRecord,
-  senderPubkeyForRfqSecrets,
   spendTxidsOf,
   spendUpdate,
   swapPrograms,
+  swapSecretsToRecord,
   unilateralClaimDelay,
   unilateralRefundDelay,
   unilateralRefundWithoutReceiverDelay,

package/dist/nostr.cjs

@@ -33,14 +33,15 @@ __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);
 
 // src/rfq.ts
-var import_base5 = require("@scure/base");
+var import_base4 = require("@scure/base");
 var import_legacy2 = require("@noble/hashes/legacy.js");
-var import_sdk3 = require("@arkade-os/sdk");
+var import_sdk2 = require("@arkade-os/sdk");
 
 // src/onchainHtlc.ts
 var import_base = require("@scure/base");
@@ -56,23 +57,19 @@ var L1_NETWORKS = {
   regtest: { ...btc.TEST_NETWORK, bech32: "bcrt" }
 };
 
-// src/secrets.ts
-var import_base2 = require("@scure/base");
-var import_sha22 = require("@noble/hashes/sha2.js");
-var import_utils = require("@noble/hashes/utils.js");
-var import_secp256k1 = require("@noble/curves/secp256k1.js");
-var import_sdk = require("@arkade-os/sdk");
+// src/rfq.ts
+var import_sdk3 = require("@arkade-os/sdk");
 
 // src/claimPacket.ts
-var import_base3 = require("@scure/base");
-var import_secp256k12 = require("@noble/curves/secp256k1.js");
+var import_base2 = require("@scure/base");
+var import_secp256k1 = require("@noble/curves/secp256k1.js");
 var import_hkdf = require("@noble/hashes/hkdf.js");
-var import_sha23 = require("@noble/hashes/sha2.js");
+var import_sha22 = require("@noble/hashes/sha2.js");
 var HKDF_INFO = new TextEncoder().encode("covclaimd/preimage/v1");
 
 // src/lockupContract.ts
-var import_base4 = require("@scure/base");
-var import_sdk2 = require("@arkade-os/sdk");
+var import_base3 = require("@scure/base");
+var import_sdk = require("@arkade-os/sdk");
 
 // src/rfq.ts
 var ARKADE_BTC = "arkade:BTC";
@@ -94,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
@@ -109,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 ?? {};
@@ -208,9 +213,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();
     }
   };
 };
@@ -219,5 +225,6 @@ var nostrRfqTransport = (options) => {
   RFQ_AD_KIND,
   RFQ_DIRECTED_KIND,
   RelayUnavailable,
+  TransportClosed,
   nostrRfqTransport
 });

package/dist/nostr.d.cts

@@ -1,7 +1,6 @@
-import { b as RfqTransport } from './rfq-CCAFoFtR.cjs';
+import { a as RfqTransport } from './rfq-BH2yvo3O.cjs';
 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 };