@arkade-os/swap 0.0.2 → 0.0.4

package/dist/index.cjs

@@ -55,7 +55,6 @@ __export(index_exports, {
   ONCHAIN_SEND_PAIR: () => ONCHAIN_SEND_PAIR,
   QUOTE_OPTIONS: () => QUOTE_OPTIONS,
   REFUND_MTP_LAG_SECONDS: () => REFUND_MTP_LAG_SECONDS,
-  RFQ_PREIMAGE_TAG: () => RFQ_PREIMAGE_TAG,
   RFQ_RESOLVED_STATES: () => RFQ_RESOLVED_STATES,
   RFQ_SWAP_TERMINAL_STATES: () => RFQ_SWAP_TERMINAL_STATES,
   RFQ_TERMINAL_STATES: () => RFQ_TERMINAL_STATES,
@@ -66,7 +65,6 @@ __export(index_exports, {
   SWAP_LOCKUP_CONTRACT_TYPE: () => SWAP_LOCKUP_CONTRACT_TYPE,
   SwapRefusal: () => SwapRefusal,
   addAssetSwap: () => addAssetSwap,
-  adoptSwapDescriptor: () => adoptSwapDescriptor,
   arkadeSwapRequest: () => arkadeSwapRequest,
   assertFundable: () => assertFundable,
   assertReceivable: () => assertReceivable,
@@ -75,7 +73,6 @@ __export(index_exports, {
   awaitRfqResolution: () => awaitRfqResolution,
   buildHtlcClaim: () => buildHtlcClaim,
   buildHtlcRefund: () => buildHtlcRefund,
-  buildPreimageMessage: () => buildPreimageMessage,
   cancelOffer: () => cancelOffer,
   claimOnchainFill: () => claimOnchainFill,
   claimReceiveLockup: () => claimReceiveLockup,
@@ -87,8 +84,6 @@ __export(index_exports, {
   deriveLightningReceive: () => deriveLightningReceive,
   deriveOnchainReceive: () => deriveOnchainReceive,
   deriveOnchainSend: () => deriveOnchainSend,
-  derivePreimage: () => derivePreimage,
-  deriveSwapSecrets: () => deriveSwapSecrets,
   discoverMarkets: () => discoverMarkets,
   encodeOffer: () => encodeOffer,
   extractPreimage: () => extractPreimage,
@@ -97,7 +92,6 @@ __export(index_exports, {
   getAssetSwaps: () => getAssetSwaps,
   getAssetSwapsOrThrow: () => getAssetSwapsOrThrow,
   httpTransport: () => httpTransport,
-  isDeterministicSigner: () => isDeterministicSigner,
   isRfqSwapTerminal: () => isRfqSwapTerminal,
   isRfqTerminal: () => isRfqTerminal,
   lightningReceiveRequest: () => lightningReceiveRequest,
@@ -113,10 +107,8 @@ __export(index_exports, {
   onchainReceiveRequest: () => onchainReceiveRequest,
   onchainSendRequest: () => onchainSendRequest,
   paymentHashOf: () => paymentHashOf,
-  preimageForRfqSecrets: () => preimageForRfqSecrets,
   pushClaim: () => pushClaim,
   pushRefundWithoutReceiver: () => pushRefundWithoutReceiver,
-  randomSwapSecrets: () => randomSwapSecrets,
   readLockupFate: () => readLockupFate,
   receiveVtxoScript: () => receiveVtxoScript,
   refundIfUnresolved: () => refundIfUnresolved,
@@ -129,15 +121,12 @@ __export(index_exports, {
   restoreAssetSwaps: () => restoreAssetSwaps,
   retireSettledOfferContracts: () => retireSettledOfferContracts,
   rfqPair: () => rfqPair,
-  rfqSecretsOfRecord: () => rfqSecretsOfRecord,
-  rfqSecretsToRecord: () => rfqSecretsToRecord,
   sealClaimPacket: () => sealClaimPacket,
-  senderIdentityForRfqSecrets: () => senderIdentityForRfqSecrets,
   senderIdentityForSwapRecord: () => senderIdentityForSwapRecord,
-  senderPubkeyForRfqSecrets: () => senderPubkeyForRfqSecrets,
   spendTxidsOf: () => spendTxidsOf,
   spendUpdate: () => spendUpdate,
   swapPrograms: () => swapPrograms,
+  swapSecretsToRecord: () => swapSecretsToRecord,
   unilateralClaimDelay: () => unilateralClaimDelay,
   unilateralRefundDelay: () => unilateralRefundDelay,
   unilateralRefundWithoutReceiverDelay: () => unilateralRefundWithoutReceiverDelay,
@@ -151,7 +140,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/offer.ts
-var import_base = require("@scure/base");
+var import_base2 = require("@scure/base");
 var import_utils = require("@scure/btc-signer/utils.js");
 var import_sdk = require("@arkade-os/sdk");
 
@@ -283,6 +272,7 @@ async function retireSettledOfferContracts(manager, swaps) {
 }
 
 // src/store.ts
+var import_base = require("@scure/base");
 var BTC_ASSET_ID = "btc";
 var byNewest = (a, b) => b.createdAt - a.createdAt;
 var getAssetSwapsOrThrow = async (repository) => {
@@ -335,6 +325,10 @@ var updateAssetSwapBestEffort = async (repository, id, changes) => {
     return { swaps, persisted: false };
   }
 };
+var swapSecretsToRecord = (secrets) => ({
+  signingDescriptor: secrets.descriptor,
+  ..."mustPersistPreimage" in secrets && secrets.mustPersistPreimage ? { preimageHex: import_base.hex.encode(secrets.preimage) } : {}
+});
 
 // src/offer.ts
 var swapPrograms = {
@@ -380,14 +374,6 @@ var FIELDS = {
   offerAsset: { tag: 11, width: void 0 }
 };
 var NAMES = Object.fromEntries(Object.entries(FIELDS).map(([k, f]) => [f.tag, k]));
-var XONLY_LEN = 32;
-var xOnly = (key, label) => {
-  if (key.length === XONLY_LEN) return key;
-  if (key.length !== 33 || key[0] !== 2 && key[0] !== 3) {
-    throw new Error(`${label} is not a compressed or x-only public key`);
-  }
-  return key.slice(1);
-};
 function tlv(type, value) {
   if (value.length > 65535) throw new Error("TLV value exceeds the u16 length field");
   return (0, import_utils.concatBytes)(Uint8Array.of(type, value.length >> 8 & 255, value.length & 255), value);
@@ -480,16 +466,16 @@ async function registerOfferContract(wallet, arkServerUrl, network, binding, ser
     contractManager
   });
   const contract = new import_sdk.arkade.ArkadeContract(client, program, args, keys);
-  if (import_base.hex.encode(contract.pkScript) !== import_base.hex.encode(expectedPkScript)) {
+  if (import_base2.hex.encode(contract.pkScript) !== import_base2.hex.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, import_base.hex.encode(expectedPkScript));
+  await promoteOfferContract(contractManager, import_base2.hex.encode(expectedPkScript));
 }
-async function createOffer(wallet, arkServerUrl, emulatorPubkey, params) {
+async function createOffer(wallet, arkServerUrl, params) {
   if (Boolean(params.wantAsset) === Boolean(params.offerAsset)) {
     throw new Error("set exactly one of wantAsset (BTC->asset) or offerAsset (asset->BTC)");
   }
@@ -498,8 +484,11 @@ async function createOffer(wallet, arkServerUrl, emulatorPubkey, params) {
     wallet.getAddress(),
     wallet.identity.xOnlyPublicKey()
   ]);
-  const serverPubKey = xOnly(import_base.hex.decode(info.signerPubkey), "ark signer key");
-  const emuKey = xOnly(emulatorPubkey, "emulator pubkey");
+  const serverPubKey = import_base2.hex.decode((0, import_sdk.toXOnlySignerHex)(info.signerPubkey));
+  const network = (0, import_sdk.getNetwork)(info.network);
+  const emuKey = import_base2.hex.decode(
+    (0, import_sdk.toXOnlySignerHex)((0, import_sdk.resolveEmulatorPubkey)(network, params.emulatorPubkey))
+  );
   const binding = {
     wantAmount: params.wantAmount,
     wantAsset: params.wantAsset,
@@ -520,17 +509,17 @@ async function createOffer(wallet, arkServerUrl, emulatorPubkey, params) {
   );
   const payload = encodeOffer(offer);
   return {
-    offerHex: import_base.hex.encode(payload),
+    offerHex: import_base2.hex.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
-    address: script.address((0, import_sdk.getNetwork)(info.network).hrp, serverPubKey).encode(),
+    address: script.address(network.hrp, serverPubKey).encode(),
     swapPkScript: script.pkScript
   };
 }
 async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
   const { repository, fundingTxid, swapAddress } = opts;
-  const offer = decodeOffer(import_base.hex.decode(offerHex));
+  const offer = decodeOffer(import_base2.hex.decode(offerHex));
   const contractManager = await wallet.getContractManager();
   const client = await import_sdk.arkade.Arkade.connect({
     arkade: new import_sdk.RestArkProvider(arkServerUrl),
@@ -547,7 +536,7 @@ async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
   const serverKey = swapAddress ? import_sdk.ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
   const { program, args, keys } = swapProgramBinding(offer, serverKey);
   const rebuilt = new import_sdk.arkade.ArkadeProgramScript(program, args, keys);
-  if (import_base.hex.encode(rebuilt.pkScript) !== import_base.hex.encode(offer.swapPkScript)) {
+  if (import_base2.hex.encode(rebuilt.pkScript) !== import_base2.hex.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"
     );
@@ -580,7 +569,7 @@ async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
       spentTxid: txid
     });
     if (persisted) {
-      await retireOfferContract(contractManager, swaps, import_base.hex.encode(offer.swapPkScript));
+      await retireOfferContract(contractManager, swaps, import_base2.hex.encode(offer.swapPkScript));
     }
   }
   return txid;
@@ -846,7 +835,7 @@ var IndexedDbAssetSwapRepository = class {
 };
 
 // src/restore.ts
-var import_base2 = require("@scure/base");
+var import_base3 = require("@scure/base");
 var import_sdk4 = require("@arkade-os/sdk");
 var TXS_PER_REQUEST = 50;
 async function fetchParsedTxs(indexer, txids) {
@@ -863,7 +852,7 @@ async function fetchParsedTxs(indexer, txids) {
     if (result.status !== "fulfilled") continue;
     for (const psbt of result.value) {
       try {
-        const parsed = import_sdk4.Transaction.fromPSBT(import_base2.base64.decode(psbt));
+        const parsed = import_sdk4.Transaction.fromPSBT(import_base3.base64.decode(psbt));
         parsedByTxid.set(parsed.id, parsed);
       } catch {
       }
@@ -878,7 +867,7 @@ function classifySpend(offer, serverPubkey, spendTx, deposit) {
   let leaves;
   try {
     const script = offerVtxoScript(offer, serverPubkey);
-    if (import_base2.hex.encode(script.pkScript) !== import_base2.hex.encode(offer.swapPkScript)) return "indeterminate";
+    if (import_base3.hex.encode(script.pkScript) !== import_base3.hex.encode(offer.swapPkScript)) return "indeterminate";
     leaves = {
       cancel: script.functionByName("cancel")?.leafScript,
       fulfill: script.functionByName("fulfill")?.leafScript
@@ -889,11 +878,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 (import_base2.hex.encode(input.txid) !== deposit.txid) continue;
+    if (import_base3.hex.encode(input.txid) !== deposit.txid) continue;
     for (const leaf of input.tapLeafScript ?? []) {
-      const spent = import_base2.hex.encode((0, import_sdk4.scriptFromTapLeafScript)(leaf));
-      if (leaves.cancel && spent === import_base2.hex.encode(leaves.cancel)) return "cancelled";
-      if (leaves.fulfill && spent === import_base2.hex.encode(leaves.fulfill)) return "fulfilled";
+      const spent = import_base3.hex.encode((0, import_sdk4.scriptFromTapLeafScript)(leaf));
+      if (leaves.cancel && spent === import_base3.hex.encode(leaves.cancel)) return "cancelled";
+      if (leaves.fulfill && spent === import_base3.hex.encode(leaves.fulfill)) return "fulfilled";
     }
   }
   return "indeterminate";
@@ -928,13 +917,13 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
       found.push({
         fundingTx,
         offer: decodeOffer(payload),
-        offerHex: import_base2.hex.encode(payload)
+        offerHex: import_base3.hex.encode(payload)
       });
     } catch {
     }
   }
   if (found.length === 0) return { restored: [], scannedTxids: fetchedTxids };
-  const scripts = [...new Set(found.map((f) => import_base2.hex.encode(f.offer.swapPkScript)))];
+  const scripts = [...new Set(found.map((f) => import_base3.hex.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();
@@ -946,7 +935,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
   const spendTxids = /* @__PURE__ */ new Set();
   for (const { fundingTx, offer } of found) {
     const vtxo = vtxoByScriptAndTxid.get(
-      `${import_base2.hex.encode(offer.swapPkScript)}:${fundingTx.redeemTxid}`
+      `${import_base3.hex.encode(offer.swapPkScript)}:${fundingTx.redeemTxid}`
     );
     if (vtxo?.virtualStatus.state !== "spent") continue;
     for (const txid of spendTxidsOf(vtxo)) spendTxids.add(txid);
@@ -955,7 +944,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
   const restored = [];
   const unresolved = /* @__PURE__ */ new Set();
   for (const { fundingTx, offer, offerHex } of found) {
-    const swapPkScript = import_base2.hex.encode(offer.swapPkScript);
+    const swapPkScript = import_base3.hex.encode(offer.swapPkScript);
     const vtxo = vtxoByScriptAndTxid.get(`${swapPkScript}:${fundingTx.redeemTxid}`);
     if (!vtxo) {
       unresolved.add(fundingTx.redeemTxid);
@@ -1012,7 +1001,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
 }
 
 // src/watch.ts
-var import_base3 = require("@scure/base");
+var import_base4 = require("@scure/base");
 var import_sdk5 = require("@arkade-os/sdk");
 var TERMINAL = ["fulfilled", "cancelled", "recoverable"];
 function spendUpdate(swap, spend) {
@@ -1047,9 +1036,9 @@ async function watchOfferSwaps({
       if (candidates.length === 0) return "indeterminate";
       const { txs } = await indexer.getVirtualTxs(candidates);
       return classifyDepositSpend(
-        decodeOffer(import_base3.hex.decode(swap.offerHex)),
+        decodeOffer(import_base4.hex.decode(swap.offerHex)),
         serverPubkey,
-        txs.map((psbt) => import_sdk5.Transaction.fromPSBT(import_base3.base64.decode(psbt))),
+        txs.map((psbt) => import_sdk5.Transaction.fromPSBT(import_base4.base64.decode(psbt))),
         { txid: vtxo.txid, vout: vtxo.vout }
       );
     } catch {
@@ -1093,10 +1082,10 @@ async function watchOfferSwaps({
 // src/rfq.ts
 var import_base8 = require("@scure/base");
 var import_legacy2 = require("@noble/hashes/legacy.js");
-var import_sdk8 = require("@arkade-os/sdk");
+var import_sdk7 = require("@arkade-os/sdk");
 
 // src/onchainHtlc.ts
-var import_base4 = require("@scure/base");
+var import_base5 = require("@scure/base");
 var import_sha2 = require("@noble/hashes/sha2.js");
 var import_legacy = require("@noble/hashes/legacy.js");
 var btc = __toESM(require("@scure/btc-signer"), 1);
@@ -1106,8 +1095,8 @@ var MAX_MIN_CONFIRMATIONS = 6;
 var ONCHAIN_SECONDS_PER_BLOCK = 600;
 var ONCHAIN_DUST_SATS = BigInt(330);
 var newPreimage = () => crypto.getRandomValues(new Uint8Array(32));
-var paymentHashOf = (preimage) => import_base4.hex.encode((0, import_sha2.sha256)(preimage));
-var h160FromPaymentHash = (paymentHash) => (0, import_legacy.ripemd160)(import_base4.hex.decode(paymentHash));
+var paymentHashOf = (preimage) => import_base5.hex.encode((0, import_sha2.sha256)(preimage));
+var h160FromPaymentHash = (paymentHash) => (0, import_legacy.ripemd160)(import_base5.hex.decode(paymentHash));
 var L1_NETWORKS = {
   bitcoin: btc.NETWORK,
   testnet: btc.TEST_NETWORK,
@@ -1148,7 +1137,7 @@ function onchainHtlcScript(params, network) {
   );
   const controlBlockFor = (leaf) => {
     for (const [block, script] of payment.tapLeafScript ?? []) {
-      if (script.length - 1 === leaf.length && import_base4.hex.encode(script.subarray(0, leaf.length)) === import_base4.hex.encode(leaf)) {
+      if (script.length - 1 === leaf.length && import_base5.hex.encode(script.subarray(0, leaf.length)) === import_base5.hex.encode(leaf)) {
         return btc.TaprootControlBlock.encode(block);
       }
     }
@@ -1241,13 +1230,13 @@ var buildHtlcRefund = (input) => buildLeafSpend({
 function extractPreimage(txHex, paymentHash) {
   let raw;
   try {
-    raw = btc.RawTx.decode(import_base4.hex.decode(txHex));
+    raw = btc.RawTx.decode(import_base5.hex.decode(txHex));
   } catch {
     return null;
   }
   for (const stack of raw.witnesses ?? []) {
     for (const item of stack) {
-      if (item.length === 32 && import_base4.hex.encode((0, import_sha2.sha256)(item)) === paymentHash) return item;
+      if (item.length === 32 && import_base5.hex.encode((0, import_sha2.sha256)(item)) === paymentHash) return item;
     }
   }
   return null;
@@ -1288,7 +1277,7 @@ async function classifyOnchainHtlc(chain, input) {
     const spend = await chain.getSpendingTx(input.funding.txid, input.funding.vout);
     if (!spend) return { phase: "unfunded" };
     const preimage = extractPreimage(spend.txHex, input.htlc.paymentHash);
-    const txid = btc.Transaction.fromRaw(import_base4.hex.decode(spend.txHex), {
+    const txid = btc.Transaction.fromRaw(import_base5.hex.decode(spend.txHex), {
       allowUnknownInputs: true,
       allowUnknownOutputs: true
     }).id;
@@ -1301,177 +1290,19 @@ async function classifyOnchainHtlc(chain, input) {
   return { phase: "claimable", utxo: best };
 }
 
-// src/secrets.ts
-var import_base5 = require("@scure/base");
-var import_sha22 = require("@noble/hashes/sha2.js");
-var import_utils2 = require("@noble/hashes/utils.js");
-var import_secp256k1 = require("@noble/curves/secp256k1.js");
-var import_sdk6 = require("@arkade-os/sdk");
-var RFQ_PREIMAGE_TAG = "Arkade-RFQ-Preimage-v1";
-function buildPreimageMessage(xonly, index) {
-  if (xonly.length !== 32) {
-    throw new Error(`x-only pubkey must be 32 bytes, got ${xonly.length}`);
-  }
-  if (!Number.isInteger(index) || index < 0 || index > 4294967295) {
-    throw new Error(`index must be a u32, got ${index}`);
-  }
-  const tag = new TextEncoder().encode(RFQ_PREIMAGE_TAG);
-  const message = new Uint8Array(tag.length + 32 + 4);
-  message.set(tag, 0);
-  message.set(xonly, tag.length);
-  new DataView(message.buffer).setUint32(tag.length + 32, index, true);
-  return message;
-}
-var PREIMAGE_INDEX = 0;
-async function deriveSwapSecrets(wallet) {
-  if (!(0, import_sdk6.isHDAllocationCapable)(wallet)) return void 0;
-  const signingDescriptor = await wallet.getNextSigningDescriptor();
-  if (!signingDescriptor) return void 0;
-  return { derivable: true, signingDescriptor };
-}
-function randomSwapSecrets(opts = {}) {
-  if (opts.preimage instanceof Uint8Array && opts.preimage.length !== 32) {
-    throw new Error(`preimage must be 32 bytes, got ${opts.preimage.length}`);
-  }
-  const preimage = opts.preimage instanceof Uint8Array ? opts.preimage : opts.preimage ? (0, import_utils2.randomBytes)(32) : void 0;
-  return {
-    derivable: false,
-    senderPrivateKey: import_secp256k1.schnorr.utils.randomSecretKey(),
-    ...preimage ? { preimage } : {}
-  };
-}
-function rfqSecretsToRecord(secrets) {
-  if (secrets.derivable) {
-    return {
-      signingDescriptor: secrets.signingDescriptor,
-      ...secrets.preimage ? { preimageHex: import_base5.hex.encode(secrets.preimage) } : {}
-    };
-  }
-  return {
-    fallbackSecrets: {
-      version: 1,
-      type: "stored",
-      senderPrivateKeyHex: import_base5.hex.encode(secrets.senderPrivateKey),
-      ...secrets.preimage ? { preimageHex: import_base5.hex.encode(secrets.preimage) } : {}
-    }
-  };
-}
-function rfqSecretsOfRecord(record) {
-  if (record.signingDescriptor) {
-    return {
-      derivable: true,
-      signingDescriptor: record.signingDescriptor,
-      ...record.preimageHex ? { preimage: decodeHex32(record.preimageHex, "preimageHex") } : {}
-    };
-  }
-  const fallback = record.fallbackSecrets;
-  if (!fallback) return void 0;
-  if (fallback.version !== 1 || fallback.type !== "stored") {
-    throw new Error("unsupported RFQ fallback secrets record");
-  }
-  return {
-    derivable: false,
-    senderPrivateKey: decodeHex32(fallback.senderPrivateKeyHex, "senderPrivateKeyHex"),
-    ...fallback.preimageHex ? { preimage: decodeHex32(fallback.preimageHex, "preimageHex") } : {}
-  };
-}
-function decodeHex32(value, label) {
-  const bytes = import_base5.hex.decode(value);
-  if (bytes.length !== 32) {
-    throw new Error(label + " must be 32 bytes, got " + bytes.length);
-  }
-  return bytes;
-}
-async function adoptSwapDescriptor(wallet, signingDescriptor) {
-  if (!(0, import_sdk6.isHDAllocationCapable)(wallet)) return;
-  await wallet.advanceSigningDescriptorWatermark(signingDescriptor);
-}
-var RefundNotLocallyPossibleError = class extends Error {
-  constructor(reason, message, options) {
-    super(message, options);
-    this.reason = reason;
-  }
-  reason;
-  name = "RefundNotLocallyPossibleError";
-};
-async function senderIdentityForRfqSecrets(wallet, secrets) {
-  if (!secrets.derivable) return import_sdk6.SingleKey.fromPrivateKey(secrets.senderPrivateKey);
-  const signer = (0, import_sdk6.isHDWalletCapable)(wallet) ? await wallet.signerForDescriptor(secrets.signingDescriptor) : void 0;
-  if (!signer || !isDeterministicSigner(signer)) {
-    throw new RefundNotLocallyPossibleError(
-      "foreign-descriptor",
-      `this wallet cannot derive ${secrets.signingDescriptor}; the swap was created on another wallet`
-    );
-  }
-  return signer;
-}
-async function senderIdentityForSwapRecord(wallet, record) {
-  let secrets;
-  try {
-    secrets = rfqSecretsOfRecord(record);
-  } catch (error) {
-    throw new RefundNotLocallyPossibleError(
-      "unreadable-secrets",
-      error instanceof Error ? error.message : String(error),
-      // the record's own diagnosis, kept for a caller that wants more
-      // than the message
-      { cause: error }
-    );
-  }
-  if (!secrets) {
-    throw new RefundNotLocallyPossibleError(
-      "no-secrets",
-      "this swap record carries no signing descriptor and no fallback secrets"
-    );
-  }
-  return senderIdentityForRfqSecrets(wallet, secrets);
-}
-async function senderPubkeyForRfqSecrets(wallet, secrets) {
-  if (!secrets.derivable) return import_secp256k1.schnorr.getPublicKey(secrets.senderPrivateKey);
-  return (await senderIdentityForRfqSecrets(wallet, secrets)).xOnlyPublicKey();
-}
-function isDeterministicSigner(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const v = value;
-  return typeof v.signSchnorrDeterministic === "function" && typeof v.xOnlyPublicKey === "function";
-}
-async function derivePreimage(signer) {
-  const xonly = await signer.xOnlyPublicKey();
-  const message = buildPreimageMessage(xonly, PREIMAGE_INDEX);
-  return (0, import_sha22.sha256)(await signer.signSchnorrDeterministic((0, import_sha22.sha256)(message)));
-}
-async function preimageForRfqSecrets(wallet, secrets) {
-  if (!secrets.derivable) {
-    if (!secrets.preimage) throw new Error("this swap carries no stored preimage");
-    return secrets.preimage;
-  }
-  if (secrets.preimage) return secrets.preimage;
-  const signer = await senderIdentityForRfqSecrets(wallet, secrets);
-  if (!isDeterministicSigner(signer)) {
-    throw new Error(
-      `wallet cannot sign deterministically for ${secrets.signingDescriptor}; its preimage is not derivable`
-    );
-  }
-  try {
-    return await derivePreimage(signer);
-  } catch (cause) {
-    throw new Error(
-      `wallet cannot sign deterministically for ${secrets.signingDescriptor}; its preimage is not derivable`,
-      { cause }
-    );
-  }
-}
+// src/rfq.ts
+var import_sdk8 = require("@arkade-os/sdk");
 
 // src/claimPacket.ts
 var import_base6 = require("@scure/base");
-var import_secp256k12 = require("@noble/curves/secp256k1.js");
+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");
 async function sealClaimPacket(input) {
   return sealWithEntropy(
     input,
-    import_secp256k12.secp256k1.utils.randomSecretKey(),
+    import_secp256k1.secp256k1.utils.randomSecretKey(),
     crypto.getRandomValues(new Uint8Array(12))
   );
 }
@@ -1480,9 +1311,9 @@ async function sealWithEntropy(input, ephemeralKey, nonce) {
   if (input.covclaimdPubkey.length !== 33) {
     throw new Error("covclaimd pubkey must be 33-byte compressed");
   }
-  const ephemeralPub = import_secp256k12.secp256k1.getPublicKey(ephemeralKey, true);
-  const sharedX = import_secp256k12.secp256k1.getSharedSecret(ephemeralKey, input.covclaimdPubkey, true).subarray(1);
-  const key = (0, import_hkdf.hkdf)(import_sha23.sha256, sharedX, ephemeralPub, HKDF_INFO, 32);
+  const ephemeralPub = import_secp256k1.secp256k1.getPublicKey(ephemeralKey, true);
+  const sharedX = import_secp256k1.secp256k1.getSharedSecret(ephemeralKey, input.covclaimdPubkey, true).subarray(1);
+  const key = (0, import_hkdf.hkdf)(import_sha22.sha256, sharedX, ephemeralPub, HKDF_INFO, 32);
   if (nonce.length !== 12) throw new Error("nonce must be 12 bytes");
   const aesKey = await crypto.subtle.importKey("raw", key, "AES-GCM", false, [
     "encrypt"
@@ -1507,7 +1338,7 @@ async function sealWithEntropy(input, ephemeralKey, nonce) {
 
 // src/lockupContract.ts
 var import_base7 = require("@scure/base");
-var import_sdk7 = require("@arkade-os/sdk");
+var import_sdk6 = require("@arkade-os/sdk");
 var SWAP_LOCKUP_CONTRACT_TYPE = "vhtlc-v2";
 var SWAP_LOCKUP_CONTRACT_LABEL = "Arkade RFQ swap lockup";
 var SWAP_LOCKUP_CONTRACT_KIND = "rfq-swap-lockup";
@@ -1529,7 +1360,7 @@ async function registerLockupContract(contracts, script, address) {
   try {
     await contracts.createContract({
       type: SWAP_LOCKUP_CONTRACT_TYPE,
-      params: import_sdk7.VHTLCV2ContractHandler.serializeParams(script.options),
+      params: import_sdk6.VHTLCV2ContractHandler.serializeParams(script.options),
       script: import_base7.hex.encode(script.pkScript),
       address,
       label: SWAP_LOCKUP_CONTRACT_LABEL,
@@ -1541,7 +1372,7 @@ async function registerLockupContract(contracts, script, address) {
 }
 
 // src/rfq.ts
-var xOnly2 = (key, label) => {
+var xOnly = (key, label) => {
   if (key.length === 32) return key;
   if (key.length !== 33 || key[0] !== 2 && key[0] !== 3) {
     throw new Error(`${label} is not a compressed or x-only public key`);
@@ -1811,7 +1642,7 @@ function lightningSendVtxoScript(params) {
     type: "seconds",
     value: BigInt(value)
   });
-  return new import_sdk8.VHTLC.ScriptV2({
+  return new import_sdk7.VHTLC.ScriptV2({
     sender: params.senderPubkey,
     receiver: params.solverPubkey,
     server: params.serverPubkey,
@@ -1832,17 +1663,12 @@ function lightningSendVtxoScript(params) {
     }
   });
 }
-async function requestLightningSend(wallet, arkServerUrl, emulatorPubkey, transport, params) {
+async function requestLightningSend(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
-  const secrets = await deriveSwapSecrets(wallet) ?? randomSwapSecrets();
-  if (!secrets.derivable) {
-    console.warn(
-      "[swap] wallet cannot allocate an HD descriptor: the sender key is random and MUST be persisted before funding"
-    );
-  }
-  const senderPubkey = await senderPubkeyForRfqSecrets(wallet, secrets);
+  const secrets = await (0, import_sdk8.provisionRefundKey)(wallet);
+  const senderPubkey = secrets.pubkey;
   const [info, refundAddress] = await Promise.all([
-    new import_sdk8.RestArkProvider(arkServerUrl).getInfo(),
+    new import_sdk7.RestArkProvider(arkServerUrl).getInfo(),
     wallet.getAddress()
   ]);
   const quote = await transport.requestQuote(
@@ -1865,19 +1691,23 @@ async function requestLightningSend(wallet, arkServerUrl, emulatorPubkey, transp
       `quote from_amount ${quote.from_amount} is below the invoice amount \u2014 a negative spread is not a quote`
     );
   }
-  const serverPubkey = xOnly2(import_base8.hex.decode(info.signerPubkey), "ark signer key");
+  const serverPubkey = xOnly(import_base8.hex.decode(info.signerPubkey), "ark signer key");
+  const network = (0, import_sdk7.getNetwork)(info.network);
   const script = lightningSendVtxoScript({
-    solverPubkey: xOnly2(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: xOnly(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime: quote.refund_locktime,
     serverPubkey,
     paymentHash: params.invoice.paymentHash,
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
-    emulatorPubkey: xOnly2(emulatorPubkey, "emulator pubkey"),
+    emulatorPubkey: xOnly(
+      import_base8.hex.decode((0, import_sdk7.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
+      "emulator signer key"
+    ),
     senderPubkey,
     receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
-    refundPkScript: import_sdk8.ArkAddress.decode(refundAddress).pkScript
+    refundPkScript: import_sdk7.ArkAddress.decode(refundAddress).pkScript
   });
-  const address = script.address((0, import_sdk8.getNetwork)(info.network).hrp, serverPubkey).encode();
+  const address = script.address(network.hrp, serverPubkey).encode();
   verifyLockupAddress(quote, address);
   assertFundable({
     quote,
@@ -1962,7 +1792,7 @@ function deriveOnchainSend(input) {
     throw new Error("onchain-send quote is missing a binding field");
   }
   const script = lightningSendVtxoScript({
-    solverPubkey: xOnly2(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: xOnly(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -1970,7 +1800,7 @@ function deriveOnchainSend(input) {
     emulatorPubkey: input.emulatorPubkey,
     senderPubkey: input.senderPubkey,
     receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
-    refundPkScript: import_sdk8.ArkAddress.decode(input.refundAddress).pkScript
+    refundPkScript: import_sdk7.ArkAddress.decode(input.refundAddress).pkScript
   });
   const address = script.address(input.hrp, input.serverPubkey).encode();
   verifyLockupAddress(quote, address);
@@ -1978,7 +1808,7 @@ function deriveOnchainSend(input) {
     {
       paymentHash: input.paymentHash,
       claimKey: input.payoutPubkey,
-      refundKey: xOnly2(import_base8.hex.decode(htlcPubkey), "solver L1 htlc key"),
+      refundKey: xOnly(import_base8.hex.decode(htlcPubkey), "solver L1 htlc key"),
       refundLocktime: htlcLocktime
     },
     input.l1Network
@@ -1994,27 +1824,18 @@ function deriveOnchainSend(input) {
     minConfirmations
   };
 }
-async function requestOnchainSend(wallet, arkServerUrl, emulatorPubkey, transport, params) {
+async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
-  if (params.preimage && params.preimage.length !== 32) {
-    throw new Error(`preimage must be 32 bytes, got ${params.preimage.length}`);
-  }
-  const derivedSecrets = await deriveSwapSecrets(wallet);
-  const secrets = derivedSecrets ? params.preimage ? { ...derivedSecrets, preimage: params.preimage } : derivedSecrets : randomSwapSecrets({ preimage: params.preimage ?? true });
-  if (!secrets.derivable) {
-    console.warn(
-      params.preimage ? "[swap] this swap's sender key is random; the supplied preimage and sender key MUST be persisted before funding" : "[swap] this swap's preimage and sender key are random and MUST be persisted before funding"
-    );
-  } else if (params.preimage) {
+  const secrets = await (0, import_sdk8.provisionClaimSecret)(wallet, { preimage: params.preimage });
+  if (secrets.mustPersistPreimage) {
     console.warn(
-      "[swap] this swap's preimage was supplied by the caller and MUST be persisted with the signing descriptor before funding"
+      "[swap] this swap's preimage cannot be re-derived from the seed and MUST be persisted with the record before funding"
     );
   }
-  const preimage = await preimageForRfqSecrets(wallet, secrets);
-  const paymentHash = paymentHashOf(preimage);
-  const senderPubkey = await senderPubkeyForRfqSecrets(wallet, secrets);
+  const paymentHash = import_base8.hex.encode(secrets.paymentHash);
+  const senderPubkey = secrets.pubkey;
   const [info, refundAddress] = await Promise.all([
-    new import_sdk8.RestArkProvider(arkServerUrl).getInfo(),
+    new import_sdk7.RestArkProvider(arkServerUrl).getInfo(),
     wallet.getAddress()
   ]);
   const quote = await transport.requestQuote(
@@ -2028,14 +1849,18 @@ async function requestOnchainSend(wallet, arkServerUrl, emulatorPubkey, transpor
       amountSide: params.amountSide
     })
   );
+  const network = (0, import_sdk7.getNetwork)(info.network);
   const derived = deriveOnchainSend({
     quote,
     paymentHash,
     payoutPubkey: params.payoutPubkey,
-    serverPubkey: xOnly2(import_base8.hex.decode(info.signerPubkey), "ark signer key"),
-    emulatorPubkey: xOnly2(emulatorPubkey, "emulator pubkey"),
+    serverPubkey: xOnly(import_base8.hex.decode(info.signerPubkey), "ark signer key"),
+    emulatorPubkey: xOnly(
+      import_base8.hex.decode((0, import_sdk7.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
+      "emulator signer key"
+    ),
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
-    hrp: (0, import_sdk8.getNetwork)(info.network).hrp,
+    hrp: network.hrp,
     l1Network: l1NetworkFromArk(info.network),
     refundAddress,
     senderPubkey
@@ -2139,7 +1964,7 @@ function receiveVtxoScript(params) {
     type: "seconds",
     value: BigInt(value)
   });
-  return new import_sdk8.VHTLC.ScriptV2({
+  return new import_sdk7.VHTLC.ScriptV2({
     sender: params.solverPubkey,
     receiver: params.payoutPubkey,
     server: params.serverPubkey,
@@ -2170,7 +1995,7 @@ function deriveLightningReceive(input) {
     throw new Error("lightning-receive quote is missing a binding field");
   }
   const script = receiveVtxoScript({
-    solverPubkey: xOnly2(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: xOnly(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -2178,25 +2003,25 @@ function deriveLightningReceive(input) {
     emulatorPubkey: input.emulatorPubkey,
     solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
     payoutPubkey: input.payoutPubkey,
-    payoutPkScript: import_sdk8.ArkAddress.decode(input.payoutAddress).pkScript
+    payoutPkScript: import_sdk7.ArkAddress.decode(input.payoutAddress).pkScript
   });
   const address = script.address(input.hrp, input.serverPubkey).encode();
   verifyLockupAddress(quote, address);
   return { address, swapPkScript: script.pkScript, script, invoice, refundLocktime };
 }
-async function requestLightningReceive(wallet, arkServerUrl, emulatorPubkey, transport, params) {
+async function requestLightningReceive(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
-  const secrets = await deriveSwapSecrets(wallet) ?? randomSwapSecrets({ preimage: true });
-  if (!secrets.derivable) {
+  const secrets = await (0, import_sdk8.provisionClaimSecret)(wallet);
+  if (secrets.mustPersistPreimage) {
     console.warn(
-      "[swap] this swap's preimage and payout key are random and MUST be persisted before paying"
+      "[swap] this swap's preimage cannot be re-derived from the seed and MUST be persisted with the record before paying"
     );
   }
-  const preimage = await preimageForRfqSecrets(wallet, secrets);
-  const paymentHash = paymentHashOf(preimage);
-  const payoutPubkey = await senderPubkeyForRfqSecrets(wallet, secrets);
+  const preimage = secrets.preimage;
+  const paymentHash = import_base8.hex.encode(secrets.paymentHash);
+  const payoutPubkey = secrets.pubkey;
   const [info, payoutAddress] = await Promise.all([
-    new import_sdk8.RestArkProvider(arkServerUrl).getInfo(),
+    new import_sdk7.RestArkProvider(arkServerUrl).getInfo(),
     wallet.getAddress()
   ]);
   const claimPacket = await sealClaimPacket({
@@ -2215,15 +2040,19 @@ async function requestLightningReceive(wallet, arkServerUrl, emulatorPubkey, tra
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
+  const network = (0, import_sdk7.getNetwork)(info.network);
   const derived = deriveLightningReceive({
     quote,
     paymentHash,
     payoutPubkey,
     payoutAddress,
-    serverPubkey: xOnly2(import_base8.hex.decode(info.signerPubkey), "ark signer key"),
-    emulatorPubkey: xOnly2(emulatorPubkey, "emulator pubkey"),
+    serverPubkey: xOnly(import_base8.hex.decode(info.signerPubkey), "ark signer key"),
+    emulatorPubkey: xOnly(
+      import_base8.hex.decode((0, import_sdk7.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
+      "emulator signer key"
+    ),
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
-    hrp: (0, import_sdk8.getNetwork)(info.network).hrp
+    hrp: network.hrp
   });
   const now = Math.floor(Date.now() / 1e3);
   const { payDeadline } = verifyReceiveInvoice({
@@ -2266,7 +2095,7 @@ function deriveOnchainReceive(input) {
     throw new Error("onchain-receive quote is missing a binding field");
   }
   const script = receiveVtxoScript({
-    solverPubkey: xOnly2(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: xOnly(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -2274,14 +2103,14 @@ function deriveOnchainReceive(input) {
     emulatorPubkey: input.emulatorPubkey,
     solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
     payoutPubkey: input.payoutPubkey,
-    payoutPkScript: import_sdk8.ArkAddress.decode(input.payoutAddress).pkScript
+    payoutPkScript: import_sdk7.ArkAddress.decode(input.payoutAddress).pkScript
   });
   const address = script.address(input.hrp, input.serverPubkey).encode();
   verifyLockupAddress(quote, address);
   const htlc = onchainHtlcScript(
     {
       paymentHash: input.paymentHash,
-      claimKey: xOnly2(import_base8.hex.decode(claimPubkey), "solver L1 claim key"),
+      claimKey: xOnly(import_base8.hex.decode(claimPubkey), "solver L1 claim key"),
       refundKey: input.refundPubkey,
       refundLocktime: htlcLocktime
     },
@@ -2298,19 +2127,19 @@ function deriveOnchainReceive(input) {
     minConfirmations
   };
 }
-async function requestOnchainReceive(wallet, arkServerUrl, emulatorPubkey, transport, params) {
+async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
-  const secrets = await deriveSwapSecrets(wallet) ?? randomSwapSecrets({ preimage: true });
-  if (!secrets.derivable) {
+  const secrets = await (0, import_sdk8.provisionClaimSecret)(wallet);
+  if (secrets.mustPersistPreimage) {
     console.warn(
-      "[swap] this swap's preimage and payout key are random and MUST be persisted before funding"
+      "[swap] this swap's preimage cannot be re-derived from the seed and MUST be persisted with the record before funding"
     );
   }
-  const preimage = await preimageForRfqSecrets(wallet, secrets);
-  const paymentHash = paymentHashOf(preimage);
-  const payoutPubkey = await senderPubkeyForRfqSecrets(wallet, secrets);
+  const preimage = secrets.preimage;
+  const paymentHash = import_base8.hex.encode(secrets.paymentHash);
+  const payoutPubkey = secrets.pubkey;
   const [info, payoutAddress] = await Promise.all([
-    new import_sdk8.RestArkProvider(arkServerUrl).getInfo(),
+    new import_sdk7.RestArkProvider(arkServerUrl).getInfo(),
     wallet.getAddress()
   ]);
   const claimPacket = await sealClaimPacket({
@@ -2330,16 +2159,20 @@ async function requestOnchainReceive(wallet, arkServerUrl, emulatorPubkey, trans
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
+  const network = (0, import_sdk7.getNetwork)(info.network);
   const derived = deriveOnchainReceive({
     quote,
     paymentHash,
     payoutPubkey,
     payoutAddress,
     refundPubkey: params.refundPubkey,
-    serverPubkey: xOnly2(import_base8.hex.decode(info.signerPubkey), "ark signer key"),
-    emulatorPubkey: xOnly2(emulatorPubkey, "emulator pubkey"),
+    serverPubkey: xOnly(import_base8.hex.decode(info.signerPubkey), "ark signer key"),
+    emulatorPubkey: xOnly(
+      import_base8.hex.decode((0, import_sdk7.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
+      "emulator signer key"
+    ),
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
-    hrp: (0, import_sdk8.getNetwork)(info.network).hrp,
+    hrp: network.hrp,
     l1Network: l1NetworkFromArk(info.network)
   });
   assertFundable({
@@ -2374,12 +2207,12 @@ async function requestOnchainReceive(wallet, arkServerUrl, emulatorPubkey, trans
 // src/claim.ts
 var import_base10 = require("@scure/base");
 var import_legacy3 = require("@noble/hashes/legacy.js");
-var import_sha25 = require("@noble/hashes/sha2.js");
+var import_sha24 = require("@noble/hashes/sha2.js");
 var import_sdk10 = require("@arkade-os/sdk");
 
 // src/refund.ts
 var import_base9 = require("@scure/base");
-var import_sha24 = require("@noble/hashes/sha2.js");
+var import_sha23 = require("@noble/hashes/sha2.js");
 var import_sdk9 = require("@arkade-os/sdk");
 var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var isRfqTerminal = (state) => RFQ_TERMINAL_STATES.includes(state);
@@ -2452,7 +2285,7 @@ async function findLockupVtxos(indexer, swapPkScript) {
   }
   return out;
 }
-var hashesTo = (candidate, paymentHash) => import_base9.hex.encode((0, import_sha24.sha256)(candidate)) === paymentHash;
+var hashesTo = (candidate, paymentHash) => import_base9.hex.encode((0, import_sha23.sha256)(candidate)) === paymentHash;
 var candidateWitnessItems = (tx, inputIndex) => [
   ...(0, import_sdk9.getArkPsbtFields)(tx, inputIndex, import_sdk9.ConditionWitness).flat(),
   ...tx.getInput(inputIndex).finalScriptWitness ?? []
@@ -2621,7 +2454,7 @@ async function pushClaim(ark, input) {
     }
   }
   const committed = input.script.options.preimageHash;
-  if (import_base10.hex.encode((0, import_legacy3.ripemd160)((0, import_sha25.sha256)(input.preimage))) !== import_base10.hex.encode(committed)) {
+  if (import_base10.hex.encode((0, import_legacy3.ripemd160)((0, import_sha24.sha256)(input.preimage))) !== import_base10.hex.encode(committed)) {
     throw new Error("preimage does not match the covenant's payment hash");
   }
   const info = await ark.getInfo();
@@ -2680,6 +2513,44 @@ async function claimReceiveLockup(indexer, ark, input) {
   });
 }
 
+// src/refundBlocked.ts
+var import_sdk11 = require("@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 (0, import_sdk11.contractSigner)(wallet, record.signingDescriptor);
+  } catch (cause) {
+    if (cause instanceof import_sdk11.WalletCannotSignError) {
+      throw new RefundNotLocallyPossibleError(
+        "unsignable-wallet",
+        `this wallet holds ${record.signingDescriptor} but cannot sign with it; attach its signer`,
+        { cause }
+      );
+    }
+    if (cause instanceof import_sdk11.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
 var import_base11 = require("@scure/base");
 var RFQ_SWAP_TERMINAL_STATES = ["settled", "refunded", "failed"];
@@ -3473,7 +3344,6 @@ var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
   ONCHAIN_SEND_PAIR,
   QUOTE_OPTIONS,
   REFUND_MTP_LAG_SECONDS,
-  RFQ_PREIMAGE_TAG,
   RFQ_RESOLVED_STATES,
   RFQ_SWAP_TERMINAL_STATES,
   RFQ_TERMINAL_STATES,
@@ -3484,7 +3354,6 @@ var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
   SWAP_LOCKUP_CONTRACT_TYPE,
   SwapRefusal,
   addAssetSwap,
-  adoptSwapDescriptor,
   arkadeSwapRequest,
   assertFundable,
   assertReceivable,
@@ -3493,7 +3362,6 @@ var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
   awaitRfqResolution,
   buildHtlcClaim,
   buildHtlcRefund,
-  buildPreimageMessage,
   cancelOffer,
   claimOnchainFill,
   claimReceiveLockup,
@@ -3505,8 +3373,6 @@ var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
   deriveLightningReceive,
   deriveOnchainReceive,
   deriveOnchainSend,
-  derivePreimage,
-  deriveSwapSecrets,
   discoverMarkets,
   encodeOffer,
   extractPreimage,
@@ -3515,7 +3381,6 @@ var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
   getAssetSwaps,
   getAssetSwapsOrThrow,
   httpTransport,
-  isDeterministicSigner,
   isRfqSwapTerminal,
   isRfqTerminal,
   lightningReceiveRequest,
@@ -3531,10 +3396,8 @@ var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
   onchainReceiveRequest,
   onchainSendRequest,
   paymentHashOf,
-  preimageForRfqSecrets,
   pushClaim,
   pushRefundWithoutReceiver,
-  randomSwapSecrets,
   readLockupFate,
   receiveVtxoScript,
   refundIfUnresolved,
@@ -3547,15 +3410,12 @@ var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
   restoreAssetSwaps,
   retireSettledOfferContracts,
   rfqPair,
-  rfqSecretsOfRecord,
-  rfqSecretsToRecord,
   sealClaimPacket,
-  senderIdentityForRfqSecrets,
   senderIdentityForSwapRecord,
-  senderPubkeyForRfqSecrets,
   spendTxidsOf,
   spendUpdate,
   swapPrograms,
+  swapSecretsToRecord,
   unilateralClaimDelay,
   unilateralRefundDelay,
   unilateralRefundWithoutReceiverDelay,