@arkade-os/swap 0.1.0-rc.11 → 0.1.0-rc.13

package/dist/advanced.cjs

@@ -35,1741 +35,1795 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/lockupContract.ts
-async function registerLockupContract(contracts, script, address) {
-  try {
-    await contracts.createContract({
-      type: SWAP_LOCKUP_CONTRACT_TYPE,
-      params: import_sdk3.VHTLCV2ContractHandler.serializeParams(script.options),
-      script: import_base3.hex.encode(script.pkScript),
-      address,
-      label: SWAP_LOCKUP_CONTRACT_LABEL,
-      metadata: { genericallySpendable: false, kind: SWAP_LOCKUP_CONTRACT_KIND }
-    });
-  } catch (error) {
-    throw new LockupRegistrationFailed(script, address, error);
+// src/swap-want-asset.program.json
+var swap_want_asset_program_default;
+var init_swap_want_asset_program = __esm({
+  "src/swap-want-asset.program.json"() {
+    swap_want_asset_program_default = {
+      version: 0,
+      name: "banco-btc-to-asset",
+      params: [
+        { name: "makerWP", type: "pubkey" },
+        { name: "wantAmount", type: "int" },
+        { name: "wantAssetTxid", type: "hash" },
+        { name: "wantAssetGroupIndex", type: "int" },
+        { name: "server", type: "pubkey" },
+        { name: "user", type: "pubkey" }
+      ],
+      functions: {
+        fulfill: {
+          tapscript: { signers: ["$server"] },
+          arkadeScript: {
+            asm: [
+              0,
+              "$wantAssetTxid",
+              "$wantAssetGroupIndex",
+              "INSPECTOUTASSETLOOKUP",
+              "VERIFY",
+              "$wantAmount",
+              "GREATERTHANOREQUAL",
+              "VERIFY",
+              0,
+              "INSPECTOUTPUTSCRIPTPUBKEY",
+              1,
+              "EQUALVERIFY",
+              "$makerWP",
+              "EQUAL"
+            ]
+          }
+        },
+        cancel: {
+          tapscript: { signers: ["$user", "$server"] }
+        }
+      }
+    };
+  }
+});
+
+// src/swap-want-btc.program.json
+var swap_want_btc_program_default;
+var init_swap_want_btc_program = __esm({
+  "src/swap-want-btc.program.json"() {
+    swap_want_btc_program_default = {
+      version: 0,
+      name: "banco-asset-to-btc",
+      params: [
+        { name: "makerWP", type: "pubkey" },
+        { name: "wantAmount", type: "int" },
+        { name: "server", type: "pubkey" },
+        { name: "user", type: "pubkey" }
+      ],
+      functions: {
+        fulfill: {
+          tapscript: { signers: ["$server"] },
+          arkadeScript: {
+            asm: [
+              0,
+              "INSPECTOUTPUTVALUE",
+              "$wantAmount",
+              "GREATERTHANOREQUAL",
+              "VERIFY",
+              0,
+              "INSPECTOUTPUTSCRIPTPUBKEY",
+              1,
+              "EQUALVERIFY",
+              "$makerWP",
+              "EQUAL"
+            ]
+          }
+        },
+        cancel: {
+          tapscript: { signers: ["$user", "$server"] }
+        }
+      }
+    };
   }
+});
+
+// src/coverage.ts
+async function serialize(script, task) {
+  const previous = inFlight.get(script) ?? Promise.resolve();
+  const result = previous.then(task, task);
+  const settled = result.then(
+    () => {
+    },
+    () => {
+    }
+  );
+  inFlight.set(script, settled);
+  void settled.then(() => {
+    if (inFlight.get(script) === settled) inFlight.delete(script);
+  });
+  return result;
 }
-async function lockupContractParams(contracts, lockupAddress) {
-  const script = import_base3.hex.encode(import_sdk3.ArkAddress.decode(lockupAddress).pkScript);
-  const [row] = await contracts.getContracts({ script });
-  if (!row) throw new LockupContractMissing(lockupAddress, script);
-  return row.params;
+function addressOutstanding(swaps, script) {
+  const issued = issuedAt.get(script);
+  if (issued === void 0) return false;
+  if (swaps.some((s) => s.swapPkScript === script && s.createdAt >= issued)) {
+    issuedAt.delete(script);
+    return false;
+  }
+  return true;
 }
-var import_base3, import_sdk3, SWAP_LOCKUP_CONTRACT_TYPE, SWAP_LOCKUP_CONTRACT_LABEL, SWAP_LOCKUP_CONTRACT_KIND, LockupContractMissing, LockupRegistrationFailed;
-var init_lockupContract = __esm({
-  "src/lockupContract.ts"() {
+async function promoteOfferContract(manager, script, issued = Date.now()) {
+  await serialize(script, async () => {
+    await manager.setContractWatchState(script, "watched");
+    issuedAt.set(script, issued);
+  });
+}
+async function retireOfferContract(manager, swaps, script) {
+  await serialize(script, async () => {
+    if (swaps.some((s) => s.swapPkScript === script && !RETIRABLE.includes(s.status))) return;
+    if (addressOutstanding(swaps, script)) return;
+    try {
+      await manager.setContractWatchState(script, "retained");
+    } catch (err) {
+      console.warn(`[swap] could not retire offer contract ${script}`, err);
+    }
+  });
+}
+async function retireSettledOfferContracts(manager, swaps) {
+  const settled = new Set(
+    swaps.filter((s) => RETIRABLE.includes(s.status)).map((s) => s.swapPkScript)
+  );
+  for (const script of settled) await retireOfferContract(manager, swaps, script);
+}
+var RETIRABLE, LOCKUP_RETIRABLE, issuedAt, inFlight;
+var init_coverage = __esm({
+  "src/coverage.ts"() {
     "use strict";
-    import_base3 = require("@scure/base");
-    import_sdk3 = require("@arkade-os/sdk");
-    SWAP_LOCKUP_CONTRACT_TYPE = "vhtlc-v2";
-    SWAP_LOCKUP_CONTRACT_LABEL = "Arkade RFQ swap lockup";
-    SWAP_LOCKUP_CONTRACT_KIND = "rfq-swap-lockup";
-    LockupContractMissing = class extends Error {
-      /** The lockup whose row is absent. */
-      address;
-      /** Its pkScript hex — the key the row would have been under. */
-      script;
-      constructor(address, script) {
-        super(
-          `no contract row for lockup ${address} (script ${script}); its covenant cannot be rebuilt from this wallet's contract store`
+    RETIRABLE = ["fulfilled", "cancelled"];
+    LOCKUP_RETIRABLE = ["settled", "refunded"];
+    issuedAt = /* @__PURE__ */ new Map();
+    inFlight = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/store.ts
+var import_base, import_sha2, import_sdk, BTC_ASSET_ID, byNewest, getAssetSwapsOrThrow, getAssetSwaps, saveSwapOrThrow, updateAssetSwap, updateAssetSwapBestEffort, swapSecretsToRecord, decodeHex32, PreimageNotRecoverableError, preimageForSwapRecord;
+var init_store = __esm({
+  "src/store.ts"() {
+    "use strict";
+    import_base = require("@scure/base");
+    import_sha2 = require("@noble/hashes/sha2.js");
+    import_sdk = require("@arkade-os/sdk");
+    BTC_ASSET_ID = "btc";
+    byNewest = (a, b) => b.createdAt - a.createdAt;
+    getAssetSwapsOrThrow = async (repository) => {
+      return (await repository.getAllSwaps()).filter(
+        (s) => s && typeof s.id === "string" && // offer swaps carry the TLV; onchain-corridor swaps carry
+        // the payment hash instead — either marks a valid record
+        (typeof s.offerHex === "string" || typeof s.paymentHash === "string")
+      ).sort(byNewest);
+    };
+    getAssetSwaps = async (repository) => {
+      try {
+        return await getAssetSwapsOrThrow(repository);
+      } catch {
+        return [];
+      }
+    };
+    saveSwapOrThrow = async (repository, swap) => {
+      try {
+        await repository.saveSwap(swap);
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`failed to save swap ${swap.id}: ${reason}`);
+      }
+    };
+    updateAssetSwap = async (repository, id, changes) => {
+      const swaps = (await getAssetSwapsOrThrow(repository)).map(
+        (s) => s.id === id ? { ...s, ...changes } : s
+      );
+      const updated = swaps.find((s) => s.id === id);
+      if (updated) await saveSwapOrThrow(repository, updated);
+      return swaps;
+    };
+    updateAssetSwapBestEffort = async (repository, id, changes) => {
+      try {
+        return { swaps: await updateAssetSwap(repository, id, changes), persisted: true };
+      } catch (error) {
+        console.warn(`[swap] failed to persist update for swap ${id}`, error);
+        const swaps = (await getAssetSwaps(repository)).map(
+          (s) => s.id === id ? { ...s, ...changes } : s
         );
-        this.name = "LockupContractMissing";
-        this.address = address;
-        this.script = script;
+        return { swaps, persisted: false };
       }
     };
-    LockupRegistrationFailed = class extends Error {
-      /** The lockup address that was never registered — never fund it: nothing
-       * is watching it. */
-      address;
-      /** The covenant the row would have been written from — the other half of
-       * `registerLockupContract`, so the write is retryable without a quote. */
-      script;
-      constructor(script, address, cause) {
-        super(`failed to register the lockup contract for ${address}`, { cause });
-        this.name = "LockupRegistrationFailed";
-        this.address = address;
-        this.script = script;
+    swapSecretsToRecord = (secrets) => ({
+      signingDescriptor: secrets.descriptor,
+      ..."mustPersistPreimage" in secrets && secrets.mustPersistPreimage ? { preimageHex: import_base.hex.encode(secrets.preimage) } : {},
+      ..."preimageSalt" in secrets && secrets.preimageSalt ? { preimageSaltHex: import_base.hex.encode(secrets.preimageSalt) } : {}
+    });
+    decodeHex32 = (value, field) => {
+      const bytes = import_base.hex.decode(value);
+      if (bytes.length !== 32) {
+        throw new Error(`${field} must be 32 bytes, got ${bytes.length}`);
+      }
+      return bytes;
+    };
+    PreimageNotRecoverableError = class extends Error {
+      constructor(reason, message, options) {
+        super(message, options);
+        this.reason = reason;
+      }
+      reason;
+      name = "PreimageNotRecoverableError";
+    };
+    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 (0, import_sdk.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 && import_base.hex.encode((0, import_sha2.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/onchainHtlc.ts
-function onchainHtlcScript(params, network) {
-  if (params.claimKey.length !== 32 || params.refundKey.length !== 32) {
-    throw new Error("claimKey and refundKey must be 32-byte x-only keys");
-  }
-  if (!Number.isInteger(params.refundLocktime) || params.refundLocktime <= 0) {
-    throw new Error(
-      `refundLocktime must be a positive unix timestamp, got ${params.refundLocktime}`
-    );
-  }
-  if (params.refundLocktime < LOCKTIME_THRESHOLD) {
-    throw new Error(
-      `refundLocktime ${params.refundLocktime} is below LOCKTIME_THRESHOLD (${LOCKTIME_THRESHOLD}) and would be interpreted as a block height`
-    );
-  }
-  if (!Object.hasOwn(L1_NETWORKS, network)) {
-    throw new Error(
-      `unknown L1 network '${String(network)}' \u2014 expected one of ${Object.keys(L1_NETWORKS).join(", ")}`
-    );
-  }
-  const h160 = h160FromPaymentHash(params.paymentHash);
-  const claim = btc.Script.encode([
-    "SIZE",
-    32,
-    "EQUALVERIFY",
-    "HASH160",
-    h160,
-    "EQUALVERIFY",
-    params.claimKey,
-    "CHECKSIG"
-  ]);
-  const refund = btc.Script.encode([
-    btc.ScriptNum().encode(BigInt(params.refundLocktime)),
-    "CHECKLOCKTIMEVERIFY",
-    "DROP",
-    params.refundKey,
-    "CHECKSIG"
-  ]);
-  const payment = btc.p2tr(
-    btc.TAPROOT_UNSPENDABLE_KEY,
-    btc.taprootListToTree([{ script: claim }, { script: refund }]),
-    L1_NETWORKS[network],
-    true
-  );
-  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)) {
-        return btc.TaprootControlBlock.encode(block);
+// src/offer.ts
+function withExitClosure(program, exit) {
+  if (!exit) return program;
+  return {
+    ...program,
+    // typed params are authoritative: an undeclared `$exitDelay` fails
+    // validateProgram instead of compiling against an unbound value
+    params: [...program.params ?? [], { name: "exitDelay", type: "int" }],
+    functions: {
+      ...program.functions,
+      exit: {
+        tapscript: { signers: ["$user"], csv: { type: exit.type, value: "$exitDelay" } }
       }
     }
-    throw new Error("leaf missing from compiled taproot tree");
-  };
-  return {
-    address: payment.address,
-    pkScript: payment.script,
-    leaves: { claim, refund },
-    controlBlocks: { claim: controlBlockFor(claim), refund: controlBlockFor(refund) },
-    paymentHash: params.paymentHash,
-    refundLocktime: params.refundLocktime
   };
 }
-function extractPreimage(txHex, paymentHash) {
-  let raw;
-  try {
-    raw = btc.RawTx.decode(import_base4.hex.decode(txHex));
-  } catch {
-    return null;
+function swapProgramBinding(offer, operatorPubkey) {
+  if (offer.makerPkScript.length !== FIELDS.makerPkScript.width) {
+    throw new Error("makerPkScript is not a 34-byte taproot scriptPubKey");
   }
-  for (const stack of raw.witnesses ?? []) {
-    for (const item of stack) {
-      if (item.length === 32 && import_base4.hex.encode((0, import_sha22.sha256)(item)) === paymentHash) return item;
+  return {
+    program: withExitClosure(
+      offer.wantAsset ? swapPrograms.wantAsset : swapPrograms.wantBtc,
+      offer.exitDelay
+    ),
+    args: {
+      makerWP: offer.makerPkScript.subarray(2),
+      wantAmount: offer.wantAmount,
+      server: operatorPubkey,
+      user: offer.makerPublicKey,
+      // internal byte order
+      ...offer.wantAsset && {
+        wantAssetTxid: offer.wantAsset.txid.slice().reverse(),
+        wantAssetGroupIndex: offer.wantAsset.groupIndex
+      },
+      ...offer.exitDelay && { exitDelay: offer.exitDelay.value }
+    },
+    keys: {
+      serverKey: operatorPubkey,
+      userKey: offer.makerPublicKey,
+      emulatorKey: offer.emulatorPubkey
     }
-  }
-  return null;
+  };
 }
-async function claimOnchainFill(chain, input) {
-  const now = input.now ?? Math.floor(Date.now() / 1e3);
-  if (input.htlc.refundLocktime - now < ONCHAIN_CLAIM_MARGIN_SECONDS) {
-    const error = new Error(
-      "refund leaf opens too soon to claim safely \u2014 take the covenant refund instead"
-    );
-    error.reason = "claim_window_closed";
-    throw error;
-  }
-  const spend = await buildHtlcClaim(input);
-  const txid = await chain.broadcast(spend.txHex);
-  return { txid, payoutAmount: spend.payoutAmount };
-}
-async function classifyOnchainHtlc(chain, input) {
-  const utxos = await chain.getScriptUtxos(input.htlc.pkScript);
-  const best = utxos.sort((a, b) => b.amount > a.amount ? 1 : -1)[0];
-  if (!best) {
-    if (!input.funding) return { phase: "unfunded" };
-    const spend = await chain.getSpendingTx(
-      input.funding.txid,
-      input.funding.vout,
-      input.htlc.pkScript
-    );
-    if (!spend) return { phase: "unfunded" };
-    const preimage = extractPreimage(spend.txHex, input.htlc.paymentHash);
-    const txid = btc.Transaction.fromRaw(import_base4.hex.decode(spend.txHex), {
-      allowUnknownInputs: true,
-      allowUnknownOutputs: true
-    }).id;
-    return preimage ? { phase: "claimed", txid, preimage } : { phase: "swept", txid };
-  }
-  if (best.confirmations < input.minConfirmations)
-    return { phase: "awaiting_confirmations", utxo: best };
-  const mtp = await chain.getMtp();
-  if (mtp >= input.htlc.refundLocktime) return { phase: "refundable", utxo: best };
-  return { phase: "claimable", utxo: best };
+function offerContract(offer, operatorPubkey) {
+  const { program, args, keys } = swapProgramBinding(offer, operatorPubkey);
+  return new import_sdk2.arkade.ArkadeProgramScript(program, args, keys);
 }
-var import_base4, import_sha22, import_legacy, btc, ONCHAIN_ORDER_MARGIN_SECONDS, ONCHAIN_CLAIM_MARGIN_SECONDS, MAX_MIN_CONFIRMATIONS, LOCKTIME_THRESHOLD, ONCHAIN_SECONDS_PER_BLOCK, ONCHAIN_DUST_SATS, ONCHAIN_CLAIM_VSIZE, paymentHashOf, h160FromPaymentHash, L1_NETWORKS, l1ScriptForAddress, buildLeafSpend, buildHtlcClaim;
-var init_onchainHtlc = __esm({
-  "src/onchainHtlc.ts"() {
-    "use strict";
-    import_base4 = require("@scure/base");
-    import_sha22 = require("@noble/hashes/sha2.js");
-    import_legacy = require("@noble/hashes/legacy.js");
-    btc = __toESM(require("@scure/btc-signer"), 1);
-    ONCHAIN_ORDER_MARGIN_SECONDS = 2 * 60 * 60;
-    ONCHAIN_CLAIM_MARGIN_SECONDS = 90 * 60;
-    MAX_MIN_CONFIRMATIONS = 6;
-    LOCKTIME_THRESHOLD = 5e8;
-    ONCHAIN_SECONDS_PER_BLOCK = 600;
-    ONCHAIN_DUST_SATS = BigInt(330);
-    ONCHAIN_CLAIM_VSIZE = 152;
-    paymentHashOf = (preimage) => import_base4.hex.encode((0, import_sha22.sha256)(preimage));
-    h160FromPaymentHash = (paymentHash) => (0, import_legacy.ripemd160)(import_base4.hex.decode(paymentHash));
-    L1_NETWORKS = {
-      bitcoin: btc.NETWORK,
-      testnet: btc.TEST_NETWORK,
-      regtest: { ...btc.TEST_NETWORK, bech32: "bcrt" }
-    };
-    l1ScriptForAddress = (address, network) => btc.OutScript.encode(btc.Address(L1_NETWORKS[network]).decode(address));
-    buildLeafSpend = async (input) => {
-      if (!Number.isFinite(input.feeRateSatVb) || input.feeRateSatVb <= 0) {
-        throw new Error(`feeRateSatVb must be positive, got ${input.feeRateSatVb}`);
-      }
-      const assemble = (payout2) => {
-        const tx2 = new btc.Transaction({ lockTime: input.lockTime ?? 0 });
-        tx2.addInput({
-          txid: input.utxo.txid,
-          index: input.utxo.vout,
-          witnessUtxo: { script: input.htlc.pkScript, amount: input.utxo.amount },
-          sequence: input.sequence
-        });
-        tx2.addOutput({ script: input.payoutPkScript, amount: payout2 });
-        return tx2;
-      };
-      const witness = (sig2) => [
-        sig2,
-        ...input.stackAboveSig,
-        input.leaf,
-        input.controlBlock
-      ];
-      const sizing = assemble(input.utxo.amount);
-      sizing.updateInput(0, { finalScriptWitness: witness(new Uint8Array(64)) }, true);
-      const fee = BigInt(Math.ceil(sizing.vsize * input.feeRateSatVb));
-      const payout = input.utxo.amount - fee;
-      if (payout < ONCHAIN_DUST_SATS) {
-        throw new Error(
-          `fee ${fee} leaves ${payout} sats from a ${input.utxo.amount} sat HTLC \u2014 below the ${ONCHAIN_DUST_SATS} sat dust limit`
-        );
-      }
-      const tx = assemble(payout);
-      const sighash = tx.preimageWitnessV1(
-        0,
-        [input.htlc.pkScript],
-        btc.SigHash.DEFAULT,
-        [input.utxo.amount],
-        void 0,
-        input.leaf,
-        192
-      );
-      const sig = await input.sign(sighash);
-      if (sig.length !== 64)
-        throw new Error(`sign() must return a 64-byte BIP340 signature, got ${sig.length}`);
-      tx.updateInput(0, { finalScriptWitness: witness(sig) }, true);
-      return { txHex: tx.hex, txid: tx.id, payoutAmount: payout };
-    };
-    buildHtlcClaim = async (input) => {
-      if (paymentHashOf(input.preimage) !== input.htlc.paymentHash) {
-        throw new Error("preimage does not hash to the HTLC's payment hash");
-      }
-      return buildLeafSpend({
-        htlc: input.htlc,
-        utxo: input.utxo,
-        leaf: input.htlc.leaves.claim,
-        controlBlock: input.htlc.controlBlocks.claim,
-        stackAboveSig: [input.preimage],
-        payoutPkScript: input.payoutPkScript,
-        feeRateSatVb: input.feeRateSatVb,
-        sign: input.sign,
-        sequence: 4294967293
-      });
-    };
+function u64(name, value) {
+  if (value < BigInt(0) || value >> BigInt(64) > BigInt(0)) {
+    throw new Error(`${name} does not fit the offer wire format (u64)`);
   }
-});
-
-// src/claimPacket.ts
-async function sealClaimPacket(input) {
-  return sealWithEntropy(
-    input,
-    import_secp256k1.secp256k1.utils.randomSecretKey(),
-    crypto.getRandomValues(new Uint8Array(12))
-  );
+  const out = new Uint8Array(FIELDS.wantAmount.width);
+  new DataView(out.buffer).setBigUint64(0, value, false);
+  return out;
 }
-async function sealWithEntropy(input, ephemeralKey, nonce) {
-  if (input.preimage.length !== 32) throw new Error("preimage must be 32 bytes");
-  if (input.covclaimdPubkey.length !== 33) {
-    throw new Error("covclaimd pubkey must be 33-byte compressed");
-  }
-  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_sha23.sha256, sharedX, ephemeralPub, HKDF_INFO, 32);
-  if (nonce.length !== 12) throw new Error("nonce must be 12 bytes");
-  const sealed = (0, import_aes.gcm)(key, nonce, ephemeralPub).encrypt(input.preimage);
-  const ciphertext = new Uint8Array(33 + 12 + sealed.length);
-  ciphertext.set(ephemeralPub, 0);
-  ciphertext.set(nonce, 33);
-  ciphertext.set(sealed, 45);
-  return {
-    ciphertext: import_base6.base64.encode(ciphertext),
-    packet: import_base6.base64.encode(
-      (0, import_utils2.concatBytes)(
-        tlv2(TLV_CIPHERTEXT, ciphertext),
-        tlv2(TLV_COVCLAIMD_PUBKEY, input.covclaimdPubkey)
-      )
-    )
-  };
+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);
 }
-var import_base6, import_utils2, import_aes, import_secp256k1, import_hkdf, import_sha23, HKDF_INFO, TLV_CIPHERTEXT, TLV_COVCLAIMD_PUBKEY, tlv2;
-var init_claimPacket = __esm({
-  "src/claimPacket.ts"() {
-    "use strict";
-    import_base6 = require("@scure/base");
-    import_utils2 = require("@scure/btc-signer/utils.js");
-    import_aes = require("@noble/ciphers/aes.js");
-    import_secp256k1 = require("@noble/curves/secp256k1.js");
-    import_hkdf = require("@noble/hashes/hkdf.js");
-    import_sha23 = require("@noble/hashes/sha2.js");
-    HKDF_INFO = new TextEncoder().encode("covclaimd/preimage/v1");
-    TLV_CIPHERTEXT = 1;
-    TLV_COVCLAIMD_PUBKEY = 3;
-    tlv2 = (type, value) => Uint8Array.from([type, value.length >> 8 & 255, value.length & 255, ...value]);
+function encodeOffer(offer) {
+  if (Boolean(offer.wantAsset) === Boolean(offer.offerAsset)) {
+    throw new Error("offer must carry exactly one of wantAsset or offerAsset");
   }
-});
-
-// src/rfq.ts
-function lightningSendContract(params) {
-  const seconds = (value) => ({
-    type: "seconds",
-    value: BigInt(value)
-  });
-  return new import_sdk5.VHTLC.ScriptV2({
-    sender: params.senderPubkey,
-    receiver: params.solverPubkey,
-    server: params.operatorPubkey,
-    preimageHash: (0, import_legacy2.ripemd160)(import_base7.hex.decode(params.paymentHash)),
-    refundLocktime: BigInt(params.refundLocktime),
-    unilateralClaimDelay: seconds(params.claimDelay),
-    unilateralRefundDelay: seconds(unilateralRefundDelay(params.claimDelay)),
-    unilateralRefundWithoutReceiverDelay: seconds(
-      params.refundWithoutReceiverDelay ?? unilateralRefundWithoutReceiverDelay(params.claimDelay)
-    ),
-    nonInteractiveParameters: {
-      receiverPkScript: params.receiverPkScript,
-      senderPkScript: params.refundPkScript,
-      emulatorPubkey: params.emulatorPubkey,
-      ...params.legacy !== void 0 && { legacy: params.legacy }
+  for (const name of [
+    "swapPkScript",
+    "makerPkScript",
+    "makerPublicKey",
+    "emulatorPubkey"
+  ]) {
+    if (offer[name].length !== FIELDS[name].width) {
+      throw new Error(`${name} must be ${FIELDS[name].width} bytes`);
     }
-  });
-}
-function deriveLightningSend(input) {
-  const { quote } = input;
-  if (quote.refund_locktime === void 0) {
-    throw new Error("lightning-send quote is missing refund_locktime");
   }
-  const refundWithoutReceiverDelay = quote.profile?.refund_without_receiver_delay;
-  if (refundWithoutReceiverDelay === void 0) {
-    throw new Error("lightning-send quote is missing profile.refund_without_receiver_delay");
+  const ratioNum = setRatio("ratioNum", offer.ratioNum);
+  const ratioDen = setRatio("ratioDen", offer.ratioDen);
+  if (ratioNum === void 0 !== (ratioDen === void 0)) {
+    throw new Error("offer must carry both ratioNum and ratioDen, or neither");
   }
-  if (!Number.isSafeInteger(refundWithoutReceiverDelay) || refundWithoutReceiverDelay < input.claimDelay || refundWithoutReceiverDelay % SEQUENCE_GRANULARITY_SECONDS !== 0 || refundWithoutReceiverDelay > 65535 * SEQUENCE_GRANULARITY_SECONDS) {
-    throw new Error("lightning-send quote carries an invalid refund_without_receiver_delay");
+  const recs = [
+    tlv(FIELDS.swapPkScript.tag, offer.swapPkScript),
+    tlv(FIELDS.wantAmount.tag, u64("wantAmount", offer.wantAmount))
+  ];
+  if (offer.wantAsset) recs.push(tlv(FIELDS.wantAsset.tag, offer.wantAsset.serialize()));
+  if (ratioNum !== void 0) recs.push(tlv(FIELDS.ratioNum.tag, u64("ratioNum", ratioNum)));
+  if (ratioDen !== void 0) recs.push(tlv(FIELDS.ratioDen.tag, u64("ratioDen", ratioDen)));
+  if (offer.offerAsset) recs.push(tlv(FIELDS.offerAsset.tag, offer.offerAsset.serialize()));
+  recs.push(
+    tlv(FIELDS.makerPkScript.tag, offer.makerPkScript),
+    tlv(FIELDS.makerPublicKey.tag, offer.makerPublicKey),
+    tlv(FIELDS.emulatorPubkey.tag, offer.emulatorPubkey)
+  );
+  if (offer.exitDelay) recs.push(tlv(FIELDS.exitTimelock.tag, encodeExitDelay(offer.exitDelay)));
+  return (0, import_utils.concatBytes)(...recs);
+}
+function encodeExitDelay(exit) {
+  return (0, import_utils.concatBytes)(
+    Uint8Array.of(EXIT_TYPES.indexOf(assertExitDelay(exit).type)),
+    u64("exitDelay", exit.value)
+  );
+}
+function assertExitDelay(exit) {
+  if (EXIT_TYPES.indexOf(exit.type) < 0) {
+    throw new Error(`unknown exitDelay locktime type: ${exit.type}`);
   }
-  if (refundWithoutReceiverDelay < quote.refund_locktime - input.now) {
-    throw new Error("lightning-send quote lets the solo refund open before refund_locktime");
+  if (exit.value <= BigInt(0)) {
+    throw new Error("exitDelay must be a positive relative locktime");
   }
-  const receiverPkScriptHex = quote.profile?.receiver_pk_script;
-  if (receiverPkScriptHex === void 0) {
-    throw new Error("lightning-send quote is missing profile.receiver_pk_script");
+  if (exit.value >> BigInt(32) > BigInt(0)) {
+    throw new Error("exitDelay does not fit the locktime field (u32)");
   }
-  const contractParams = {
-    solverPubkey: (0, import_sdk5.toXOnly)(import_base7.hex.decode(quote.solver_pubkey), "solver key"),
-    refundLocktime: quote.refund_locktime,
-    operatorPubkey: input.operatorPubkey,
-    paymentHash: input.paymentHash,
-    claimDelay: input.claimDelay,
-    refundWithoutReceiverDelay,
-    emulatorPubkey: input.emulatorPubkey,
-    senderPubkey: input.senderPubkey,
-    receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
-    refundPkScript: input.refundPkScript
-  };
-  const matched = matchQuotedLockup(
-    quote,
-    input.hrp,
-    input.operatorPubkey,
-    (legacy) => lightningSendContract({ ...contractParams, ...legacy !== void 0 && { legacy } })
-  );
-  return {
-    address: matched.address,
-    swapPkScript: matched.script.pkScript,
-    script: matched.script,
-    contractParams: {
-      ...contractParams,
-      ...matched.legacy !== void 0 && { legacy: matched.legacy }
-    },
-    refundLocktime: quote.refund_locktime
-  };
+  return exit;
 }
-function deriveOnchainSend(input) {
-  const { quote } = input;
-  const profile = quote.profile ?? {};
-  const refundLocktime = quote.refund_locktime ?? profile.refund_locktime;
-  const htlcPubkey = profile.htlc_pubkey;
-  const htlcLocktime = profile.htlc_locktime;
-  const htlcAddress = profile.htlc_address;
-  const minConfirmations = profile.min_confirmations;
-  const receiverPkScriptHex = profile.receiver_pk_script;
-  if (refundLocktime === void 0 || htlcPubkey === void 0 || htlcLocktime === void 0 || minConfirmations === void 0 || receiverPkScriptHex === void 0) {
-    throw new Error("onchain-send quote is missing a binding field");
+function decodeOffer(data) {
+  const fields = {};
+  let off = 0;
+  while (off < data.length) {
+    if (off + 3 > data.length) throw new Error("truncated TLV header");
+    const type = data[off];
+    const length = data[off + 1] << 8 | data[off + 2];
+    off += 3;
+    if (off + length > data.length)
+      throw new Error(`truncated TLV value for type 0x${type.toString(16)}`);
+    const name = NAMES[type];
+    if (!name) throw new Error(`unknown TLV type: 0x${type.toString(16)}`);
+    if (fields[name] !== void 0) throw new Error(`duplicate TLV record: ${name}`);
+    fields[name] = data.slice(off, off + length);
+    off += length;
   }
-  const contractParams = {
-    solverPubkey: (0, import_sdk5.toXOnly)(import_base7.hex.decode(quote.solver_pubkey), "solver key"),
-    refundLocktime,
-    operatorPubkey: input.operatorPubkey,
-    paymentHash: input.paymentHash,
-    claimDelay: input.claimDelay,
-    emulatorPubkey: input.emulatorPubkey,
-    senderPubkey: input.senderPubkey,
-    receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
-    refundPkScript: import_sdk5.ArkAddress.decode(input.refundAddress).pkScript
+  for (const name of ["wantAsset", "offerAsset"]) {
+    if (fields[name]?.length === 0) throw new Error(`missing/invalid ${name}`);
+  }
+  for (const [name, value] of Object.entries(fields)) {
+    const width = FIELDS[name].width;
+    if (width !== void 0 && value.length !== width) {
+      throw new Error(`missing/invalid ${name}`);
+    }
+  }
+  const need = (name) => {
+    const v = fields[name];
+    const len = FIELDS[name].width;
+    if (!v || len !== void 0 && v.length !== len)
+      throw new Error(`missing/invalid ${name}`);
+    return v;
   };
-  const { script, address } = matchQuotedLockup(
-    quote,
-    input.hrp,
-    input.operatorPubkey,
-    (legacy) => lightningSendContract({ ...contractParams, ...legacy !== void 0 && { legacy } })
-  );
-  const htlcParams = {
-    paymentHash: input.paymentHash,
-    claimKey: input.payoutPubkey,
-    refundKey: (0, import_sdk5.toXOnly)(import_base7.hex.decode(htlcPubkey), "solver L1 htlc key"),
-    refundLocktime: htlcLocktime
+  const amount = need("wantAmount");
+  if (Boolean(fields.wantAsset) === Boolean(fields.offerAsset)) {
+    throw new Error("offer must carry exactly one of wantAsset or offerAsset");
+  }
+  const readRatio = (name) => {
+    const raw = fields[name];
+    if (!raw) return void 0;
+    const value = readU64(raw);
+    if (value === BigInt(0)) throw new Error(`missing/invalid ${name}`);
+    return value;
   };
-  const htlc = onchainHtlcScript(htlcParams, input.l1Network);
-  if (htlc.address !== htlcAddress) throw new AddressMismatch(htlc.address, htlcAddress);
+  const ratioNum = readRatio("ratioNum");
+  const ratioDen = readRatio("ratioDen");
+  if (ratioNum === void 0 !== (ratioDen === void 0)) {
+    throw new Error("offer must carry both ratioNum and ratioDen, or neither");
+  }
   return {
-    address,
-    swapPkScript: script.pkScript,
-    script,
-    htlc,
-    htlcParams,
-    l1Network: input.l1Network,
-    refundLocktime,
-    htlcLocktime,
-    minConfirmations
+    swapPkScript: need("swapPkScript"),
+    wantAmount: readU64(amount),
+    ...fields.wantAsset && { wantAsset: import_sdk2.asset.AssetId.fromBytes(fields.wantAsset) },
+    ...fields.offerAsset && { offerAsset: import_sdk2.asset.AssetId.fromBytes(fields.offerAsset) },
+    makerPkScript: need("makerPkScript"),
+    makerPublicKey: need("makerPublicKey"),
+    emulatorPubkey: need("emulatorPubkey"),
+    ...ratioNum !== void 0 && { ratioNum },
+    ...ratioDen !== void 0 && { ratioDen },
+    ...fields.exitTimelock && { exitDelay: decodeExitDelay(fields.exitTimelock) }
   };
 }
-function lightningReceiveContract(params) {
-  const seconds = (value) => ({
-    type: "seconds",
-    value: BigInt(value)
-  });
-  return new import_sdk5.VHTLC.ScriptV2({
-    sender: params.solverPubkey,
-    receiver: params.payoutPubkey,
-    server: params.operatorPubkey,
-    preimageHash: (0, import_legacy2.ripemd160)(import_base7.hex.decode(params.paymentHash)),
-    refundLocktime: BigInt(params.refundLocktime),
-    unilateralClaimDelay: seconds(params.claimDelay),
-    unilateralRefundDelay: seconds(unilateralRefundDelay(params.claimDelay)),
-    unilateralRefundWithoutReceiverDelay: seconds(
-      unilateralRefundWithoutReceiverDelay(params.claimDelay)
-    ),
-    nonInteractiveParameters: {
-      receiverPkScript: params.payoutPkScript,
-      senderPkScript: params.solverRefundPkScript,
-      emulatorPubkey: params.emulatorPubkey,
-      ...params.legacy !== void 0 && { legacy: params.legacy }
-    }
+function decodeExitDelay(value) {
+  const type = EXIT_TYPES[value[0]];
+  if (!type) throw new Error(`unknown exitDelay locktime type: 0x${value[0].toString(16)}`);
+  return { type, value: readU64(value.subarray(1)) };
+}
+async function registerOfferContract(wallet, info, binding, operatorPubkey, expectedPkScript) {
+  const contractManager = await wallet.getContractManager();
+  const client = await import_sdk2.arkade.Arkade.connect({
+    // Registration derives and persists; it never broadcasts and never
+    // reads UTXOs, so the only thing the client needs off the server is the
+    // info the caller already resolved. Handing that back — rather than a
+    // provider built from a URL — is what lets `createOffer` take just a
+    // wallet, and spares a second `/v1/info` round-trip.
+    arkade: { getInfo: async () => info },
+    identity: wallet.identity,
+    // without this the row's `address` would be derived against the SDK's
+    // default network while its script is right — a row that disagrees with
+    // the address the user is about to fund
+    network: (0, import_sdk2.networkFromArkadeInfo)(info),
+    contractManager
   });
+  await contractManager.createContract(
+    offerContractParams(client, binding, operatorPubkey, expectedPkScript)
+  );
+  await promoteOfferContract(contractManager, import_base2.hex.encode(expectedPkScript));
 }
-function deriveLightningReceive(input) {
-  const { quote } = input;
-  const profile = quote.profile ?? {};
-  const refundLocktime = quote.refund_locktime;
-  const invoice = profile.invoice;
-  const solverRefundPkScriptHex = profile.solver_refund_pk_script;
-  if (refundLocktime === void 0 || invoice === void 0 || solverRefundPkScriptHex === void 0) {
-    throw new Error("lightning-receive quote is missing a binding field");
+function offerContractParams(client, binding, operatorPubkey, expectedPkScript) {
+  const { program, args, keys } = swapProgramBinding(binding, operatorPubkey);
+  const contract = new import_sdk2.arkade.ArkadeContract(client, program, args, keys);
+  if (import_base2.hex.encode(contract.pkScript) !== import_base2.hex.encode(expectedPkScript)) {
+    throw new Error("derived covenant does not match the offer's swapPkScript");
   }
-  const contractParams = {
-    solverPubkey: (0, import_sdk5.toXOnly)(import_base7.hex.decode(quote.solver_pubkey), "solver key"),
-    refundLocktime,
-    operatorPubkey: input.operatorPubkey,
-    paymentHash: input.paymentHash,
-    claimDelay: input.claimDelay,
-    emulatorPubkey: input.emulatorPubkey,
-    solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
-    payoutPubkey: input.payoutPubkey,
-    payoutPkScript: import_sdk5.ArkAddress.decode(input.payoutAddress).pkScript
-  };
-  const matched = matchQuotedLockup(
-    quote,
-    input.hrp,
-    input.operatorPubkey,
-    (legacy) => lightningReceiveContract({ ...contractParams, ...legacy !== void 0 && { legacy } })
-  );
   return {
-    address: matched.address,
-    swapPkScript: matched.script.pkScript,
-    script: matched.script,
-    invoice,
-    refundLocktime,
-    contractParams: {
-      ...contractParams,
-      ...matched.legacy !== void 0 && { legacy: matched.legacy }
-    }
+    ...contract.toContractParams(),
+    label: OFFER_CONTRACT_LABEL,
+    metadata: { genericallySpendable: false, kind: OFFER_CONTRACT_KIND }
   };
 }
-var import_base7, import_legacy2, import_sdk5, import_sdk6, solverHex, ARKADE_BTC, LIGHTNING_BTC, ONCHAIN_BTC, rfqPair, LIGHTNING_SEND_PAIR, LIGHTNING_RECEIVE_PAIR, ONCHAIN_SEND_PAIR, ONCHAIN_RECEIVE_PAIR, RFQ_REFUSAL_ERROR_CODES, isRfqRefusalErrorCode, REFUSAL_FIELDS, REFUSAL_UNITS, safeInteger, safeRefusalDetail, refusalMessage, SwapRefusal, AddressMismatch, newRfqId, lightningSendRequest, MIN_HEADROOM_SECONDS, gateError, assertFinite, MAX_PAIR_LENGTH, assertPairLength, verifyLockupAddress, LOCKUP_SHAPE_VARIANTS, matchQuotedLockup, assertFundable, expectQuote, pairOf, SEQUENCE_GRANULARITY_SECONDS, SOLO_REFUND_HEADROOM_SECONDS, unilateralClaimDelay, unilateralRefundDelay, unilateralRefundWithoutReceiverDelay, l1NetworkFromArk, onchainSendRequest, lightningReceiveRequest, MIN_CLAIM_WINDOW_SECONDS, assertReceivable;
-var init_rfq = __esm({
-  "src/rfq.ts"() {
-    "use strict";
-    import_base7 = require("@scure/base");
-    import_legacy2 = require("@noble/hashes/legacy.js");
-    import_sdk5 = require("@arkade-os/sdk");
-    init_onchainHtlc();
-    init_onchainHtlc();
-    import_sdk6 = require("@arkade-os/sdk");
-    init_claimPacket();
-    init_lockupContract();
-    solverHex = (value, field) => {
-      try {
-        return import_base7.hex.decode(value);
-      } catch {
-        throw new Error(`solver sent malformed hex for ${field}`);
-      }
-    };
-    ARKADE_BTC = "arkade:BTC";
-    LIGHTNING_BTC = "lightning:BTC";
-    ONCHAIN_BTC = "onchain:BTC";
-    rfqPair = (from, to) => `${from}->${to}`;
-    LIGHTNING_SEND_PAIR = rfqPair(ARKADE_BTC, LIGHTNING_BTC);
-    LIGHTNING_RECEIVE_PAIR = rfqPair(LIGHTNING_BTC, ARKADE_BTC);
-    ONCHAIN_SEND_PAIR = rfqPair(ARKADE_BTC, ONCHAIN_BTC);
-    ONCHAIN_RECEIVE_PAIR = rfqPair(ONCHAIN_BTC, ARKADE_BTC);
-    RFQ_REFUSAL_ERROR_CODES = [
-      "amount_side_unsupported",
-      "exact_out_unsupported",
-      "invalid_amount",
-      "invalid_payout_address",
-      "invalid_refund_address",
-      "invoice_amount_mismatch",
-      "invoice_cltv_too_large",
-      "invoice_malformed",
-      "invoice_missing_amount",
-      "invoice_missing_network",
-      "invoice_missing_payment_hash",
-      "invoice_missing_timestamp",
-      "invoice_mixed_case",
-      "invoice_sub_satoshi_amount",
-      "invoice_too_long",
-      "invoice_wrong_network"
-    ];
-    isRfqRefusalErrorCode = (value) => typeof value === "string" && RFQ_REFUSAL_ERROR_CODES.includes(value);
-    REFUSAL_FIELDS = /* @__PURE__ */ new Set([
-      "amount",
-      "amount_side",
-      "profile.invoice",
-      "profile.payout_address",
-      "profile.refund_address"
-    ]);
-    REFUSAL_UNITS = /* @__PURE__ */ new Set(["blocks", "characters", "sats"]);
-    safeInteger = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
-    safeRefusalDetail = (detail) => {
-      if (!isRfqRefusalErrorCode(detail.errorCode)) return {};
-      return {
-        errorCode: detail.errorCode,
-        field: typeof detail.field === "string" && REFUSAL_FIELDS.has(detail.field) ? detail.field : void 0,
-        actual: safeInteger(detail.actual),
-        expected: safeInteger(detail.expected),
-        limit: safeInteger(detail.limit),
-        unit: typeof detail.unit === "string" && REFUSAL_UNITS.has(detail.unit) ? detail.unit : void 0
-      };
-    };
-    refusalMessage = (reason, detail) => {
-      if (!detail.errorCode) return `solver refused: ${reason}`;
-      const where = detail.field ? ` at ${detail.field}` : "";
-      const unit = detail.unit ? ` ${detail.unit}` : "";
-      if (detail.actual !== void 0 && detail.limit !== void 0) {
-        return `solver refused: ${reason} (${detail.errorCode}${where}: ${detail.actual}${unit}, limit ${detail.limit})`;
-      }
-      if (detail.actual !== void 0 && detail.expected !== void 0) {
-        return `solver refused: ${reason} (${detail.errorCode}${where}: ${detail.actual}${unit}, expected ${detail.expected})`;
-      }
-      return `solver refused: ${reason} (${detail.errorCode}${where})`;
+function serverExitDelay(delay) {
+  if (typeof delay !== "bigint" || delay <= BigInt(0)) {
+    throw new Error(
+      "the server reports no usable unilateralExitDelay; pass `exitDelay` to set the offer's exit closure explicitly, or `noExit: true` to publish without one"
+    );
+  }
+  return assertExitDelay({ value: delay, type: delay < BigInt(512) ? "blocks" : "seconds" });
+}
+async function createOffer(wallet, params) {
+  if (Boolean(params.wantAsset) === Boolean(params.offerAsset)) {
+    throw new Error("set exactly one of wantAsset (BTC->asset) or offerAsset (asset->BTC)");
+  }
+  const [info, makerAddress, makerPublicKey] = await Promise.all([
+    // requireLive: this info binds signerPubkey into the covenant — a
+    // snapshot could derive an address the operator no longer co-signs
+    // for, so an unreachable operator fails the call instead (fail closed,
+    // the same behaviour the pre-#734 caller-held provider had)
+    wallet.getArkadeInfo({ requireLive: true }),
+    wallet.getAddress(),
+    wallet.identity.xOnlyPublicKey()
+  ]);
+  const operatorPubKey = import_base2.hex.decode((0, import_sdk2.toXOnlySignerHex)(info.signerPubkey));
+  const network = (0, import_sdk2.networkFromArkadeInfo)(info);
+  const emuKey = import_base2.hex.decode(
+    (0, import_sdk2.toXOnlySignerHex)((0, import_sdk2.resolveEmulatorPubkey)(network, params.emulatorPubkey))
+  );
+  const binding = {
+    wantAmount: params.wantAmount,
+    wantAsset: params.wantAsset,
+    offerAsset: params.offerAsset,
+    makerPkScript: import_sdk2.ArkAddress.decode(makerAddress).pkScript,
+    makerPublicKey,
+    emulatorPubkey: emuKey,
+    // checked HERE, before the covenant is derived and registered below:
+    // deferring it to `encodeOffer` leaves a registered contract behind for
+    // an offer that then fails to encode. @see assertExitDelay
+    exitDelay: params.noExit ? void 0 : params.exitDelay ? assertExitDelay(params.exitDelay) : serverExitDelay(info.unilateralExitDelay)
+  };
+  const script = offerContract(binding, operatorPubKey);
+  const offer = { ...binding, swapPkScript: script.pkScript };
+  await registerOfferContract(wallet, info, binding, operatorPubKey, script.pkScript);
+  const payload = encodeOffer(offer);
+  return {
+    offerHex: import_base2.hex.encode(payload),
+    extension: { type: OFFER_PACKET_TYPE, payload },
+    // the contract's .address() builds the address; assembling an ArkAddress
+    // from tweakedPublicKey here would silently miss any future step it gains
+    address: script.address(network.hrp, operatorPubKey).encode(),
+    swapPkScript: script.pkScript
+  };
+}
+async function prepareOfferCancel(wallet, offerHex, opts) {
+  const { fundingTxid, swapAddress } = opts;
+  const offer = decodeOffer(import_base2.hex.decode(offerHex));
+  const [contractManager, info, reader, broadcaster] = await Promise.all([
+    wallet.getContractManager(),
+    wallet.getArkadeInfo({ requireLive: true }),
+    wallet.getArkadeReader(),
+    wallet.getArkadeBroadcaster()
+  ]);
+  const client = await import_sdk2.arkade.Arkade.connect({
+    // info the wallet already holds, plus its broadcast pair — the shape
+    // `ArkadeServerProvider` describes, without a second `/v1/info`
+    arkade: { getInfo: async () => info, ...broadcaster },
+    indexer: reader,
+    identity: wallet.identity,
+    // registered offers resolve their VTXOs from the contract repository
+    // instead of a direct indexer query; the indexer above stays as the
+    // fallback for offers created before registration existed
+    contractManager
+    // no `network`, unlike registerOfferContract: the row lookup is by
+    // script and the payout script comes from wallet.getAddress(), so the
+    // client's network (which only shapes address derivation) is unused here
+  });
+  const operatorPubkey = swapAddress ? import_sdk2.ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
+  const { program, args, keys } = swapProgramBinding(offer, operatorPubkey);
+  let rebuilt;
+  try {
+    rebuilt = new import_sdk2.arkade.ArkadeProgramScript(program, args, keys);
+  } catch (cause) {
+    throw new OfferCovenantMismatchError(import_base2.hex.encode(offer.swapPkScript), { cause });
+  }
+  if (import_base2.hex.encode(rebuilt.pkScript) !== import_base2.hex.encode(offer.swapPkScript)) {
+    throw new OfferCovenantMismatchError(import_base2.hex.encode(offer.swapPkScript));
+  }
+  const contract = new import_sdk2.arkade.ArkadeContract(client, program, args, keys);
+  const [vtxos, makerAddress] = await Promise.all([contract.getUtxos(), wallet.getAddress()]);
+  if (!fundingTxid && vtxos.length > 1) {
+    throw new Error(
+      "multiple spendable deposits at the swap address \u2014 pass fundingTxid to select one"
+    );
+  }
+  const vtxo = fundingTxid ? vtxos.find((v) => v.txid === fundingTxid) : vtxos[0];
+  if (!vtxo) throw new NoSpendableDepositError();
+  const makerPkScript = import_sdk2.ArkAddress.decode(makerAddress).pkScript;
+  const cancel = contract.functions.cancel().from({ txid: vtxo.txid, vout: vtxo.vout, value: vtxo.value }).to(makerPkScript, BigInt(vtxo.value));
+  for (const a of vtxo.assets ?? []) {
+    cancel.withAsset({
+      assetId: a.assetId,
+      inputs: [{ vin: 0, amount: BigInt(a.amount) }],
+      outputs: [{ vout: 0, amount: BigInt(a.amount) }]
+    });
+  }
+  return {
+    offer,
+    vtxo: { txid: vtxo.txid, vout: vtxo.vout, value: vtxo.value },
+    send: async () => (await cancel.send()).txid
+  };
+}
+var import_base2, import_utils, import_sdk2, swapPrograms, OFFER_PACKET_TYPE, FIELDS, EXIT_TYPES, NAMES, readU64, setRatio, OFFER_CONTRACT_LABEL, OFFER_CONTRACT_KIND, OFFER_COVENANT_MISMATCH, NoSpendableDepositError, OfferCovenantMismatchError, ASSET_CARRIER_SATS;
+var init_offer = __esm({
+  "src/offer.ts"() {
+    "use strict";
+    import_base2 = require("@scure/base");
+    import_utils = require("@scure/btc-signer/utils.js");
+    import_sdk2 = require("@arkade-os/sdk");
+    init_swap_want_asset_program();
+    init_swap_want_btc_program();
+    init_coverage();
+    init_store();
+    swapPrograms = {
+      wantAsset: import_sdk2.arkade.parseArtifact(swap_want_asset_program_default),
+      wantBtc: import_sdk2.arkade.parseArtifact(swap_want_btc_program_default)
     };
-    SwapRefusal = class extends Error {
-      /** Literal-typed so the v2 error taxonomy's union discriminates on `name`
-       * — a `string` here collapses the discriminant for every member. Same value
-       * the constructor has always set, moved to a field initializer. */
-      name = "SwapRefusal";
-      reason;
-      rfqId;
-      errorCode;
-      field;
-      actual;
-      expected;
-      limit;
-      unit;
-      constructor(reason, rfqId, detail = {}) {
-        const safeDetail = safeRefusalDetail(detail);
-        super(refusalMessage(reason, safeDetail));
-        this.reason = reason;
-        this.rfqId = rfqId;
-        this.errorCode = safeDetail.errorCode;
-        this.field = safeDetail.field;
-        this.actual = safeDetail.actual;
-        this.expected = safeDetail.expected;
-        this.limit = safeDetail.limit;
-        this.unit = safeDetail.unit;
-      }
+    OFFER_PACKET_TYPE = 3;
+    FIELDS = {
+      swapPkScript: { tag: 1, width: 34 },
+      wantAmount: { tag: 2, width: 8 },
+      wantAsset: { tag: 3, width: void 0 },
+      makerPkScript: { tag: 5, width: 34 },
+      makerPublicKey: { tag: 7, width: 32 },
+      emulatorPubkey: { tag: 8, width: 32 },
+      ratioNum: { tag: 9, width: 8 },
+      ratioDen: { tag: 10, width: 8 },
+      offerAsset: { tag: 11, width: void 0 },
+      exitTimelock: { tag: 12, width: 9 }
     };
-    AddressMismatch = class extends Error {
-      derived;
-      quoted;
-      constructor(derived, quoted) {
-        super("solver lockup address does not match local derivation \u2014 refusing to fund");
-        this.name = "AddressMismatch";
-        this.derived = derived;
-        this.quoted = quoted;
-      }
+    EXIT_TYPES = ["blocks", "seconds"];
+    NAMES = Object.fromEntries(Object.entries(FIELDS).map(([k, f]) => [f.tag, k]));
+    readU64 = (value) => new DataView(value.buffer, value.byteOffset).getBigUint64(0, false);
+    setRatio = (name, value) => {
+      if (value === void 0 || value === BigInt(0)) return void 0;
+      if (value < BigInt(0)) throw new Error(`${name} does not fit the offer wire format (u64)`);
+      return value;
     };
-    newRfqId = () => import_base7.hex.encode(crypto.getRandomValues(new Uint8Array(32)));
-    lightningSendRequest = (input) => ({
-      v: 1,
-      type: "rfq_request",
-      rfq_id: input.rfqId,
-      pair: LIGHTNING_SEND_PAIR,
-      amount_side: "to",
-      profile: {
-        invoice: input.invoice,
-        refund_address: input.refundAddress,
-        client_refund_pubkey: import_base7.hex.encode(input.senderPubkey)
+    OFFER_CONTRACT_LABEL = "Arkade swap offer";
+    OFFER_CONTRACT_KIND = "asset-swap-offer";
+    OFFER_COVENANT_MISMATCH = "rebuilt covenant does not match the offer's swapPkScript";
+    NoSpendableDepositError = class extends Error {
+      name = "NoSpendableDepositError";
+      constructor(options) {
+        super("no spendable VTXO at the swap address", options);
       }
-    });
-    MIN_HEADROOM_SECONDS = 90 * 60;
-    gateError = (reason, message) => {
-      const error = new Error(message);
-      error.reason = reason;
-      return error;
     };
-    assertFinite = (value, reason, label) => {
-      if (value !== void 0 && !Number.isFinite(value)) {
-        throw gateError(reason, `${label} is not a finite number (${String(value)})`);
+    OfferCovenantMismatchError = class extends Error {
+      constructor(swapPkScript, options) {
+        super(
+          `${OFFER_COVENANT_MISMATCH} \u2014 the operator signing key pinned by the rebuild does not reproduce the funded covenant; the signing key has likely rotated since funding (pass swapAddress, the funded address, to pin the original key), or the record is corrupt`,
+          options
+        );
+        this.swapPkScript = swapPkScript;
       }
+      swapPkScript;
+      name = "OfferCovenantMismatchError";
     };
-    MAX_PAIR_LENGTH = 158;
-    assertPairLength = (pair) => {
-      if (pair.length > MAX_PAIR_LENGTH) {
-        throw new Error(
-          `pair is ${pair.length} characters, over the wire's ${MAX_PAIR_LENGTH}-character limit`
+    ASSET_CARRIER_SATS = BigInt(import_sdk2.ASSET_CARRIER_SATS);
+  }
+});
+
+// src/lockupContract.ts
+async function registerLockupContract(contracts, script, address) {
+  try {
+    await contracts.createContract({
+      type: SWAP_LOCKUP_CONTRACT_TYPE,
+      params: import_sdk3.VHTLCV2ContractHandler.serializeParams(script.options),
+      script: import_base3.hex.encode(script.pkScript),
+      address,
+      label: SWAP_LOCKUP_CONTRACT_LABEL,
+      metadata: { genericallySpendable: false, kind: SWAP_LOCKUP_CONTRACT_KIND }
+    });
+  } catch (error) {
+    throw new LockupRegistrationFailed(script, address, error);
+  }
+}
+async function lockupContractParams(contracts, lockupAddress) {
+  const script = import_base3.hex.encode(import_sdk3.ArkAddress.decode(lockupAddress).pkScript);
+  const [row] = await contracts.getContracts({ script });
+  if (!row) throw new LockupContractMissing(lockupAddress, script);
+  return row.params;
+}
+var import_base3, import_sdk3, SWAP_LOCKUP_CONTRACT_TYPE, SWAP_LOCKUP_CONTRACT_LABEL, SWAP_LOCKUP_CONTRACT_KIND, LockupContractMissing, LockupRegistrationFailed;
+var init_lockupContract = __esm({
+  "src/lockupContract.ts"() {
+    "use strict";
+    import_base3 = require("@scure/base");
+    import_sdk3 = require("@arkade-os/sdk");
+    SWAP_LOCKUP_CONTRACT_TYPE = "vhtlc-v2";
+    SWAP_LOCKUP_CONTRACT_LABEL = "Arkade RFQ swap lockup";
+    SWAP_LOCKUP_CONTRACT_KIND = "rfq-swap-lockup";
+    LockupContractMissing = class extends Error {
+      /** The lockup whose row is absent. */
+      address;
+      /** Its pkScript hex — the key the row would have been under. */
+      script;
+      constructor(address, script) {
+        super(
+          `no contract row for lockup ${address} (script ${script}); its covenant cannot be rebuilt from this wallet's contract store`
         );
+        this.name = "LockupContractMissing";
+        this.address = address;
+        this.script = script;
       }
     };
-    verifyLockupAddress = (quote, derivedAddress) => {
-      const quoted = quote.profile?.lockup_address;
-      const candidates = Array.isArray(derivedAddress) ? derivedAddress : [derivedAddress];
-      const matched = candidates.find((address) => address === quoted);
-      if (matched === void 0) throw new AddressMismatch(candidates, quoted);
-      return matched;
-    };
-    LOCKUP_SHAPE_VARIANTS = [void 0, "preTimelockedRefund"];
-    matchQuotedLockup = (quote, hrp, serverPubkey, build) => {
-      const candidates = LOCKUP_SHAPE_VARIANTS.map((legacy) => {
-        const script = build(legacy);
-        return { script, address: script.address(hrp, serverPubkey).encode(), legacy };
-      });
-      const matchedAddress = verifyLockupAddress(
-        quote,
-        candidates.map((candidate) => candidate.address)
-      );
-      return candidates.find((candidate) => candidate.address === matchedAddress);
-    };
-    assertFundable = (input) => {
-      const fail = (reason, message) => {
-        throw gateError(reason, message);
-      };
-      if (input.quote.valid_until === void 0) {
-        fail("quote_malformed", "quote carries no valid_until");
-      }
-      assertFinite(input.quote.valid_until, "quote_malformed", "quote valid_until");
-      if (input.invoiceExpiresAt !== void 0 && input.now >= input.invoiceExpiresAt) {
-        fail("invoice_expired", "invoice expired");
-      }
-      if (input.now >= input.quote.valid_until)
-        fail("quote_expired", "quote expired \u2014 request a fresh one");
-      if (input.quote.refund_locktime !== void 0 && input.quote.refund_locktime - input.now < MIN_HEADROOM_SECONDS) {
-        fail("insufficient_headroom", "refund deadline headroom below 90 minutes");
-      }
-      if (input.maxFee) {
-        const { bps, sats, referenceRate } = input.maxFee;
-        if (bps === void 0 && sats === void 0) {
-          fail("max_fee_unbounded", "maxFee names neither bps nor sats");
-        }
-        if (bps !== void 0 && (!Number.isInteger(bps) || bps < 0 || bps > 1e4)) {
-          fail("max_fee_out_of_range", `maxFee.bps must be an integer in 0..10000, got ${bps}`);
-        }
-        if (sats !== void 0 && (!Number.isInteger(sats) || sats < 0)) {
-          fail("max_fee_out_of_range", `maxFee.sats must be a non-negative integer, got ${sats}`);
-        }
-        const legs = input.quote.pair.split("->");
-        const assetOf2 = (leg) => leg.slice(leg.indexOf(":") + 1);
-        const sameAsset2 = legs.length === 2 && assetOf2(legs[0]) === assetOf2(legs[1]);
-        if (!sameAsset2 && referenceRate === void 0) {
-          fail(
-            "fee_gate_unavailable",
-            `maxFee cannot gate ${input.quote.pair}: its legs name different assets, so from_amount - to_amount is not a fee. Supply maxFee.referenceRate (to-units per from-unit) from a source of your OWN \u2014 reading it off the solver's published feed would check the solver against its own number`
-          );
-        }
-        if (!sameAsset2 && (!Number.isFinite(referenceRate) || referenceRate <= 0)) {
-          fail(
-            "max_fee_out_of_range",
-            `maxFee.referenceRate must be a positive finite number, got ${referenceRate}`
-          );
-        }
-        const fee = sameAsset2 ? input.quote.from_amount - input.quote.to_amount : Math.ceil(
-          (input.quote.from_amount * referenceRate - input.quote.to_amount) / referenceRate
-        );
-        const allowed = Math.max(
-          sats ?? 0,
-          Math.floor(input.quote.from_amount * (bps ?? 0) / 1e4)
-        );
-        if (fee > allowed) {
-          fail("fee_too_high", `fee ${fee} exceeds the ${allowed} this client allows`);
-        }
-      }
-      if (input.onchain) {
-        const { htlcLocktime, minConfirmations, direction } = input.onchain;
-        if (!Number.isInteger(minConfirmations) || minConfirmations < 1 || minConfirmations > MAX_MIN_CONFIRMATIONS) {
-          fail(
-            "confirmations_out_of_range",
-            `min_confirmations must be 1..${MAX_MIN_CONFIRMATIONS}, got ${minConfirmations}`
-          );
-        }
-        const needed = minConfirmations * ONCHAIN_SECONDS_PER_BLOCK + ONCHAIN_CLAIM_MARGIN_SECONDS;
-        if (htlcLocktime - input.now <= needed) {
-          fail("claim_window_too_short", "L1 HTLC locktime leaves no safe claim window");
-        }
-        if (direction === "send") {
-          if (input.quote.refund_locktime === void 0 || htlcLocktime + ONCHAIN_ORDER_MARGIN_SECONDS > input.quote.refund_locktime) {
-            fail(
-              "timelock_order",
-              "L1 HTLC locktime + margin must fall before the Arkade refund locktime"
-            );
-          }
-        }
-      }
-    };
-    expectQuote = (payload, rfqId, requestedPair) => {
-      const p = payload;
-      if (p?.type === "rfq_refusal") {
-        throw new SwapRefusal(p.reason ?? "unknown", p.rfq_id ?? rfqId, {
-          errorCode: p.error_code,
-          field: p.field,
-          actual: p.actual,
-          expected: p.expected,
-          limit: p.limit,
-          unit: p.unit
-        });
-      }
-      if (p?.type !== "rfq_quote" || p.rfq_id !== rfqId) {
-        throw new Error(`unexpected reply: ${p?.type ?? "no payload"}`);
-      }
-      if (requestedPair !== void 0 && p.pair !== requestedPair) {
-        throw new Error(
-          `solver quoted ${JSON.stringify(p.pair)}, not the requested ${requestedPair}`
-        );
-      }
-      return payload;
-    };
-    pairOf = (payload) => typeof payload.pair === "string" ? payload.pair : void 0;
-    SEQUENCE_GRANULARITY_SECONDS = 512;
-    SOLO_REFUND_HEADROOM_SECONDS = 8 * SEQUENCE_GRANULARITY_SECONDS;
-    unilateralClaimDelay = (operatorExitDelaySeconds) => {
-      if (!Number.isFinite(operatorExitDelaySeconds) || operatorExitDelaySeconds < SEQUENCE_GRANULARITY_SECONDS) {
-        throw new Error(
-          `operator exit delay must be at least ${SEQUENCE_GRANULARITY_SECONDS}s of seconds, got ${operatorExitDelaySeconds}`
-        );
-      }
-      if (operatorExitDelaySeconds > 65535 * SEQUENCE_GRANULARITY_SECONDS - SOLO_REFUND_HEADROOM_SECONDS) {
-        throw new Error(
-          `operator exit delay ${operatorExitDelaySeconds}s exceeds what BIP68 can encode once the solo refund's headroom is stacked above it`
-        );
-      }
-      return Math.ceil(operatorExitDelaySeconds / SEQUENCE_GRANULARITY_SECONDS) * SEQUENCE_GRANULARITY_SECONDS;
-    };
-    unilateralRefundDelay = (claimDelay) => claimDelay;
-    unilateralRefundWithoutReceiverDelay = (claimDelay) => claimDelay + SOLO_REFUND_HEADROOM_SECONDS;
-    l1NetworkFromArk = (network) => network === "bitcoin" ? "bitcoin" : network === "regtest" ? "regtest" : "testnet";
-    onchainSendRequest = (input) => ({
-      v: 1,
-      type: "rfq_request",
-      rfq_id: input.rfqId,
-      pair: ONCHAIN_SEND_PAIR,
-      amount_side: input.amountSide,
-      amount: input.amount,
-      profile: {
-        payment_hash: input.paymentHash,
-        payout_pubkey: import_base7.hex.encode(input.payoutPubkey),
-        refund_address: input.refundAddress,
-        client_refund_pubkey: import_base7.hex.encode(input.senderPubkey)
-      }
-    });
-    lightningReceiveRequest = (input) => ({
-      v: 1,
-      type: "rfq_request",
-      rfq_id: input.rfqId,
-      pair: LIGHTNING_RECEIVE_PAIR,
-      amount_side: input.amountSide,
-      amount: input.amount,
-      profile: {
-        payment_hash: input.paymentHash,
-        payout_address: input.payoutAddress,
-        payout_pubkey: import_base7.hex.encode(input.payoutPubkey),
-        ...input.claimPacket === void 0 ? {} : { claim_packet: input.claimPacket }
-      }
-    });
-    MIN_CLAIM_WINDOW_SECONDS = 30 * 60;
-    assertReceivable = (input) => {
-      assertFinite(input.payDeadline, "quote_malformed", "payDeadline");
-      assertFinite(input.now, "invalid_gate_input", "now");
-      assertFinite(input.minClaimWindowSeconds, "invalid_gate_input", "minClaimWindowSeconds");
-      assertFinite(input.maxPayAmount, "invalid_gate_input", "maxPayAmount");
-      const minClaimWindow = input.minClaimWindowSeconds ?? MIN_CLAIM_WINDOW_SECONDS;
-      if (input.now >= input.payDeadline) {
-        throw gateError("quote_expired", "quote or invoice already expired \u2014 request a fresh one");
-      }
-      if (input.quote.refund_locktime === void 0) {
-        throw gateError("missing_refund_locktime", "receive quote carries no refund_locktime");
-      }
-      assertFinite(input.quote.refund_locktime, "quote_malformed", "quote refund_locktime");
-      if (input.quote.refund_locktime - input.payDeadline < minClaimWindow) {
-        throw gateError(
-          "claim_window_too_short",
-          `a payment at the deadline would leave under ${minClaimWindow}s to claim before the solver's refund opens`
-        );
-      }
-      if (input.maxPayAmount !== void 0 && input.quote.from_amount > input.maxPayAmount) {
-        throw gateError(
-          "price_too_high",
-          `quote asks ${input.quote.from_amount} sats, above the ${input.maxPayAmount} ceiling`
-        );
+    LockupRegistrationFailed = class extends Error {
+      /** The lockup address that was never registered — never fund it: nothing
+       * is watching it. */
+      address;
+      /** The covenant the row would have been written from — the other half of
+       * `registerLockupContract`, so the write is retryable without a quote. */
+      script;
+      constructor(script, address, cause) {
+        super(`failed to register the lockup contract for ${address}`, { cause });
+        this.name = "LockupRegistrationFailed";
+        this.address = address;
+        this.script = script;
       }
     };
   }
 });
 
-// src/nostr.ts
-var nostr_exports = {};
-__export(nostr_exports, {
-  RFQ_AD_KIND: () => RFQ_AD_KIND,
-  RFQ_DIRECTED_KIND: () => RFQ_DIRECTED_KIND,
-  RelayUnavailable: () => RelayUnavailable,
-  TransportClosed: () => TransportClosed,
-  nostrRfqTransport: () => nostrRfqTransport
-});
-var import_nostr_tools, RFQ_DIRECTED_KIND, RFQ_AD_KIND, DEFAULT_TIMEOUT_MS, RelayUnavailable, TransportClosed, closeReasons, nostrRfqTransport;
-var init_nostr = __esm({
-  "src/nostr.ts"() {
-    "use strict";
-    init_rfq();
-    import_nostr_tools = require("nostr-tools");
-    RFQ_DIRECTED_KIND = 24859;
-    RFQ_AD_KIND = 38859;
-    DEFAULT_TIMEOUT_MS = 3e4;
-    RelayUnavailable = class extends Error {
-      reasons;
-      constructor(reasons) {
-        super(`lost every relay connection: ${reasons.join("; ") || "connection closed"}`);
-        this.name = "RelayUnavailable";
-        this.reasons = reasons;
-      }
-    };
-    TransportClosed = class extends Error {
-      constructor() {
-        super("transport closed before the solver replied");
-        this.name = "TransportClosed";
-      }
-    };
-    closeReasons = (raw) => raw.map((entry) => {
-      if (typeof entry === "string") return entry;
-      const { url, reason } = entry ?? {};
-      return url ? `${url}: ${reason ?? "closed"}` : reason ?? "closed";
-    });
-    nostrRfqTransport = (options) => {
-      const relays = options.relays;
-      const solverPubkey = options.solverPubkey;
-      const secretKey = options.secretKey ?? (0, import_nostr_tools.generateSecretKey)();
-      const pubkey = (0, import_nostr_tools.getPublicKey)(secretKey);
-      const pool = options.pool ?? new import_nostr_tools.SimplePool();
-      const ownsPool = !options.pool;
-      const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-      const conversationKey = import_nostr_tools.nip44.v2.utils.getConversationKey(secretKey, solverPubkey);
-      let closed = false;
-      const waiters = /* @__PURE__ */ new Map();
-      const subscription = pool.subscribeMany(
-        relays,
-        { kinds: [RFQ_DIRECTED_KIND], "#p": [pubkey], authors: [solverPubkey] },
-        {
-          onevent(event) {
-            let payload;
-            try {
-              payload = JSON.parse(import_nostr_tools.nip44.v2.decrypt(event.content, conversationKey));
-            } catch {
-              return;
-            }
-            const rfqId = payload?.rfq_id;
-            if (!rfqId) return;
-            waiters.get(rfqId)?.resolve(payload);
-          },
-          // subscribeMany calls this once every relay has closed. Nothing will
-          // arrive after it, so failing now beats waiting out the timeout — and
-          // it names the real cause instead of implicating the solver.
-          onclose(reasons) {
-            if (closed) return;
-            const error = new RelayUnavailable(closeReasons(reasons));
-            for (const waiter of waiters.values()) waiter.reject(error);
-            waiters.clear();
-          }
-        }
-      );
-      const send = async (payload) => {
-        const event = (0, import_nostr_tools.finalizeEvent)(
-          {
-            kind: RFQ_DIRECTED_KIND,
-            created_at: Math.floor(Date.now() / 1e3),
-            tags: [["p", solverPubkey]],
-            content: import_nostr_tools.nip44.v2.encrypt(JSON.stringify(payload), conversationKey)
-          },
-          secretKey
-        );
-        const results = await Promise.allSettled(pool.publish(relays, event));
-        if (!results.some((r) => r.status === "fulfilled")) {
-          throw new Error("no relay accepted the RFQ message");
-        }
-      };
-      const awaitReply = (rfqId) => new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-          waiters.delete(rfqId);
-          reject(new Error(`no solver reply within ${timeoutMs}ms`));
-        }, timeoutMs);
-        waiters.set(rfqId, {
-          resolve: (payload) => {
-            clearTimeout(timer);
-            waiters.delete(rfqId);
-            resolve(payload);
-          },
-          reject: (error) => {
-            clearTimeout(timer);
-            waiters.delete(rfqId);
-            reject(error);
-          }
+// src/onchainHtlc.ts
+function onchainHtlcScript(params, network) {
+  if (params.claimKey.length !== 32 || params.refundKey.length !== 32) {
+    throw new Error("claimKey and refundKey must be 32-byte x-only keys");
+  }
+  if (!Number.isInteger(params.refundLocktime) || params.refundLocktime <= 0) {
+    throw new Error(
+      `refundLocktime must be a positive unix timestamp, got ${params.refundLocktime}`
+    );
+  }
+  if (params.refundLocktime < LOCKTIME_THRESHOLD) {
+    throw new Error(
+      `refundLocktime ${params.refundLocktime} is below LOCKTIME_THRESHOLD (${LOCKTIME_THRESHOLD}) and would be interpreted as a block height`
+    );
+  }
+  if (!Object.hasOwn(L1_NETWORKS, network)) {
+    throw new Error(
+      `unknown L1 network '${String(network)}' \u2014 expected one of ${Object.keys(L1_NETWORKS).join(", ")}`
+    );
+  }
+  const h160 = h160FromPaymentHash(params.paymentHash);
+  const claim = btc.Script.encode([
+    "SIZE",
+    32,
+    "EQUALVERIFY",
+    "HASH160",
+    h160,
+    "EQUALVERIFY",
+    params.claimKey,
+    "CHECKSIG"
+  ]);
+  const refund = btc.Script.encode([
+    btc.ScriptNum().encode(BigInt(params.refundLocktime)),
+    "CHECKLOCKTIMEVERIFY",
+    "DROP",
+    params.refundKey,
+    "CHECKSIG"
+  ]);
+  const payment = btc.p2tr(
+    btc.TAPROOT_UNSPENDABLE_KEY,
+    btc.taprootListToTree([{ script: claim }, { script: refund }]),
+    L1_NETWORKS[network],
+    true
+  );
+  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)) {
+        return btc.TaprootControlBlock.encode(block);
+      }
+    }
+    throw new Error("leaf missing from compiled taproot tree");
+  };
+  return {
+    address: payment.address,
+    pkScript: payment.script,
+    leaves: { claim, refund },
+    controlBlocks: { claim: controlBlockFor(claim), refund: controlBlockFor(refund) },
+    paymentHash: params.paymentHash,
+    refundLocktime: params.refundLocktime
+  };
+}
+function extractPreimage(txHex, paymentHash) {
+  let raw;
+  try {
+    raw = btc.RawTx.decode(import_base4.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_sha22.sha256)(item)) === paymentHash) return item;
+    }
+  }
+  return null;
+}
+async function claimOnchainFill(chain, input) {
+  const now = input.now ?? Math.floor(Date.now() / 1e3);
+  if (input.htlc.refundLocktime - now < ONCHAIN_CLAIM_MARGIN_SECONDS) {
+    const error = new Error(
+      "refund leaf opens too soon to claim safely \u2014 take the covenant refund instead"
+    );
+    error.reason = "claim_window_closed";
+    throw error;
+  }
+  const spend = await buildHtlcClaim(input);
+  const txid = await chain.broadcast(spend.txHex);
+  return { txid, payoutAmount: spend.payoutAmount };
+}
+async function classifyOnchainHtlc(chain, input) {
+  const utxos = await chain.getScriptUtxos(input.htlc.pkScript);
+  const best = utxos.sort((a, b) => b.amount > a.amount ? 1 : -1)[0];
+  if (!best) {
+    if (!input.funding) return { phase: "unfunded" };
+    const spend = await chain.getSpendingTx(
+      input.funding.txid,
+      input.funding.vout,
+      input.htlc.pkScript
+    );
+    if (!spend) return { phase: "unfunded" };
+    const preimage = extractPreimage(spend.txHex, input.htlc.paymentHash);
+    const txid = btc.Transaction.fromRaw(import_base4.hex.decode(spend.txHex), {
+      allowUnknownInputs: true,
+      allowUnknownOutputs: true
+    }).id;
+    return preimage ? { phase: "claimed", txid, preimage } : { phase: "swept", txid };
+  }
+  if (best.confirmations < input.minConfirmations)
+    return { phase: "awaiting_confirmations", utxo: best };
+  const mtp = await chain.getMtp();
+  if (mtp >= input.htlc.refundLocktime) return { phase: "refundable", utxo: best };
+  return { phase: "claimable", utxo: best };
+}
+var import_base4, import_sha22, import_legacy, btc, ONCHAIN_ORDER_MARGIN_SECONDS, ONCHAIN_CLAIM_MARGIN_SECONDS, MAX_MIN_CONFIRMATIONS, LOCKTIME_THRESHOLD, ONCHAIN_SECONDS_PER_BLOCK, ONCHAIN_DUST_SATS, ONCHAIN_CLAIM_VSIZE, paymentHashOf, h160FromPaymentHash, L1_NETWORKS, l1ScriptForAddress, buildLeafSpend, buildHtlcClaim;
+var init_onchainHtlc = __esm({
+  "src/onchainHtlc.ts"() {
+    "use strict";
+    import_base4 = require("@scure/base");
+    import_sha22 = require("@noble/hashes/sha2.js");
+    import_legacy = require("@noble/hashes/legacy.js");
+    btc = __toESM(require("@scure/btc-signer"), 1);
+    ONCHAIN_ORDER_MARGIN_SECONDS = 2 * 60 * 60;
+    ONCHAIN_CLAIM_MARGIN_SECONDS = 90 * 60;
+    MAX_MIN_CONFIRMATIONS = 6;
+    LOCKTIME_THRESHOLD = 5e8;
+    ONCHAIN_SECONDS_PER_BLOCK = 600;
+    ONCHAIN_DUST_SATS = BigInt(330);
+    ONCHAIN_CLAIM_VSIZE = 152;
+    paymentHashOf = (preimage) => import_base4.hex.encode((0, import_sha22.sha256)(preimage));
+    h160FromPaymentHash = (paymentHash) => (0, import_legacy.ripemd160)(import_base4.hex.decode(paymentHash));
+    L1_NETWORKS = {
+      bitcoin: btc.NETWORK,
+      testnet: btc.TEST_NETWORK,
+      regtest: { ...btc.TEST_NETWORK, bech32: "bcrt" }
+    };
+    l1ScriptForAddress = (address, network) => btc.OutScript.encode(btc.Address(L1_NETWORKS[network]).decode(address));
+    buildLeafSpend = async (input) => {
+      if (!Number.isFinite(input.feeRateSatVb) || input.feeRateSatVb <= 0) {
+        throw new Error(`feeRateSatVb must be positive, got ${input.feeRateSatVb}`);
+      }
+      const assemble = (payout2) => {
+        const tx2 = new btc.Transaction({ lockTime: input.lockTime ?? 0 });
+        tx2.addInput({
+          txid: input.utxo.txid,
+          index: input.utxo.vout,
+          witnessUtxo: { script: input.htlc.pkScript, amount: input.utxo.amount },
+          sequence: input.sequence
         });
-      });
-      return {
-        async requestQuote(payload) {
-          const rfqId = String(payload.rfq_id);
-          const reply = awaitReply(rfqId);
-          await send(payload);
-          return expectQuote(await reply, rfqId, pairOf(payload));
-        },
-        async status(rfqId) {
-          const reply = awaitReply(rfqId);
-          await send({ v: 1, type: "rfq_status_request", rfq_id: rfqId });
-          const payload = await reply;
-          if (payload?.type !== "rfq_status") return null;
-          return payload;
-        },
-        async close() {
-          closed = true;
-          for (const waiter of waiters.values()) waiter.reject(new TransportClosed());
-          waiters.clear();
-          if (ownsPool) pool.close(relays);
-          else subscription.close();
-        }
+        tx2.addOutput({ script: input.payoutPkScript, amount: payout2 });
+        return tx2;
       };
+      const witness = (sig2) => [
+        sig2,
+        ...input.stackAboveSig,
+        input.leaf,
+        input.controlBlock
+      ];
+      const sizing = assemble(input.utxo.amount);
+      sizing.updateInput(0, { finalScriptWitness: witness(new Uint8Array(64)) }, true);
+      const fee = BigInt(Math.ceil(sizing.vsize * input.feeRateSatVb));
+      const payout = input.utxo.amount - fee;
+      if (payout < ONCHAIN_DUST_SATS) {
+        throw new Error(
+          `fee ${fee} leaves ${payout} sats from a ${input.utxo.amount} sat HTLC \u2014 below the ${ONCHAIN_DUST_SATS} sat dust limit`
+        );
+      }
+      const tx = assemble(payout);
+      const sighash = tx.preimageWitnessV1(
+        0,
+        [input.htlc.pkScript],
+        btc.SigHash.DEFAULT,
+        [input.utxo.amount],
+        void 0,
+        input.leaf,
+        192
+      );
+      const sig = await input.sign(sighash);
+      if (sig.length !== 64)
+        throw new Error(`sign() must return a 64-byte BIP340 signature, got ${sig.length}`);
+      tx.updateInput(0, { finalScriptWitness: witness(sig) }, true);
+      return { txHex: tx.hex, txid: tx.id, payoutAmount: payout };
+    };
+    buildHtlcClaim = async (input) => {
+      if (paymentHashOf(input.preimage) !== input.htlc.paymentHash) {
+        throw new Error("preimage does not hash to the HTLC's payment hash");
+      }
+      return buildLeafSpend({
+        htlc: input.htlc,
+        utxo: input.utxo,
+        leaf: input.htlc.leaves.claim,
+        controlBlock: input.htlc.controlBlocks.claim,
+        stackAboveSig: [input.preimage],
+        payoutPkScript: input.payoutPkScript,
+        feeRateSatVb: input.feeRateSatVb,
+        sign: input.sign,
+        sequence: 4294967293
+      });
     };
   }
 });
 
-// src/advanced.ts
-var advanced_exports = {};
-__export(advanced_exports, {
-  ACTIVITY_TOKEN: () => ACTIVITY_TOKEN,
-  ARKADE_ASSET_NAMESPACE: () => ARKADE_ASSET_NAMESPACE,
-  AcceptConflict: () => AcceptConflict,
-  AmbiguousDestination: () => AmbiguousDestination,
-  Amount: () => Amount,
-  AmountEncodingUnsupported: () => AmountEncodingUnsupported,
-  AmountFormatError: () => AmountFormatError,
-  AmountMismatch: () => AmountMismatch,
-  AssetIdError: () => AssetIdError,
-  BITCOIN_RAILS: () => BITCOIN_RAILS,
-  BTC_ASSET_PART: () => BTC_ASSET_PART,
-  CORRIDORS: () => CORRIDORS,
-  CORRIDOR_FACTORIES: () => CORRIDOR_FACTORIES,
-  CORRIDOR_PASS: () => CORRIDOR_PASS,
-  ClientDisposed: () => ClientDisposed,
-  CovclaimdRevealError: () => CovclaimdRevealError,
-  DEFAULT_INVOICE_EXPIRY_SECONDS: () => DEFAULT_INVOICE_EXPIRY_SECONDS,
-  DiscoverySnapshotUnavailable: () => DiscoverySnapshotUnavailable,
-  FEED_TTL_MS: () => FEED_TTL_MS,
-  INDEXED_NETWORKS: () => INDEXED_NETWORKS,
-  INVOICE_HRPS: () => INVOICE_HRPS,
-  InconsistentRoute: () => InconsistentRoute,
-  InsufficientFunds: () => InsufficientFunds,
-  LIGHTNING_DRIVE: () => LIGHTNING_DRIVE,
-  LOCKUP_OWNER: () => LOCKUP_OWNER,
-  MaxFeeExceeded: () => MaxFeeExceeded,
-  MissingCorridorDep: () => MissingCorridorDep,
-  NotCancellable: () => NotCancellable,
-  OFFER_SWAP_ID_PREFIX: () => OFFER_SWAP_ID_PREFIX,
-  ONCHAIN_CLAIM_FEE_RATE_SATVB: () => ONCHAIN_CLAIM_FEE_RATE_SATVB,
-  ONCHAIN_DRIVE: () => ONCHAIN_DRIVE,
-  OperatorUnreachable: () => OperatorUnreachable,
-  QuoteExpired: () => QuoteExpired,
-  QuoteVerificationFailed: () => QuoteVerificationFailed,
-  RAILS: () => RAILS,
-  REGISTRY_URL: () => REGISTRY_URL,
-  RFQ_SWAP_ID_PREFIX: () => RFQ_SWAP_ID_PREFIX,
-  SWAP_ERROR_NAMES: () => SWAP_ERROR_NAMES,
-  SwapDriveRefusedError: () => SwapDriveRefusedError,
-  SwapRefusal: () => SwapRefusal,
-  UnsupportedRoute: () => UnsupportedRoute,
-  acceptQuote: () => acceptQuote,
-  aliasTableFrom: () => aliasTableFrom,
-  applyOfferSpend: () => applyOfferSpend,
-  arkadeAsset: () => arkadeAsset,
-  arkadeCorridor: () => arkadeCorridor,
-  artifactOf: () => artifactOf,
-  assembleRoute: () => assembleRoute,
-  assetPartOf: () => assetPartOf,
-  assetSwapIdOf: () => assetSwapIdOf,
-  attesting: () => attesting,
-  bitcoinNetworkOf: () => bitcoinNetworkOf,
-  btcOn: () => btcOn,
-  cancelSwap: () => cancelSwap,
-  canonicalAssetId: () => canonicalAssetId,
-  cardMarketOf: () => cardMarketOf,
-  chainSourceOver: () => chainSourceOver,
-  chooseMarket: () => chooseMarket,
-  conflictingFields: () => conflictingFields,
-  corridorOfRail: () => corridorOfRail,
-  corridorOutcome: () => corridorOutcome,
-  corridorRecordStore: () => corridorRecordStore,
-  corridorSet: () => corridorSet,
-  covclaimdClient: () => covclaimdClient,
-  createSwapClient: () => createSwapClient,
-  createSwapDrive: () => createSwapDrive,
-  decodeBolt11: () => decodeBolt11,
-  decodeRfqAmount: () => decodeRfqAmount,
-  discoveryIndex: () => discoveryIndex,
-  eligibleMarkets: () => eligibleMarkets,
-  encodeRfqAmount: () => encodeRfqAmount,
-  enforceFeeCeiling: () => enforceFeeCeiling,
-  esploraChainSource: () => esploraChainSource,
-  esploraTip: () => esploraTip,
-  exchange: () => exchange,
-  familyOfSwapId: () => familyOfSwapId,
-  feedFetch: () => feedFetch,
-  formatAssetId: () => formatAssetId,
-  fromAtomicDecimal: () => fromAtomicDecimal,
-  fromRfqAmountSide: () => fromRfqAmountSide,
-  fundsFromWallet: () => fundsFromWallet,
-  instrumentOf: () => instrumentOf,
-  isAddressable: () => isAddressable,
-  isAssetId: () => isAssetId,
-  isAtomicDecimal: () => isAtomicDecimal,
-  isCardMarket: () => isCardMarket,
-  isIndexedNetwork: () => isIndexedNetwork,
-  isNetworkRef: () => isNetworkRef,
-  isSwapError: () => isSwapError,
-  isUsableCard: () => isUsableCard,
-  issuanceOf: () => issuanceOf,
-  legOf: () => legOf,
-  lightningCorridor: () => lightningCorridor,
-  liveArkadeInfo: () => liveArkadeInfo,
-  marketBackendOf: () => marketBackendOf,
-  marketKeyOf: () => marketKeyOf,
-  marketRefOf: () => marketRefOf,
-  networksOfInvoiceHrp: () => networksOfInvoiceHrp,
-  nostrTransportFactory: () => nostrTransportFactory,
-  offerFactsOf: () => offerFactsOf,
-  offerOutcome: () => offerOutcome,
-  offerRecordSource: () => offerRecordSource,
-  onchainCorridor: () => onchainCorridor,
-  parseAssetId: () => parseAssetId,
-  parseRfqQuote: () => parseRfqQuote,
-  pay: () => pay,
-  publicAssetId: () => publicAssetId,
-  quoteFromFeed: () => quoteFromFeed,
-  quoteIdOfSwapId: () => quoteIdOfSwapId,
-  quoteViaRfq: () => quoteViaRfq,
-  railOf: () => railOf,
-  railOfCorridor: () => railOfCorridor,
-  readableRecord: () => readableRecord,
-  readsChain: () => readsChain,
-  receive: () => receive,
-  recordArtifact: () => recordArtifact,
-  recordEndpoint: () => recordEndpoint,
-  recordInstrument: () => recordInstrument,
-  recordLeg: () => recordLeg,
-  recordOutcome: () => recordOutcome,
-  resolveCorridorBase: () => resolveCorridorBase,
-  resolveCorridorDeps: () => resolveCorridorDeps,
-  resolveRoute: () => resolveRoute,
-  revealClaimPacket: () => revealClaimPacket,
-  revealFieldsFromScript: () => revealFieldsFromScript,
-  rfqLeg: () => rfqLeg,
-  rfqPairFor: () => rfqPairFor,
-  rfqRecordOf: () => rfqRecordOf,
-  sameAsset: () => sameAsset,
-  satsOf: () => satsOf,
-  scopedToRail: () => scopedToRail,
-  splitRecords: () => splitRecords,
-  swapOf: () => swapOf,
-  swapRecordOf: () => swapRecordOf,
-  toAtomicDecimal: () => toAtomicDecimal,
-  toDiscoveryLeg: () => toDiscoveryLeg,
-  toRfqAmountSide: () => toRfqAmountSide,
-  toSafeNumber: () => toSafeNumber,
-  usableMarkets: () => usableMarkets,
-  verifyPair: () => verifyPair,
-  verifyQuoteTtl: () => verifyQuoteTtl,
-  verifyQuotedAmount: () => verifyQuotedAmount,
-  verifyReceiveInvoiceFacts: () => verifyReceiveInvoiceFacts,
-  verifyReceiveWindow: () => verifyReceiveWindow,
-  verifyResponder: () => verifyResponder,
-  verifySendInvoice: () => verifySendInvoice,
-  verifySendWindow: () => verifySendWindow,
-  verifyingDerivation: () => verifyingDerivation,
-  walletLockupIndexer: () => walletLockupIndexer,
-  withCanonicalAmount: () => withCanonicalAmount,
-  withOfferStatus: () => withOfferStatus,
-  withRfqState: () => withRfqState
-});
-module.exports = __toCommonJS(advanced_exports);
-
-// src/client/accept.ts
-var import_base8 = require("@scure/base");
-var import_sdk9 = require("@arkade-os/sdk");
-
-// src/offer.ts
-var import_base2 = require("@scure/base");
-var import_utils = require("@scure/btc-signer/utils.js");
-var import_sdk2 = require("@arkade-os/sdk");
-
-// src/swap-want-asset.program.json
-var swap_want_asset_program_default = {
-  version: 0,
-  name: "banco-btc-to-asset",
-  params: [
-    { name: "makerWP", type: "pubkey" },
-    { name: "wantAmount", type: "int" },
-    { name: "wantAssetTxid", type: "hash" },
-    { name: "wantAssetGroupIndex", type: "int" },
-    { name: "server", type: "pubkey" },
-    { name: "user", type: "pubkey" }
-  ],
-  functions: {
-    fulfill: {
-      tapscript: { signers: ["$server"] },
-      arkadeScript: {
-        asm: [
-          0,
-          "$wantAssetTxid",
-          "$wantAssetGroupIndex",
-          "INSPECTOUTASSETLOOKUP",
-          "VERIFY",
-          "$wantAmount",
-          "GREATERTHANOREQUAL",
-          "VERIFY",
-          0,
-          "INSPECTOUTPUTSCRIPTPUBKEY",
-          1,
-          "EQUALVERIFY",
-          "$makerWP",
-          "EQUAL"
-        ]
-      }
-    },
-    cancel: {
-      tapscript: { signers: ["$user", "$server"] }
-    }
+// src/claimPacket.ts
+async function sealClaimPacket(input) {
+  return sealWithEntropy(
+    input,
+    import_secp256k1.secp256k1.utils.randomSecretKey(),
+    crypto.getRandomValues(new Uint8Array(12))
+  );
+}
+async function sealWithEntropy(input, ephemeralKey, nonce) {
+  if (input.preimage.length !== 32) throw new Error("preimage must be 32 bytes");
+  if (input.covclaimdPubkey.length !== 33) {
+    throw new Error("covclaimd pubkey must be 33-byte compressed");
   }
-};
-
-// src/swap-want-btc.program.json
-var swap_want_btc_program_default = {
-  version: 0,
-  name: "banco-asset-to-btc",
-  params: [
-    { name: "makerWP", type: "pubkey" },
-    { name: "wantAmount", type: "int" },
-    { name: "server", type: "pubkey" },
-    { name: "user", type: "pubkey" }
-  ],
-  functions: {
-    fulfill: {
-      tapscript: { signers: ["$server"] },
-      arkadeScript: {
-        asm: [
-          0,
-          "INSPECTOUTPUTVALUE",
-          "$wantAmount",
-          "GREATERTHANOREQUAL",
-          "VERIFY",
-          0,
-          "INSPECTOUTPUTSCRIPTPUBKEY",
-          1,
-          "EQUALVERIFY",
-          "$makerWP",
-          "EQUAL"
-        ]
-      }
-    },
-    cancel: {
-      tapscript: { signers: ["$user", "$server"] }
-    }
+  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_sha23.sha256, sharedX, ephemeralPub, HKDF_INFO, 32);
+  if (nonce.length !== 12) throw new Error("nonce must be 12 bytes");
+  const sealed = (0, import_aes.gcm)(key, nonce, ephemeralPub).encrypt(input.preimage);
+  const ciphertext = new Uint8Array(33 + 12 + sealed.length);
+  ciphertext.set(ephemeralPub, 0);
+  ciphertext.set(nonce, 33);
+  ciphertext.set(sealed, 45);
+  return {
+    ciphertext: import_base6.base64.encode(ciphertext),
+    packet: import_base6.base64.encode(
+      (0, import_utils2.concatBytes)(
+        tlv2(TLV_CIPHERTEXT, ciphertext),
+        tlv2(TLV_COVCLAIMD_PUBKEY, input.covclaimdPubkey)
+      )
+    )
+  };
+}
+var import_base6, import_utils2, import_aes, import_secp256k1, import_hkdf, import_sha23, HKDF_INFO, TLV_CIPHERTEXT, TLV_COVCLAIMD_PUBKEY, tlv2;
+var init_claimPacket = __esm({
+  "src/claimPacket.ts"() {
+    "use strict";
+    import_base6 = require("@scure/base");
+    import_utils2 = require("@scure/btc-signer/utils.js");
+    import_aes = require("@noble/ciphers/aes.js");
+    import_secp256k1 = require("@noble/curves/secp256k1.js");
+    import_hkdf = require("@noble/hashes/hkdf.js");
+    import_sha23 = require("@noble/hashes/sha2.js");
+    HKDF_INFO = new TextEncoder().encode("covclaimd/preimage/v1");
+    TLV_CIPHERTEXT = 1;
+    TLV_COVCLAIMD_PUBKEY = 3;
+    tlv2 = (type, value) => Uint8Array.from([type, value.length >> 8 & 255, value.length & 255, ...value]);
   }
-};
+});
 
-// src/coverage.ts
-var RETIRABLE = ["fulfilled", "cancelled"];
-var LOCKUP_RETIRABLE = ["settled", "refunded"];
-var issuedAt = /* @__PURE__ */ new Map();
-var inFlight = /* @__PURE__ */ new Map();
-async function serialize(script, task) {
-  const previous = inFlight.get(script) ?? Promise.resolve();
-  const result = previous.then(task, task);
-  const settled = result.then(
-    () => {
-    },
-    () => {
+// src/rfq.ts
+function lightningSendContract(params) {
+  const seconds = (value) => ({
+    type: "seconds",
+    value: BigInt(value)
+  });
+  return new import_sdk5.VHTLC.ScriptV2({
+    sender: params.senderPubkey,
+    receiver: params.solverPubkey,
+    server: params.operatorPubkey,
+    preimageHash: (0, import_legacy2.ripemd160)(import_base7.hex.decode(params.paymentHash)),
+    refundLocktime: BigInt(params.refundLocktime),
+    unilateralClaimDelay: seconds(params.claimDelay),
+    unilateralRefundDelay: seconds(unilateralRefundDelay(params.claimDelay)),
+    unilateralRefundWithoutReceiverDelay: seconds(
+      params.refundWithoutReceiverDelay ?? unilateralRefundWithoutReceiverDelay(params.claimDelay)
+    ),
+    nonInteractiveParameters: {
+      receiverPkScript: params.receiverPkScript,
+      senderPkScript: params.refundPkScript,
+      emulatorPubkey: params.emulatorPubkey,
+      ...params.legacy !== void 0 && { legacy: params.legacy }
     }
-  );
-  inFlight.set(script, settled);
-  void settled.then(() => {
-    if (inFlight.get(script) === settled) inFlight.delete(script);
   });
-  return result;
 }
-function addressOutstanding(swaps, script) {
-  const issued = issuedAt.get(script);
-  if (issued === void 0) return false;
-  if (swaps.some((s) => s.swapPkScript === script && s.createdAt >= issued)) {
-    issuedAt.delete(script);
-    return false;
-  }
-  return true;
-}
-async function promoteOfferContract(manager, script, issued = Date.now()) {
-  await serialize(script, async () => {
-    await manager.setContractWatchState(script, "watched");
-    issuedAt.set(script, issued);
-  });
-}
-async function retireOfferContract(manager, swaps, script) {
-  await serialize(script, async () => {
-    if (swaps.some((s) => s.swapPkScript === script && !RETIRABLE.includes(s.status))) return;
-    if (addressOutstanding(swaps, script)) return;
-    try {
-      await manager.setContractWatchState(script, "retained");
-    } catch (err) {
-      console.warn(`[swap] could not retire offer contract ${script}`, err);
-    }
-  });
-}
-async function retireSettledOfferContracts(manager, swaps) {
-  const settled = new Set(
-    swaps.filter((s) => RETIRABLE.includes(s.status)).map((s) => s.swapPkScript)
-  );
-  for (const script of settled) await retireOfferContract(manager, swaps, script);
-}
-
-// src/store.ts
-var import_base = require("@scure/base");
-var import_sha2 = require("@noble/hashes/sha2.js");
-var import_sdk = require("@arkade-os/sdk");
-var BTC_ASSET_ID = "btc";
-var byNewest = (a, b) => b.createdAt - a.createdAt;
-var getAssetSwapsOrThrow = async (repository) => {
-  return (await repository.getAllSwaps()).filter(
-    (s) => s && typeof s.id === "string" && // offer swaps carry the TLV; onchain-corridor swaps carry
-    // the payment hash instead — either marks a valid record
-    (typeof s.offerHex === "string" || typeof s.paymentHash === "string")
-  ).sort(byNewest);
-};
-var getAssetSwaps = async (repository) => {
-  try {
-    return await getAssetSwapsOrThrow(repository);
-  } catch {
-    return [];
-  }
-};
-var saveSwapOrThrow = async (repository, swap) => {
-  try {
-    await repository.saveSwap(swap);
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    throw new Error(`failed to save swap ${swap.id}: ${reason}`);
-  }
-};
-var updateAssetSwap = async (repository, id, changes) => {
-  const swaps = (await getAssetSwapsOrThrow(repository)).map(
-    (s) => s.id === id ? { ...s, ...changes } : s
-  );
-  const updated = swaps.find((s) => s.id === id);
-  if (updated) await saveSwapOrThrow(repository, updated);
-  return swaps;
-};
-var updateAssetSwapBestEffort = async (repository, id, changes) => {
-  try {
-    return { swaps: await updateAssetSwap(repository, id, changes), persisted: true };
-  } catch (error) {
-    console.warn(`[swap] failed to persist update for swap ${id}`, error);
-    const swaps = (await getAssetSwaps(repository)).map(
-      (s) => s.id === id ? { ...s, ...changes } : s
-    );
-    return { swaps, persisted: false };
-  }
-};
-var swapSecretsToRecord = (secrets) => ({
-  signingDescriptor: secrets.descriptor,
-  ..."mustPersistPreimage" in secrets && secrets.mustPersistPreimage ? { preimageHex: import_base.hex.encode(secrets.preimage) } : {},
-  ..."preimageSalt" in secrets && secrets.preimageSalt ? { preimageSaltHex: import_base.hex.encode(secrets.preimageSalt) } : {}
-});
-var decodeHex32 = (value, field) => {
-  const bytes = import_base.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;
+function deriveLightningSend(input) {
+  const { quote } = input;
+  if (quote.refund_locktime === void 0) {
+    throw new Error("lightning-send quote is missing refund_locktime");
   }
-  reason;
-  name = "PreimageNotRecoverableError";
-};
-var preimageForSwapRecord = async (wallet, record) => {
-  if (!record.signingDescriptor) {
-    throw new PreimageNotRecoverableError(
-      "no-secrets",
-      "this swap record carries no signing descriptor"
-    );
+  const refundWithoutReceiverDelay = quote.profile?.refund_without_receiver_delay;
+  if (refundWithoutReceiverDelay === void 0) {
+    throw new Error("lightning-send quote is missing profile.refund_without_receiver_delay");
   }
-  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 }
-    );
+  if (!Number.isSafeInteger(refundWithoutReceiverDelay) || refundWithoutReceiverDelay < input.claimDelay || refundWithoutReceiverDelay % SEQUENCE_GRANULARITY_SECONDS !== 0 || refundWithoutReceiverDelay > 65535 * SEQUENCE_GRANULARITY_SECONDS) {
+    throw new Error("lightning-send quote carries an invalid refund_without_receiver_delay");
   }
-  let preimage;
-  try {
-    preimage = await (0, import_sdk.contractPreimage)(wallet, record.signingDescriptor, { stored, salt });
-  } catch (cause) {
-    throw new PreimageNotRecoverableError(
-      "not-derivable",
-      `this wallet cannot produce the preimage for ${record.signingDescriptor}`,
-      { cause }
-    );
+  if (refundWithoutReceiverDelay < quote.refund_locktime - input.now) {
+    throw new Error("lightning-send quote lets the solo refund open before refund_locktime");
   }
-  if (record.paymentHash && import_base.hex.encode((0, import_sha2.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"
-    );
+  const receiverPkScriptHex = quote.profile?.receiver_pk_script;
+  if (receiverPkScriptHex === void 0) {
+    throw new Error("lightning-send quote is missing profile.receiver_pk_script");
   }
-  return preimage;
-};
-
-// src/offer.ts
-var swapPrograms = {
-  wantAsset: import_sdk2.arkade.parseArtifact(swap_want_asset_program_default),
-  wantBtc: import_sdk2.arkade.parseArtifact(swap_want_btc_program_default)
-};
-function withExitClosure(program, exit) {
-  if (!exit) return program;
-  return {
-    ...program,
-    // typed params are authoritative: an undeclared `$exitDelay` fails
-    // validateProgram instead of compiling against an unbound value
-    params: [...program.params ?? [], { name: "exitDelay", type: "int" }],
-    functions: {
-      ...program.functions,
-      exit: {
-        tapscript: { signers: ["$user"], csv: { type: exit.type, value: "$exitDelay" } }
-      }
-    }
+  const contractParams = {
+    solverPubkey: (0, import_sdk5.toXOnly)(import_base7.hex.decode(quote.solver_pubkey), "solver key"),
+    refundLocktime: quote.refund_locktime,
+    operatorPubkey: input.operatorPubkey,
+    paymentHash: input.paymentHash,
+    claimDelay: input.claimDelay,
+    refundWithoutReceiverDelay,
+    emulatorPubkey: input.emulatorPubkey,
+    senderPubkey: input.senderPubkey,
+    receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
+    refundPkScript: input.refundPkScript
   };
-}
-function swapProgramBinding(offer, operatorPubkey) {
-  if (offer.makerPkScript.length !== FIELDS.makerPkScript.width) {
-    throw new Error("makerPkScript is not a 34-byte taproot scriptPubKey");
-  }
+  const matched = matchQuotedLockup(
+    quote,
+    input.hrp,
+    input.operatorPubkey,
+    (legacy) => lightningSendContract({ ...contractParams, ...legacy !== void 0 && { legacy } })
+  );
   return {
-    program: withExitClosure(
-      offer.wantAsset ? swapPrograms.wantAsset : swapPrograms.wantBtc,
-      offer.exitDelay
-    ),
-    args: {
-      makerWP: offer.makerPkScript.subarray(2),
-      wantAmount: offer.wantAmount,
-      server: operatorPubkey,
-      user: offer.makerPublicKey,
-      // internal byte order
-      ...offer.wantAsset && {
-        wantAssetTxid: offer.wantAsset.txid.slice().reverse(),
-        wantAssetGroupIndex: offer.wantAsset.groupIndex
-      },
-      ...offer.exitDelay && { exitDelay: offer.exitDelay.value }
+    address: matched.address,
+    swapPkScript: matched.script.pkScript,
+    script: matched.script,
+    contractParams: {
+      ...contractParams,
+      ...matched.legacy !== void 0 && { legacy: matched.legacy }
     },
-    keys: {
-      serverKey: operatorPubkey,
-      userKey: offer.makerPublicKey,
-      emulatorKey: offer.emulatorPubkey
-    }
+    refundLocktime: quote.refund_locktime
   };
 }
-function offerContract(offer, operatorPubkey) {
-  const { program, args, keys } = swapProgramBinding(offer, operatorPubkey);
-  return new import_sdk2.arkade.ArkadeProgramScript(program, args, keys);
-}
-var OFFER_PACKET_TYPE = 3;
-var FIELDS = {
-  swapPkScript: { tag: 1, width: 34 },
-  wantAmount: { tag: 2, width: 8 },
-  wantAsset: { tag: 3, width: void 0 },
-  makerPkScript: { tag: 5, width: 34 },
-  makerPublicKey: { tag: 7, width: 32 },
-  emulatorPubkey: { tag: 8, width: 32 },
-  ratioNum: { tag: 9, width: 8 },
-  ratioDen: { tag: 10, width: 8 },
-  offerAsset: { tag: 11, width: void 0 },
-  exitTimelock: { tag: 12, width: 9 }
-};
-var EXIT_TYPES = ["blocks", "seconds"];
-var NAMES = Object.fromEntries(Object.entries(FIELDS).map(([k, f]) => [f.tag, k]));
-function u64(name, value) {
-  if (value < BigInt(0) || value >> BigInt(64) > BigInt(0)) {
-    throw new Error(`${name} does not fit the offer wire format (u64)`);
+function deriveOnchainSend(input) {
+  const { quote } = input;
+  const profile = quote.profile ?? {};
+  const refundLocktime = quote.refund_locktime ?? profile.refund_locktime;
+  const htlcPubkey = profile.htlc_pubkey;
+  const htlcLocktime = profile.htlc_locktime;
+  const htlcAddress = profile.htlc_address;
+  const minConfirmations = profile.min_confirmations;
+  const receiverPkScriptHex = profile.receiver_pk_script;
+  if (refundLocktime === void 0 || htlcPubkey === void 0 || htlcLocktime === void 0 || minConfirmations === void 0 || receiverPkScriptHex === void 0) {
+    throw new Error("onchain-send quote is missing a binding field");
   }
-  const out = new Uint8Array(FIELDS.wantAmount.width);
-  new DataView(out.buffer).setBigUint64(0, value, false);
-  return out;
+  const contractParams = {
+    solverPubkey: (0, import_sdk5.toXOnly)(import_base7.hex.decode(quote.solver_pubkey), "solver key"),
+    refundLocktime,
+    operatorPubkey: input.operatorPubkey,
+    paymentHash: input.paymentHash,
+    claimDelay: input.claimDelay,
+    emulatorPubkey: input.emulatorPubkey,
+    senderPubkey: input.senderPubkey,
+    receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
+    refundPkScript: import_sdk5.ArkAddress.decode(input.refundAddress).pkScript
+  };
+  const { script, address } = matchQuotedLockup(
+    quote,
+    input.hrp,
+    input.operatorPubkey,
+    (legacy) => lightningSendContract({ ...contractParams, ...legacy !== void 0 && { legacy } })
+  );
+  const htlcParams = {
+    paymentHash: input.paymentHash,
+    claimKey: input.payoutPubkey,
+    refundKey: (0, import_sdk5.toXOnly)(import_base7.hex.decode(htlcPubkey), "solver L1 htlc key"),
+    refundLocktime: htlcLocktime
+  };
+  const htlc = onchainHtlcScript(htlcParams, input.l1Network);
+  if (htlc.address !== htlcAddress) throw new AddressMismatch(htlc.address, htlcAddress);
+  return {
+    address,
+    swapPkScript: script.pkScript,
+    script,
+    htlc,
+    htlcParams,
+    l1Network: input.l1Network,
+    refundLocktime,
+    htlcLocktime,
+    minConfirmations,
+    expectedAmount: quoteExpectedSats(quote.to_amount, "to_amount")
+  };
 }
-var readU64 = (value) => new DataView(value.buffer, value.byteOffset).getBigUint64(0, false);
-var setRatio = (name, value) => {
-  if (value === void 0 || value === BigInt(0)) return void 0;
-  if (value < BigInt(0)) throw new Error(`${name} does not fit the offer wire format (u64)`);
-  return value;
-};
-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);
+function lightningReceiveContract(params) {
+  const seconds = (value) => ({
+    type: "seconds",
+    value: BigInt(value)
+  });
+  return new import_sdk5.VHTLC.ScriptV2({
+    sender: params.solverPubkey,
+    receiver: params.payoutPubkey,
+    server: params.operatorPubkey,
+    preimageHash: (0, import_legacy2.ripemd160)(import_base7.hex.decode(params.paymentHash)),
+    refundLocktime: BigInt(params.refundLocktime),
+    unilateralClaimDelay: seconds(params.claimDelay),
+    unilateralRefundDelay: seconds(unilateralRefundDelay(params.claimDelay)),
+    unilateralRefundWithoutReceiverDelay: seconds(
+      unilateralRefundWithoutReceiverDelay(params.claimDelay)
+    ),
+    nonInteractiveParameters: {
+      receiverPkScript: params.payoutPkScript,
+      senderPkScript: params.solverRefundPkScript,
+      emulatorPubkey: params.emulatorPubkey,
+      ...params.legacy !== void 0 && { legacy: params.legacy }
+    }
+  });
 }
-function encodeOffer(offer) {
-  if (Boolean(offer.wantAsset) === Boolean(offer.offerAsset)) {
-    throw new Error("offer must carry exactly one of wantAsset or offerAsset");
+function deriveLightningReceive(input) {
+  const { quote } = input;
+  const profile = quote.profile ?? {};
+  const refundLocktime = quote.refund_locktime;
+  const invoice = profile.invoice;
+  const solverRefundPkScriptHex = profile.solver_refund_pk_script;
+  if (refundLocktime === void 0 || invoice === void 0 || solverRefundPkScriptHex === void 0) {
+    throw new Error("lightning-receive quote is missing a binding field");
   }
-  for (const name of [
-    "swapPkScript",
-    "makerPkScript",
-    "makerPublicKey",
-    "emulatorPubkey"
-  ]) {
-    if (offer[name].length !== FIELDS[name].width) {
-      throw new Error(`${name} must be ${FIELDS[name].width} bytes`);
-    }
-  }
-  const ratioNum = setRatio("ratioNum", offer.ratioNum);
-  const ratioDen = setRatio("ratioDen", offer.ratioDen);
-  if (ratioNum === void 0 !== (ratioDen === void 0)) {
-    throw new Error("offer must carry both ratioNum and ratioDen, or neither");
-  }
-  const recs = [
-    tlv(FIELDS.swapPkScript.tag, offer.swapPkScript),
-    tlv(FIELDS.wantAmount.tag, u64("wantAmount", offer.wantAmount))
-  ];
-  if (offer.wantAsset) recs.push(tlv(FIELDS.wantAsset.tag, offer.wantAsset.serialize()));
-  if (ratioNum !== void 0) recs.push(tlv(FIELDS.ratioNum.tag, u64("ratioNum", ratioNum)));
-  if (ratioDen !== void 0) recs.push(tlv(FIELDS.ratioDen.tag, u64("ratioDen", ratioDen)));
-  if (offer.offerAsset) recs.push(tlv(FIELDS.offerAsset.tag, offer.offerAsset.serialize()));
-  recs.push(
-    tlv(FIELDS.makerPkScript.tag, offer.makerPkScript),
-    tlv(FIELDS.makerPublicKey.tag, offer.makerPublicKey),
-    tlv(FIELDS.emulatorPubkey.tag, offer.emulatorPubkey)
-  );
-  if (offer.exitDelay) recs.push(tlv(FIELDS.exitTimelock.tag, encodeExitDelay(offer.exitDelay)));
-  return (0, import_utils.concatBytes)(...recs);
-}
-function encodeExitDelay(exit) {
-  return (0, import_utils.concatBytes)(
-    Uint8Array.of(EXIT_TYPES.indexOf(assertExitDelay(exit).type)),
-    u64("exitDelay", exit.value)
-  );
-}
-function assertExitDelay(exit) {
-  if (EXIT_TYPES.indexOf(exit.type) < 0) {
-    throw new Error(`unknown exitDelay locktime type: ${exit.type}`);
-  }
-  if (exit.value <= BigInt(0)) {
-    throw new Error("exitDelay must be a positive relative locktime");
-  }
-  if (exit.value >> BigInt(32) > BigInt(0)) {
-    throw new Error("exitDelay does not fit the locktime field (u32)");
-  }
-  return exit;
-}
-function decodeOffer(data) {
-  const fields = {};
-  let off = 0;
-  while (off < data.length) {
-    if (off + 3 > data.length) throw new Error("truncated TLV header");
-    const type = data[off];
-    const length = data[off + 1] << 8 | data[off + 2];
-    off += 3;
-    if (off + length > data.length)
-      throw new Error(`truncated TLV value for type 0x${type.toString(16)}`);
-    const name = NAMES[type];
-    if (!name) throw new Error(`unknown TLV type: 0x${type.toString(16)}`);
-    if (fields[name] !== void 0) throw new Error(`duplicate TLV record: ${name}`);
-    fields[name] = data.slice(off, off + length);
-    off += length;
-  }
-  for (const name of ["wantAsset", "offerAsset"]) {
-    if (fields[name]?.length === 0) throw new Error(`missing/invalid ${name}`);
-  }
-  for (const [name, value] of Object.entries(fields)) {
-    const width = FIELDS[name].width;
-    if (width !== void 0 && value.length !== width) {
-      throw new Error(`missing/invalid ${name}`);
-    }
-  }
-  const need = (name) => {
-    const v = fields[name];
-    const len = FIELDS[name].width;
-    if (!v || len !== void 0 && v.length !== len)
-      throw new Error(`missing/invalid ${name}`);
-    return v;
-  };
-  const amount = need("wantAmount");
-  if (Boolean(fields.wantAsset) === Boolean(fields.offerAsset)) {
-    throw new Error("offer must carry exactly one of wantAsset or offerAsset");
-  }
-  const readRatio = (name) => {
-    const raw = fields[name];
-    if (!raw) return void 0;
-    const value = readU64(raw);
-    if (value === BigInt(0)) throw new Error(`missing/invalid ${name}`);
-    return value;
-  };
-  const ratioNum = readRatio("ratioNum");
-  const ratioDen = readRatio("ratioDen");
-  if (ratioNum === void 0 !== (ratioDen === void 0)) {
-    throw new Error("offer must carry both ratioNum and ratioDen, or neither");
-  }
-  return {
-    swapPkScript: need("swapPkScript"),
-    wantAmount: readU64(amount),
-    ...fields.wantAsset && { wantAsset: import_sdk2.asset.AssetId.fromBytes(fields.wantAsset) },
-    ...fields.offerAsset && { offerAsset: import_sdk2.asset.AssetId.fromBytes(fields.offerAsset) },
-    makerPkScript: need("makerPkScript"),
-    makerPublicKey: need("makerPublicKey"),
-    emulatorPubkey: need("emulatorPubkey"),
-    ...ratioNum !== void 0 && { ratioNum },
-    ...ratioDen !== void 0 && { ratioDen },
-    ...fields.exitTimelock && { exitDelay: decodeExitDelay(fields.exitTimelock) }
-  };
-}
-function decodeExitDelay(value) {
-  const type = EXIT_TYPES[value[0]];
-  if (!type) throw new Error(`unknown exitDelay locktime type: 0x${value[0].toString(16)}`);
-  return { type, value: readU64(value.subarray(1)) };
-}
-var OFFER_CONTRACT_LABEL = "Arkade swap offer";
-var OFFER_CONTRACT_KIND = "asset-swap-offer";
-async function registerOfferContract(wallet, info, binding, operatorPubkey, expectedPkScript) {
-  const contractManager = await wallet.getContractManager();
-  const client = await import_sdk2.arkade.Arkade.connect({
-    // Registration derives and persists; it never broadcasts and never
-    // reads UTXOs, so the only thing the client needs off the server is the
-    // info the caller already resolved. Handing that back — rather than a
-    // provider built from a URL — is what lets `createOffer` take just a
-    // wallet, and spares a second `/v1/info` round-trip.
-    arkade: { getInfo: async () => info },
-    identity: wallet.identity,
-    // without this the row's `address` would be derived against the SDK's
-    // default network while its script is right — a row that disagrees with
-    // the address the user is about to fund
-    network: (0, import_sdk2.networkFromArkadeInfo)(info),
-    contractManager
-  });
-  await contractManager.createContract(
-    offerContractParams(client, binding, operatorPubkey, expectedPkScript)
-  );
-  await promoteOfferContract(contractManager, import_base2.hex.encode(expectedPkScript));
-}
-function offerContractParams(client, binding, operatorPubkey, expectedPkScript) {
-  const { program, args, keys } = swapProgramBinding(binding, operatorPubkey);
-  const contract = new import_sdk2.arkade.ArkadeContract(client, program, args, keys);
-  if (import_base2.hex.encode(contract.pkScript) !== import_base2.hex.encode(expectedPkScript)) {
-    throw new Error("derived covenant does not match the offer's swapPkScript");
-  }
-  return {
-    ...contract.toContractParams(),
-    label: OFFER_CONTRACT_LABEL,
-    metadata: { genericallySpendable: false, kind: OFFER_CONTRACT_KIND }
+  const contractParams = {
+    solverPubkey: (0, import_sdk5.toXOnly)(import_base7.hex.decode(quote.solver_pubkey), "solver key"),
+    refundLocktime,
+    operatorPubkey: input.operatorPubkey,
+    paymentHash: input.paymentHash,
+    claimDelay: input.claimDelay,
+    emulatorPubkey: input.emulatorPubkey,
+    solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
+    payoutPubkey: input.payoutPubkey,
+    payoutPkScript: import_sdk5.ArkAddress.decode(input.payoutAddress).pkScript
   };
-}
-function serverExitDelay(delay) {
-  if (typeof delay !== "bigint" || delay <= BigInt(0)) {
-    throw new Error(
-      "the server reports no usable unilateralExitDelay; pass `exitDelay` to set the offer's exit closure explicitly, or `noExit: true` to publish without one"
-    );
-  }
-  return assertExitDelay({ value: delay, type: delay < BigInt(512) ? "blocks" : "seconds" });
-}
-async function createOffer(wallet, params) {
-  if (Boolean(params.wantAsset) === Boolean(params.offerAsset)) {
-    throw new Error("set exactly one of wantAsset (BTC->asset) or offerAsset (asset->BTC)");
-  }
-  const [info, makerAddress, makerPublicKey] = await Promise.all([
-    // requireLive: this info binds signerPubkey into the covenant — a
-    // snapshot could derive an address the operator no longer co-signs
-    // for, so an unreachable operator fails the call instead (fail closed,
-    // the same behaviour the pre-#734 caller-held provider had)
-    wallet.getArkadeInfo({ requireLive: true }),
-    wallet.getAddress(),
-    wallet.identity.xOnlyPublicKey()
-  ]);
-  const operatorPubKey = import_base2.hex.decode((0, import_sdk2.toXOnlySignerHex)(info.signerPubkey));
-  const network = (0, import_sdk2.networkFromArkadeInfo)(info);
-  const emuKey = import_base2.hex.decode(
-    (0, import_sdk2.toXOnlySignerHex)((0, import_sdk2.resolveEmulatorPubkey)(network, params.emulatorPubkey))
+  const matched = matchQuotedLockup(
+    quote,
+    input.hrp,
+    input.operatorPubkey,
+    (legacy) => lightningReceiveContract({ ...contractParams, ...legacy !== void 0 && { legacy } })
   );
-  const binding = {
-    wantAmount: params.wantAmount,
-    wantAsset: params.wantAsset,
-    offerAsset: params.offerAsset,
-    makerPkScript: import_sdk2.ArkAddress.decode(makerAddress).pkScript,
-    makerPublicKey,
-    emulatorPubkey: emuKey,
-    // checked HERE, before the covenant is derived and registered below:
-    // deferring it to `encodeOffer` leaves a registered contract behind for
-    // an offer that then fails to encode. @see assertExitDelay
-    exitDelay: params.noExit ? void 0 : params.exitDelay ? assertExitDelay(params.exitDelay) : serverExitDelay(info.unilateralExitDelay)
-  };
-  const script = offerContract(binding, operatorPubKey);
-  const offer = { ...binding, swapPkScript: script.pkScript };
-  await registerOfferContract(wallet, info, binding, operatorPubKey, script.pkScript);
-  const payload = encodeOffer(offer);
   return {
-    offerHex: import_base2.hex.encode(payload),
-    extension: { type: OFFER_PACKET_TYPE, payload },
-    // the contract's .address() builds the address; assembling an ArkAddress
-    // from tweakedPublicKey here would silently miss any future step it gains
-    address: script.address(network.hrp, operatorPubKey).encode(),
-    swapPkScript: script.pkScript
+    address: matched.address,
+    swapPkScript: matched.script.pkScript,
+    script: matched.script,
+    invoice,
+    refundLocktime,
+    contractParams: {
+      ...contractParams,
+      ...matched.legacy !== void 0 && { legacy: matched.legacy }
+    }
   };
 }
-var OFFER_COVENANT_MISMATCH = "rebuilt covenant does not match the offer's swapPkScript";
-var NoSpendableDepositError = class extends Error {
-  name = "NoSpendableDepositError";
-  constructor(options) {
-    super("no spendable VTXO at the swap address", options);
-  }
-};
-var OfferCovenantMismatchError = class extends Error {
-  constructor(swapPkScript, options) {
-    super(
-      `${OFFER_COVENANT_MISMATCH} \u2014 the operator signing key pinned by the rebuild does not reproduce the funded covenant; the signing key has likely rotated since funding (pass swapAddress, the funded address, to pin the original key), or the record is corrupt`,
-      options
-    );
-    this.swapPkScript = swapPkScript;
-  }
-  swapPkScript;
-  name = "OfferCovenantMismatchError";
-};
-async function prepareOfferCancel(wallet, offerHex, opts) {
-  const { fundingTxid, swapAddress } = opts;
-  const offer = decodeOffer(import_base2.hex.decode(offerHex));
-  const [contractManager, info, reader, broadcaster] = await Promise.all([
-    wallet.getContractManager(),
-    wallet.getArkadeInfo({ requireLive: true }),
-    wallet.getArkadeReader(),
-    wallet.getArkadeBroadcaster()
-  ]);
-  const client = await import_sdk2.arkade.Arkade.connect({
-    // info the wallet already holds, plus its broadcast pair — the shape
-    // `ArkadeServerProvider` describes, without a second `/v1/info`
-    arkade: { getInfo: async () => info, ...broadcaster },
-    indexer: reader,
-    identity: wallet.identity,
-    // registered offers resolve their VTXOs from the contract repository
-    // instead of a direct indexer query; the indexer above stays as the
-    // fallback for offers created before registration existed
-    contractManager
-    // no `network`, unlike registerOfferContract: the row lookup is by
-    // script and the payout script comes from wallet.getAddress(), so the
-    // client's network (which only shapes address derivation) is unused here
-  });
-  const operatorPubkey = swapAddress ? import_sdk2.ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
-  const { program, args, keys } = swapProgramBinding(offer, operatorPubkey);
-  let rebuilt;
-  try {
-    rebuilt = new import_sdk2.arkade.ArkadeProgramScript(program, args, keys);
-  } catch (cause) {
-    throw new OfferCovenantMismatchError(import_base2.hex.encode(offer.swapPkScript), { cause });
-  }
-  if (import_base2.hex.encode(rebuilt.pkScript) !== import_base2.hex.encode(offer.swapPkScript)) {
-    throw new OfferCovenantMismatchError(import_base2.hex.encode(offer.swapPkScript));
-  }
-  const contract = new import_sdk2.arkade.ArkadeContract(client, program, args, keys);
-  const [vtxos, makerAddress] = await Promise.all([contract.getUtxos(), wallet.getAddress()]);
-  if (!fundingTxid && vtxos.length > 1) {
-    throw new Error(
-      "multiple spendable deposits at the swap address \u2014 pass fundingTxid to select one"
-    );
+var import_base7, import_solver_discovery, import_legacy2, import_sdk5, import_sdk6, solverHex, quoteSats, quoteAmountSats, quoteExpectedSats, ARKADE_BTC, LIGHTNING_BTC, ONCHAIN_BTC, rfqPair, LIGHTNING_SEND_PAIR, LIGHTNING_RECEIVE_PAIR, ONCHAIN_SEND_PAIR, ONCHAIN_RECEIVE_PAIR, RFQ_REFUSAL_ERROR_CODES, isRfqRefusalErrorCode, REFUSAL_FIELDS, REFUSAL_UNITS, safeInteger, safeRefusalDetail, refusalMessage, SwapRefusal, AddressMismatch, newRfqId, lightningSendRequest, MIN_HEADROOM_SECONDS, gateError, assertFinite, MAX_PAIR_LENGTH, assertPairLength, verifyLockupAddress, LOCKUP_SHAPE_VARIANTS, matchQuotedLockup, assertFundable, expectQuote, pairOf, SEQUENCE_GRANULARITY_SECONDS, SOLO_REFUND_HEADROOM_SECONDS, unilateralClaimDelay, unilateralRefundDelay, unilateralRefundWithoutReceiverDelay, l1NetworkFromArk, onchainSendRequest, lightningReceiveRequest, MIN_CLAIM_WINDOW_SECONDS, assertReceivable;
+var init_rfq = __esm({
+  "src/rfq.ts"() {
+    "use strict";
+    import_base7 = require("@scure/base");
+    import_solver_discovery = require("@arkade-os/solver-discovery");
+    import_legacy2 = require("@noble/hashes/legacy.js");
+    import_sdk5 = require("@arkade-os/sdk");
+    init_onchainHtlc();
+    init_onchainHtlc();
+    import_sdk6 = require("@arkade-os/sdk");
+    init_claimPacket();
+    init_lockupContract();
+    init_offer();
+    solverHex = (value, field) => {
+      try {
+        return import_base7.hex.decode(value);
+      } catch {
+        throw new Error(`solver sent malformed hex for ${field}`);
+      }
+    };
+    quoteSats = (value, field) => {
+      if (typeof value !== "number" || !Number.isSafeInteger(value)) {
+        throw new Error(`HTLC quote carries a non-sats ${field}: ${String(value)}`);
+      }
+      return value;
+    };
+    quoteAmountSats = (value, field) => {
+      if (typeof value === "string" && (0, import_solver_discovery.isAmount)(value)) return BigInt(value);
+      if (typeof value === "number" && Number.isSafeInteger(value)) return BigInt(value);
+      throw new Error(`HTLC quote carries an unreadable ${field}: ${String(value)}`);
+    };
+    quoteExpectedSats = (value, field) => {
+      const sats = quoteAmountSats(value, field);
+      if (sats <= 0n || sats > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new Error(`HTLC quote carries an unusable ${field}: ${String(value)}`);
+      }
+      return Number(sats);
+    };
+    ARKADE_BTC = "arkade:BTC";
+    LIGHTNING_BTC = "lightning:BTC";
+    ONCHAIN_BTC = "onchain:BTC";
+    rfqPair = (from, to) => `${from}->${to}`;
+    LIGHTNING_SEND_PAIR = rfqPair(ARKADE_BTC, LIGHTNING_BTC);
+    LIGHTNING_RECEIVE_PAIR = rfqPair(LIGHTNING_BTC, ARKADE_BTC);
+    ONCHAIN_SEND_PAIR = rfqPair(ARKADE_BTC, ONCHAIN_BTC);
+    ONCHAIN_RECEIVE_PAIR = rfqPair(ONCHAIN_BTC, ARKADE_BTC);
+    RFQ_REFUSAL_ERROR_CODES = [
+      "amount_side_unsupported",
+      "exact_out_unsupported",
+      "invalid_amount",
+      "invalid_payout_address",
+      "invalid_refund_address",
+      "invoice_amount_mismatch",
+      "invoice_cltv_too_large",
+      "invoice_malformed",
+      "invoice_missing_amount",
+      "invoice_missing_network",
+      "invoice_missing_payment_hash",
+      "invoice_missing_timestamp",
+      "invoice_mixed_case",
+      "invoice_sub_satoshi_amount",
+      "invoice_too_long",
+      "invoice_wrong_network"
+    ];
+    isRfqRefusalErrorCode = (value) => typeof value === "string" && RFQ_REFUSAL_ERROR_CODES.includes(value);
+    REFUSAL_FIELDS = /* @__PURE__ */ new Set([
+      "amount",
+      "amount_side",
+      "profile.invoice",
+      "profile.payout_address",
+      "profile.refund_address"
+    ]);
+    REFUSAL_UNITS = /* @__PURE__ */ new Set(["blocks", "characters", "sats"]);
+    safeInteger = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+    safeRefusalDetail = (detail) => {
+      if (!isRfqRefusalErrorCode(detail.errorCode)) return {};
+      return {
+        errorCode: detail.errorCode,
+        field: typeof detail.field === "string" && REFUSAL_FIELDS.has(detail.field) ? detail.field : void 0,
+        actual: safeInteger(detail.actual),
+        expected: safeInteger(detail.expected),
+        limit: safeInteger(detail.limit),
+        unit: typeof detail.unit === "string" && REFUSAL_UNITS.has(detail.unit) ? detail.unit : void 0
+      };
+    };
+    refusalMessage = (reason, detail) => {
+      if (!detail.errorCode) return `solver refused: ${reason}`;
+      const where = detail.field ? ` at ${detail.field}` : "";
+      const unit = detail.unit ? ` ${detail.unit}` : "";
+      if (detail.actual !== void 0 && detail.limit !== void 0) {
+        return `solver refused: ${reason} (${detail.errorCode}${where}: ${detail.actual}${unit}, limit ${detail.limit})`;
+      }
+      if (detail.actual !== void 0 && detail.expected !== void 0) {
+        return `solver refused: ${reason} (${detail.errorCode}${where}: ${detail.actual}${unit}, expected ${detail.expected})`;
+      }
+      return `solver refused: ${reason} (${detail.errorCode}${where})`;
+    };
+    SwapRefusal = class extends Error {
+      /** Literal-typed so the v2 error taxonomy's union discriminates on `name`
+       * — a `string` here collapses the discriminant for every member. Same value
+       * the constructor has always set, moved to a field initializer. */
+      name = "SwapRefusal";
+      reason;
+      rfqId;
+      errorCode;
+      field;
+      actual;
+      expected;
+      limit;
+      unit;
+      constructor(reason, rfqId, detail = {}) {
+        const safeDetail = safeRefusalDetail(detail);
+        super(refusalMessage(reason, safeDetail));
+        this.reason = reason;
+        this.rfqId = rfqId;
+        this.errorCode = safeDetail.errorCode;
+        this.field = safeDetail.field;
+        this.actual = safeDetail.actual;
+        this.expected = safeDetail.expected;
+        this.limit = safeDetail.limit;
+        this.unit = safeDetail.unit;
+      }
+    };
+    AddressMismatch = class extends Error {
+      derived;
+      quoted;
+      constructor(derived, quoted) {
+        super("solver lockup address does not match local derivation \u2014 refusing to fund");
+        this.name = "AddressMismatch";
+        this.derived = derived;
+        this.quoted = quoted;
+      }
+    };
+    newRfqId = () => import_base7.hex.encode(crypto.getRandomValues(new Uint8Array(32)));
+    lightningSendRequest = (input) => ({
+      v: 1,
+      type: "rfq_request",
+      rfq_id: input.rfqId,
+      pair: LIGHTNING_SEND_PAIR,
+      amount_side: "to",
+      profile: {
+        invoice: input.invoice,
+        refund_address: input.refundAddress,
+        client_refund_pubkey: import_base7.hex.encode(input.senderPubkey)
+      }
+    });
+    MIN_HEADROOM_SECONDS = 90 * 60;
+    gateError = (reason, message) => {
+      const error = new Error(message);
+      error.reason = reason;
+      return error;
+    };
+    assertFinite = (value, reason, label) => {
+      if (value !== void 0 && !Number.isFinite(value)) {
+        throw gateError(reason, `${label} is not a finite number (${String(value)})`);
+      }
+    };
+    MAX_PAIR_LENGTH = 158;
+    assertPairLength = (pair) => {
+      if (pair.length > MAX_PAIR_LENGTH) {
+        throw new Error(
+          `pair is ${pair.length} characters, over the wire's ${MAX_PAIR_LENGTH}-character limit`
+        );
+      }
+    };
+    verifyLockupAddress = (quote, derivedAddress) => {
+      const quoted = quote.profile?.lockup_address;
+      const candidates = Array.isArray(derivedAddress) ? derivedAddress : [derivedAddress];
+      const matched = candidates.find((address) => address === quoted);
+      if (matched === void 0) throw new AddressMismatch(candidates, quoted);
+      return matched;
+    };
+    LOCKUP_SHAPE_VARIANTS = [void 0, "preTimelockedRefund"];
+    matchQuotedLockup = (quote, hrp, serverPubkey, build) => {
+      const candidates = LOCKUP_SHAPE_VARIANTS.map((legacy) => {
+        const script = build(legacy);
+        return { script, address: script.address(hrp, serverPubkey).encode(), legacy };
+      });
+      const matchedAddress = verifyLockupAddress(
+        quote,
+        candidates.map((candidate) => candidate.address)
+      );
+      return candidates.find((candidate) => candidate.address === matchedAddress);
+    };
+    assertFundable = (input) => {
+      const fail = (reason, message) => {
+        throw gateError(reason, message);
+      };
+      if (input.quote.valid_until === void 0) {
+        fail("quote_malformed", "quote carries no valid_until");
+      }
+      assertFinite(input.quote.valid_until, "quote_malformed", "quote valid_until");
+      if (input.invoiceExpiresAt !== void 0 && input.now >= input.invoiceExpiresAt) {
+        fail("invoice_expired", "invoice expired");
+      }
+      if (input.now >= input.quote.valid_until)
+        fail("quote_expired", "quote expired \u2014 request a fresh one");
+      if (quoteAmountSats(input.quote.from_amount, "from_amount") <= 0n || quoteAmountSats(input.quote.to_amount, "to_amount") <= 0n) {
+        fail("non_positive_amount", "quote carries a non-positive amount");
+      }
+      if (input.quote.refund_locktime !== void 0 && input.quote.refund_locktime - input.now < MIN_HEADROOM_SECONDS) {
+        fail("insufficient_headroom", "refund deadline headroom below 90 minutes");
+      }
+      if (input.maxFee) {
+        const { bps, sats, referenceRate } = input.maxFee;
+        if (bps === void 0 && sats === void 0) {
+          fail("max_fee_unbounded", "maxFee names neither bps nor sats");
+        }
+        if (bps !== void 0 && (!Number.isInteger(bps) || bps < 0 || bps > 1e4)) {
+          fail("max_fee_out_of_range", `maxFee.bps must be an integer in 0..10000, got ${bps}`);
+        }
+        if (sats !== void 0 && (!Number.isInteger(sats) || sats < 0)) {
+          fail("max_fee_out_of_range", `maxFee.sats must be a non-negative integer, got ${sats}`);
+        }
+        const legs = input.quote.pair.split("->");
+        const assetOf2 = (leg) => leg.slice(leg.indexOf(":") + 1);
+        const sameAsset2 = legs.length === 2 && assetOf2(legs[0]) === assetOf2(legs[1]);
+        if (!sameAsset2 && referenceRate === void 0) {
+          fail(
+            "fee_gate_unavailable",
+            `maxFee cannot gate ${input.quote.pair}: its legs name different assets, so from_amount - to_amount is not a fee. Supply maxFee.referenceRate (to-units per from-unit) from a source of your OWN \u2014 reading it off the solver's published feed would check the solver against its own number`
+          );
+        }
+        if (!sameAsset2 && (!Number.isFinite(referenceRate) || referenceRate <= 0)) {
+          fail(
+            "max_fee_out_of_range",
+            `maxFee.referenceRate must be a positive finite number, got ${referenceRate}`
+          );
+        }
+        const fromSats = quoteSats(input.quote.from_amount, "from_amount");
+        const toSats = quoteSats(input.quote.to_amount, "to_amount");
+        const fee = sameAsset2 ? fromSats - toSats : Math.ceil(
+          (fromSats * referenceRate - toSats) / referenceRate
+        );
+        const allowed = Math.max(sats ?? 0, Math.floor(fromSats * (bps ?? 0) / 1e4));
+        if (fee > allowed) {
+          fail("fee_too_high", `fee ${fee} exceeds the ${allowed} this client allows`);
+        }
+      }
+      if (input.onchain) {
+        const { htlcLocktime, minConfirmations, direction } = input.onchain;
+        if (!Number.isInteger(minConfirmations) || minConfirmations < 1 || minConfirmations > MAX_MIN_CONFIRMATIONS) {
+          fail(
+            "confirmations_out_of_range",
+            `min_confirmations must be 1..${MAX_MIN_CONFIRMATIONS}, got ${minConfirmations}`
+          );
+        }
+        const needed = minConfirmations * ONCHAIN_SECONDS_PER_BLOCK + ONCHAIN_CLAIM_MARGIN_SECONDS;
+        if (htlcLocktime - input.now <= needed) {
+          fail("claim_window_too_short", "L1 HTLC locktime leaves no safe claim window");
+        }
+        if (direction === "send") {
+          if (input.quote.refund_locktime === void 0 || htlcLocktime + ONCHAIN_ORDER_MARGIN_SECONDS > input.quote.refund_locktime) {
+            fail(
+              "timelock_order",
+              "L1 HTLC locktime + margin must fall before the Arkade refund locktime"
+            );
+          }
+        }
+      }
+    };
+    expectQuote = (payload, rfqId, requestedPair) => {
+      const p = payload;
+      if (p?.type === "rfq_refusal") {
+        throw new SwapRefusal(p.reason ?? "unknown", p.rfq_id ?? rfqId, {
+          errorCode: p.error_code,
+          field: p.field,
+          actual: p.actual,
+          expected: p.expected,
+          limit: p.limit,
+          unit: p.unit
+        });
+      }
+      if (p?.type !== "rfq_quote" || p.rfq_id !== rfqId) {
+        throw new Error(`unexpected reply: ${p?.type ?? "no payload"}`);
+      }
+      if (requestedPair !== void 0 && p.pair !== requestedPair) {
+        throw new Error(
+          `solver quoted ${JSON.stringify(p.pair)}, not the requested ${requestedPair}`
+        );
+      }
+      return payload;
+    };
+    pairOf = (payload) => typeof payload.pair === "string" ? payload.pair : void 0;
+    SEQUENCE_GRANULARITY_SECONDS = 512;
+    SOLO_REFUND_HEADROOM_SECONDS = 8 * SEQUENCE_GRANULARITY_SECONDS;
+    unilateralClaimDelay = (operatorExitDelaySeconds) => {
+      if (!Number.isFinite(operatorExitDelaySeconds) || operatorExitDelaySeconds < SEQUENCE_GRANULARITY_SECONDS) {
+        throw new Error(
+          `operator exit delay must be at least ${SEQUENCE_GRANULARITY_SECONDS}s of seconds, got ${operatorExitDelaySeconds}`
+        );
+      }
+      if (operatorExitDelaySeconds > 65535 * SEQUENCE_GRANULARITY_SECONDS - SOLO_REFUND_HEADROOM_SECONDS) {
+        throw new Error(
+          `operator exit delay ${operatorExitDelaySeconds}s exceeds what BIP68 can encode once the solo refund's headroom is stacked above it`
+        );
+      }
+      return Math.ceil(operatorExitDelaySeconds / SEQUENCE_GRANULARITY_SECONDS) * SEQUENCE_GRANULARITY_SECONDS;
+    };
+    unilateralRefundDelay = (claimDelay) => claimDelay;
+    unilateralRefundWithoutReceiverDelay = (claimDelay) => claimDelay + SOLO_REFUND_HEADROOM_SECONDS;
+    l1NetworkFromArk = (network) => network === "bitcoin" ? "bitcoin" : network === "regtest" ? "regtest" : "testnet";
+    onchainSendRequest = (input) => ({
+      v: 1,
+      type: "rfq_request",
+      rfq_id: input.rfqId,
+      pair: ONCHAIN_SEND_PAIR,
+      amount_side: input.amountSide,
+      amount: input.amount,
+      profile: {
+        payment_hash: input.paymentHash,
+        payout_pubkey: import_base7.hex.encode(input.payoutPubkey),
+        refund_address: input.refundAddress,
+        client_refund_pubkey: import_base7.hex.encode(input.senderPubkey)
+      }
+    });
+    lightningReceiveRequest = (input) => ({
+      v: 1,
+      type: "rfq_request",
+      rfq_id: input.rfqId,
+      pair: LIGHTNING_RECEIVE_PAIR,
+      amount_side: input.amountSide,
+      amount: input.amount,
+      profile: {
+        payment_hash: input.paymentHash,
+        payout_address: input.payoutAddress,
+        payout_pubkey: import_base7.hex.encode(input.payoutPubkey),
+        ...input.claimPacket === void 0 ? {} : { claim_packet: input.claimPacket }
+      }
+    });
+    MIN_CLAIM_WINDOW_SECONDS = 30 * 60;
+    assertReceivable = (input) => {
+      assertFinite(input.payDeadline, "quote_malformed", "payDeadline");
+      assertFinite(input.now, "invalid_gate_input", "now");
+      assertFinite(input.minClaimWindowSeconds, "invalid_gate_input", "minClaimWindowSeconds");
+      assertFinite(input.maxPayAmount, "invalid_gate_input", "maxPayAmount");
+      const minClaimWindow = input.minClaimWindowSeconds ?? MIN_CLAIM_WINDOW_SECONDS;
+      if (input.now >= input.payDeadline) {
+        throw gateError("quote_expired", "quote or invoice already expired \u2014 request a fresh one");
+      }
+      if (input.quote.refund_locktime === void 0) {
+        throw gateError("missing_refund_locktime", "receive quote carries no refund_locktime");
+      }
+      assertFinite(input.quote.refund_locktime, "quote_malformed", "quote refund_locktime");
+      if (input.quote.refund_locktime - input.payDeadline < minClaimWindow) {
+        throw gateError(
+          "claim_window_too_short",
+          `a payment at the deadline would leave under ${minClaimWindow}s to claim before the solver's refund opens`
+        );
+      }
+      if (input.maxPayAmount !== void 0 && quoteSats(input.quote.from_amount, "from_amount") > input.maxPayAmount) {
+        throw gateError(
+          "price_too_high",
+          `quote asks ${input.quote.from_amount} sats, above the ${input.maxPayAmount} ceiling`
+        );
+      }
+    };
   }
-  const vtxo = fundingTxid ? vtxos.find((v) => v.txid === fundingTxid) : vtxos[0];
-  if (!vtxo) throw new NoSpendableDepositError();
-  const makerPkScript = import_sdk2.ArkAddress.decode(makerAddress).pkScript;
-  const cancel = contract.functions.cancel().from({ txid: vtxo.txid, vout: vtxo.vout, value: vtxo.value }).to(makerPkScript, BigInt(vtxo.value));
-  for (const a of vtxo.assets ?? []) {
-    cancel.withAsset({
-      assetId: a.assetId,
-      inputs: [{ vin: 0, amount: BigInt(a.amount) }],
-      outputs: [{ vout: 0, amount: BigInt(a.amount) }]
+});
+
+// src/nostr.ts
+var nostr_exports = {};
+__export(nostr_exports, {
+  RFQ_AD_KIND: () => RFQ_AD_KIND,
+  RFQ_DIRECTED_KIND: () => RFQ_DIRECTED_KIND,
+  RelayUnavailable: () => RelayUnavailable,
+  TransportClosed: () => TransportClosed,
+  nostrRfqTransport: () => nostrRfqTransport
+});
+var import_nostr_tools, RFQ_DIRECTED_KIND, RFQ_AD_KIND, DEFAULT_TIMEOUT_MS, RelayUnavailable, TransportClosed, closeReasons, nostrRfqTransport;
+var init_nostr = __esm({
+  "src/nostr.ts"() {
+    "use strict";
+    init_rfq();
+    import_nostr_tools = require("nostr-tools");
+    RFQ_DIRECTED_KIND = 24859;
+    RFQ_AD_KIND = 38859;
+    DEFAULT_TIMEOUT_MS = 3e4;
+    RelayUnavailable = class extends Error {
+      reasons;
+      constructor(reasons) {
+        super(`lost every relay connection: ${reasons.join("; ") || "connection closed"}`);
+        this.name = "RelayUnavailable";
+        this.reasons = reasons;
+      }
+    };
+    TransportClosed = class extends Error {
+      constructor() {
+        super("transport closed before the solver replied");
+        this.name = "TransportClosed";
+      }
+    };
+    closeReasons = (raw) => raw.map((entry) => {
+      if (typeof entry === "string") return entry;
+      const { url, reason } = entry ?? {};
+      return url ? `${url}: ${reason ?? "closed"}` : reason ?? "closed";
     });
+    nostrRfqTransport = (options) => {
+      const relays = options.relays;
+      const solverPubkey = options.solverPubkey;
+      const secretKey = options.secretKey ?? (0, import_nostr_tools.generateSecretKey)();
+      const pubkey = (0, import_nostr_tools.getPublicKey)(secretKey);
+      const pool = options.pool ?? new import_nostr_tools.SimplePool();
+      const ownsPool = !options.pool;
+      const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+      const conversationKey = import_nostr_tools.nip44.v2.utils.getConversationKey(secretKey, solverPubkey);
+      let closed = false;
+      const waiters = /* @__PURE__ */ new Map();
+      const subscription = pool.subscribeMany(
+        relays,
+        { kinds: [RFQ_DIRECTED_KIND], "#p": [pubkey], authors: [solverPubkey] },
+        {
+          onevent(event) {
+            let payload;
+            try {
+              payload = JSON.parse(import_nostr_tools.nip44.v2.decrypt(event.content, conversationKey));
+            } catch {
+              return;
+            }
+            const rfqId = payload?.rfq_id;
+            if (!rfqId) return;
+            waiters.get(rfqId)?.resolve(payload);
+          },
+          // subscribeMany calls this once every relay has closed. Nothing will
+          // arrive after it, so failing now beats waiting out the timeout — and
+          // it names the real cause instead of implicating the solver.
+          onclose(reasons) {
+            if (closed) return;
+            const error = new RelayUnavailable(closeReasons(reasons));
+            for (const waiter of waiters.values()) waiter.reject(error);
+            waiters.clear();
+          }
+        }
+      );
+      const send = async (payload) => {
+        const event = (0, import_nostr_tools.finalizeEvent)(
+          {
+            kind: RFQ_DIRECTED_KIND,
+            created_at: Math.floor(Date.now() / 1e3),
+            tags: [["p", solverPubkey]],
+            content: import_nostr_tools.nip44.v2.encrypt(JSON.stringify(payload), conversationKey)
+          },
+          secretKey
+        );
+        const results = await Promise.allSettled(pool.publish(relays, event));
+        if (!results.some((r) => r.status === "fulfilled")) {
+          throw new Error("no relay accepted the RFQ message");
+        }
+      };
+      const awaitReply = (rfqId) => new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          waiters.delete(rfqId);
+          reject(new Error(`no solver reply within ${timeoutMs}ms`));
+        }, timeoutMs);
+        waiters.set(rfqId, {
+          resolve: (payload) => {
+            clearTimeout(timer);
+            waiters.delete(rfqId);
+            resolve(payload);
+          },
+          reject: (error) => {
+            clearTimeout(timer);
+            waiters.delete(rfqId);
+            reject(error);
+          }
+        });
+      });
+      return {
+        async requestQuote(payload) {
+          const rfqId = String(payload.rfq_id);
+          const reply = awaitReply(rfqId);
+          await send(payload);
+          return expectQuote(await reply, rfqId, pairOf(payload));
+        },
+        async status(rfqId) {
+          const reply = awaitReply(rfqId);
+          await send({ v: 1, type: "rfq_status_request", rfq_id: rfqId });
+          const payload = await reply;
+          if (payload?.type !== "rfq_status") return null;
+          return payload;
+        },
+        async close() {
+          closed = true;
+          for (const waiter of waiters.values()) waiter.reject(new TransportClosed());
+          waiters.clear();
+          if (ownsPool) pool.close(relays);
+          else subscription.close();
+        }
+      };
+    };
   }
-  return {
-    offer,
-    vtxo: { txid: vtxo.txid, vout: vtxo.vout, value: vtxo.value },
-    send: async () => (await cancel.send()).txid
-  };
-}
-var ASSET_CARRIER_SATS = BigInt(import_sdk2.ASSET_CARRIER_SATS);
+});
+
+// src/advanced.ts
+var advanced_exports = {};
+__export(advanced_exports, {
+  ACTIVITY_TOKEN: () => ACTIVITY_TOKEN,
+  ARKADE_ASSET_NAMESPACE: () => ARKADE_ASSET_NAMESPACE,
+  AcceptConflict: () => AcceptConflict,
+  AmbiguousDestination: () => AmbiguousDestination,
+  Amount: () => Amount,
+  AmountEncodingUnsupported: () => AmountEncodingUnsupported,
+  AmountFormatError: () => AmountFormatError,
+  AmountMismatch: () => AmountMismatch,
+  AssetIdError: () => AssetIdError,
+  BITCOIN_RAILS: () => BITCOIN_RAILS,
+  BTC_ASSET_PART: () => BTC_ASSET_PART,
+  CORRIDORS: () => CORRIDORS,
+  CORRIDOR_FACTORIES: () => CORRIDOR_FACTORIES,
+  CORRIDOR_PASS: () => CORRIDOR_PASS,
+  ClientDisposed: () => ClientDisposed,
+  CovclaimdRevealError: () => CovclaimdRevealError,
+  DEFAULT_INVOICE_EXPIRY_SECONDS: () => DEFAULT_INVOICE_EXPIRY_SECONDS,
+  DiscoverySnapshotUnavailable: () => DiscoverySnapshotUnavailable,
+  FEED_TTL_MS: () => FEED_TTL_MS,
+  INDEXED_NETWORKS: () => INDEXED_NETWORKS,
+  INVOICE_HRPS: () => INVOICE_HRPS,
+  InconsistentRoute: () => InconsistentRoute,
+  InsufficientFunds: () => InsufficientFunds,
+  LIGHTNING_DRIVE: () => LIGHTNING_DRIVE,
+  LOCKUP_OWNER: () => LOCKUP_OWNER,
+  MaxFeeExceeded: () => MaxFeeExceeded,
+  MissingCorridorDep: () => MissingCorridorDep,
+  NotCancellable: () => NotCancellable,
+  OFFER_SWAP_ID_PREFIX: () => OFFER_SWAP_ID_PREFIX,
+  ONCHAIN_CLAIM_FEE_RATE_SATVB: () => ONCHAIN_CLAIM_FEE_RATE_SATVB,
+  ONCHAIN_DRIVE: () => ONCHAIN_DRIVE,
+  OperatorUnreachable: () => OperatorUnreachable,
+  QuoteExpired: () => QuoteExpired,
+  QuoteVerificationFailed: () => QuoteVerificationFailed,
+  RAILS: () => RAILS,
+  REGISTRY_URL: () => REGISTRY_URL,
+  RFQ_SWAP_ID_PREFIX: () => RFQ_SWAP_ID_PREFIX,
+  SWAP_ERROR_NAMES: () => SWAP_ERROR_NAMES,
+  SwapDriveRefusedError: () => SwapDriveRefusedError,
+  SwapRefusal: () => SwapRefusal,
+  UnsupportedRoute: () => UnsupportedRoute,
+  acceptQuote: () => acceptQuote,
+  aliasTableFrom: () => aliasTableFrom,
+  applyOfferSpend: () => applyOfferSpend,
+  arkadeAsset: () => arkadeAsset,
+  arkadeCorridor: () => arkadeCorridor,
+  artifactOf: () => artifactOf,
+  assembleRoute: () => assembleRoute,
+  assetPartOf: () => assetPartOf,
+  assetSwapIdOf: () => assetSwapIdOf,
+  attesting: () => attesting,
+  bitcoinNetworkOf: () => bitcoinNetworkOf,
+  btcOn: () => btcOn,
+  cancelSwap: () => cancelSwap,
+  canonicalAssetId: () => canonicalAssetId,
+  cardMarketOf: () => cardMarketOf,
+  chainSourceOver: () => chainSourceOver,
+  chooseMarket: () => chooseMarket,
+  conflictingFields: () => conflictingFields,
+  corridorOfRail: () => corridorOfRail,
+  corridorOutcome: () => corridorOutcome,
+  corridorRecordStore: () => corridorRecordStore,
+  corridorSet: () => corridorSet,
+  covclaimdClient: () => covclaimdClient,
+  createSwapClient: () => createSwapClient,
+  createSwapDrive: () => createSwapDrive,
+  decodeBolt11: () => decodeBolt11,
+  decodeRfqAmount: () => decodeRfqAmount,
+  discoveryIndex: () => discoveryIndex,
+  eligibleMarkets: () => eligibleMarkets,
+  encodeRfqAmount: () => encodeRfqAmount,
+  enforceFeeCeiling: () => enforceFeeCeiling,
+  esploraChainSource: () => esploraChainSource,
+  esploraTip: () => esploraTip,
+  exchange: () => exchange,
+  familyOfSwapId: () => familyOfSwapId,
+  fateMoved: () => fateMoved,
+  feedFetch: () => feedFetch,
+  formatAssetId: () => formatAssetId,
+  fromAtomicDecimal: () => fromAtomicDecimal,
+  fromRfqAmountSide: () => fromRfqAmountSide,
+  fundsFromWallet: () => fundsFromWallet,
+  instrumentOf: () => instrumentOf,
+  isAddressable: () => isAddressable,
+  isAssetId: () => isAssetId,
+  isAtomicDecimal: () => isAtomicDecimal,
+  isCardMarket: () => isCardMarket,
+  isIndexedNetwork: () => isIndexedNetwork,
+  isNetworkRef: () => isNetworkRef,
+  isSwapError: () => isSwapError,
+  isUsableCard: () => isUsableCard,
+  issuanceOf: () => issuanceOf,
+  legOf: () => legOf,
+  lightningCorridor: () => lightningCorridor,
+  liveArkadeInfo: () => liveArkadeInfo,
+  marketBackendOf: () => marketBackendOf,
+  marketKeyOf: () => marketKeyOf,
+  marketRefOf: () => marketRefOf,
+  networksOfInvoiceHrp: () => networksOfInvoiceHrp,
+  nostrTransportFactory: () => nostrTransportFactory,
+  offerFactsOf: () => offerFactsOf,
+  offerOutcome: () => offerOutcome,
+  offerRecordSource: () => offerRecordSource,
+  onchainCorridor: () => onchainCorridor,
+  parseAssetId: () => parseAssetId,
+  parseRfqQuote: () => parseRfqQuote,
+  pay: () => pay,
+  publicAssetId: () => publicAssetId,
+  quoteFromFeed: () => quoteFromFeed,
+  quoteIdOfSwapId: () => quoteIdOfSwapId,
+  quoteViaRfq: () => quoteViaRfq,
+  railOf: () => railOf,
+  railOfCorridor: () => railOfCorridor,
+  readableRecord: () => readableRecord,
+  readsChain: () => readsChain,
+  receive: () => receive,
+  recordArtifact: () => recordArtifact,
+  recordEndpoint: () => recordEndpoint,
+  recordInstrument: () => recordInstrument,
+  recordLeg: () => recordLeg,
+  recordOutcome: () => recordOutcome,
+  resolveCorridorBase: () => resolveCorridorBase,
+  resolveCorridorDeps: () => resolveCorridorDeps,
+  resolveRoute: () => resolveRoute,
+  restoredOfferRecord: () => restoredOfferRecord,
+  revealClaimPacket: () => revealClaimPacket,
+  revealFieldsFromScript: () => revealFieldsFromScript,
+  rfqLeg: () => rfqLeg,
+  rfqPairFor: () => rfqPairFor,
+  rfqRecordOf: () => rfqRecordOf,
+  sameAsset: () => sameAsset,
+  satsOf: () => satsOf,
+  scopedToRail: () => scopedToRail,
+  splitRecords: () => splitRecords,
+  swapOf: () => swapOf,
+  swapRecordOf: () => swapRecordOf,
+  toAtomicDecimal: () => toAtomicDecimal,
+  toDiscoveryLeg: () => toDiscoveryLeg,
+  toRfqAmountSide: () => toRfqAmountSide,
+  toSafeNumber: () => toSafeNumber,
+  usableMarkets: () => usableMarkets,
+  verifyPair: () => verifyPair,
+  verifyQuoteTtl: () => verifyQuoteTtl,
+  verifyQuotedAmount: () => verifyQuotedAmount,
+  verifyReceiveInvoiceFacts: () => verifyReceiveInvoiceFacts,
+  verifyReceiveWindow: () => verifyReceiveWindow,
+  verifyResponder: () => verifyResponder,
+  verifySendInvoice: () => verifySendInvoice,
+  verifySendWindow: () => verifySendWindow,
+  verifyingDerivation: () => verifyingDerivation,
+  walletLockupIndexer: () => walletLockupIndexer,
+  withCanonicalAmount: () => withCanonicalAmount,
+  withDepositFate: () => withDepositFate,
+  withRfqState: () => withRfqState
+});
+module.exports = __toCommonJS(advanced_exports);
 
 // src/client/accept.ts
+var import_base8 = require("@scure/base");
+var import_sdk9 = require("@arkade-os/sdk");
+init_offer();
 init_lockupContract();
 
 // src/rfqCorridors.ts
@@ -1823,6 +1877,7 @@ var RfqCorridorRegistry = class {
 var rfqCorridorHandlers = new RfqCorridorRegistry();
 
 // src/rfqProfileParts.ts
+init_store();
 var rfqSecretsProfile = (secrets, paymentHash) => {
   const { signingDescriptor, ...preimage } = swapSecretsToRecord(secrets);
   return {
@@ -1952,6 +2007,7 @@ function onchainSendProfile(result) {
     network: result.l1Network,
     htlcAddress: result.htlc.address,
     minConfirmations: result.minConfirmations,
+    expectedAmount: result.expectedAmount,
     payoutPkScript: import_base5.hex.encode(result.payoutPkScript)
   };
 }
@@ -1963,6 +2019,7 @@ var OnchainSendCorridor = {
   project: (swap) => {
     const send = swap;
     return {
+      expectedAmount: send.expectedAmount,
       ...send.funding ? { funding: send.funding } : {},
       ...send.claimTxid ? { claimTxid: send.claimTxid } : {}
     };
@@ -1979,6 +2036,11 @@ var OnchainSendCorridor = {
         `onchain_send record carries no usable minConfirmations (${String(profile.minConfirmations)}); the confirmation gate cannot be checked \u2014 refusing to restore a swap that would claim an unconfirmed fill`
       );
     }
+    if (!Number.isSafeInteger(profile.expectedAmount) || profile.expectedAmount <= 0) {
+      throw new Error(
+        `onchain_send record carries no usable expectedAmount (${String(profile.expectedAmount)}); the funded value cannot be checked \u2014 refusing to restore a swap that would claim an underfunded fill`
+      );
+    }
     const htlc = onchainHtlcScript(
       {
         // From the profile, not the covenant: the lockup commits to
@@ -2001,6 +2063,7 @@ var OnchainSendCorridor = {
       paymentHash,
       htlc,
       minConfirmations: profile.minConfirmations,
+      expectedAmount: profile.expectedAmount,
       // Optional here, required at the write: throwing on an older
       // record would strand the refund it is still owed.
       ...profile.payoutPkScript ? { payoutPkScript: import_base5.hex.decode(profile.payoutPkScript) } : {},
@@ -2020,6 +2083,9 @@ rfqCorridorHandlers.register(LightningSendCorridor);
 rfqCorridorHandlers.register(LightningReceiveCorridor);
 rfqCorridorHandlers.register(OnchainSendCorridor);
 
+// src/client/accept.ts
+init_store();
+
 // src/client/assetId.ts
 var import_sdk4 = require("@arkade-os/sdk");
 var RAILS = ["arkade", "bitcoin", "bolt11", "eip155"];
@@ -2168,7 +2234,8 @@ var issuanceOf = (id) => {
 };
 
 // src/client/aliases.ts
-var import_solver_discovery = require("@arkade-os/solver-discovery");
+var import_solver_discovery2 = require("@arkade-os/solver-discovery");
+init_store();
 
 // src/client/errors.ts
 init_rfq();
@@ -2241,10 +2308,10 @@ var QuoteExpired = class extends Error {
   name = "QuoteExpired";
 };
 var MaxFeeExceeded = class extends Error {
-  constructor(quoteId, asset5, fee, maxFee) {
-    super(`fee ${fee} of ${asset5} exceeds the ${maxFee} ceiling`);
+  constructor(quoteId, asset6, fee, maxFee) {
+    super(`fee ${fee} of ${asset6} exceeds the ${maxFee} ceiling`);
     this.quoteId = quoteId;
-    this.asset = asset5;
+    this.asset = asset6;
     this.fee = fee;
     this.maxFee = maxFee;
   }
@@ -2255,11 +2322,11 @@ var MaxFeeExceeded = class extends Error {
   name = "MaxFeeExceeded";
 };
 var InsufficientFunds = class extends Error {
-  constructor(asset5, required, available) {
+  constructor(asset6, required, available) {
     super(
-      `funding needs ${required} of ${asset5}` + (available === void 0 ? "" : `, wallet holds ${available}`)
+      `funding needs ${required} of ${asset6}` + (available === void 0 ? "" : `, wallet holds ${available}`)
     );
-    this.asset = asset5;
+    this.asset = asset6;
     this.required = required;
     this.available = available;
   }
@@ -2297,9 +2364,9 @@ var NotCancellable = class extends Error {
   name = "NotCancellable";
 };
 var InconsistentRoute = class extends Error {
-  constructor(asset5, destination) {
-    super(`destination ${JSON.stringify(destination)} is not on ${asset5}'s chain`);
-    this.asset = asset5;
+  constructor(asset6, destination) {
+    super(`destination ${JSON.stringify(destination)} is not on ${asset6}'s chain`);
+    this.asset = asset6;
     this.destination = destination;
   }
   asset;
@@ -2352,29 +2419,29 @@ function isSwapError(e, name) {
 // src/client/aliases.ts
 var toDiscoveryLeg = (id) => {
   const { rail, assetNamespace, assetReference } = parseAssetId(id);
-  const asset5 = `${assetNamespace}:${assetReference}`;
+  const asset6 = `${assetNamespace}:${assetReference}`;
   if (rail === "arkade") {
-    if (asset5 === BTC_ASSET_PART)
+    if (asset6 === BTC_ASSET_PART)
       return { corridor: "arkade", assetId: BTC_ASSET_ID, marketId: id };
     if (assetNamespace === ARKADE_ASSET_NAMESPACE) {
       return { corridor: "arkade", assetId: assetReference, marketId: id };
     }
-    throw new UnsupportedRoute(`the arkade corridor has no ${asset5}`);
+    throw new UnsupportedRoute(`the arkade corridor has no ${asset6}`);
   }
   if (rail === "bolt11") {
-    if (asset5 === BTC_ASSET_PART)
+    if (asset6 === BTC_ASSET_PART)
       return { corridor: "lightning", assetId: BTC_ASSET_ID, marketId: id };
-    throw new UnsupportedRoute(`the lightning corridor carries BTC only, not ${asset5}`);
+    throw new UnsupportedRoute(`the lightning corridor carries BTC only, not ${asset6}`);
   }
   if (rail === "bitcoin") {
-    if (asset5 === BTC_ASSET_PART)
+    if (asset6 === BTC_ASSET_PART)
       return { corridor: "onchain", assetId: BTC_ASSET_ID, marketId: id };
-    throw new UnsupportedRoute(`the onchain corridor carries BTC only, not ${asset5}`);
+    throw new UnsupportedRoute(`the onchain corridor carries BTC only, not ${asset6}`);
   }
   throw new UnsupportedRoute(`no corridor serves ${id}`);
 };
-var INDEXED_NETWORKS = import_solver_discovery.NETWORKS;
-var isIndexedNetwork = (network) => (0, import_solver_discovery.isNetwork)(network);
+var INDEXED_NETWORKS = import_solver_discovery2.NETWORKS;
+var isIndexedNetwork = (network) => (0, import_solver_discovery2.isNetwork)(network);
 var networkOfRow = (row) => parseAssetId(row.id).reference;
 var canonicalAssetId = (input, table) => {
   if (isAssetId(input)) return input;
@@ -2606,7 +2673,7 @@ var ACTIVITY_TOKEN = {
 };
 
 // src/client/amount.ts
-var import_solver_discovery2 = require("@arkade-os/solver-discovery");
+var import_solver_discovery3 = require("@arkade-os/solver-discovery");
 var AmountFormatError = class extends Error {
   constructor(reason, message) {
     super(message);
@@ -2619,10 +2686,10 @@ var SCALED_DECIMAL = /^([0-9]+)(?:\.([0-9]+))?$/;
 var ATOMIC_CEILING = 10n ** 30n;
 var MAX_SIGNIFICANT_DIGITS = 64;
 var assertDecimals = (decimals) => {
-  if (!Number.isInteger(decimals) || decimals < 0 || decimals > import_solver_discovery2.MAX_ASSET_DECIMALS) {
+  if (!Number.isInteger(decimals) || decimals < 0 || decimals > import_solver_discovery3.MAX_ASSET_DECIMALS) {
     throw new AmountFormatError(
       "invalid_decimals",
-      `decimals must be an integer in [0, ${import_solver_discovery2.MAX_ASSET_DECIMALS}], got ${decimals}`
+      `decimals must be an integer in [0, ${import_solver_discovery3.MAX_ASSET_DECIMALS}], got ${decimals}`
     );
   }
 };
@@ -2650,8 +2717,8 @@ var Amount = {
    * result would not survive the record boundary, so one law holds in both
    * directions.
    */
-  parse(display, asset5) {
-    assertDecimals(asset5.decimals);
+  parse(display, asset6) {
+    assertDecimals(asset6.decimals);
     const parts = SCALED_DECIMAL.exec(display);
     if (!parts) {
       throw new AmountFormatError(
@@ -2660,17 +2727,17 @@ var Amount = {
       );
     }
     const [, whole, fraction = ""] = parts;
-    if (fraction.length > asset5.decimals) {
+    if (fraction.length > asset6.decimals) {
       throw new AmountFormatError(
         "too_precise",
-        `${display} has more precision than ${asset5.decimals} decimals allow`
+        `${display} has more precision than ${asset6.decimals} decimals allow`
       );
     }
     if (whole.length + fraction.length > MAX_SIGNIFICANT_DIGITS) {
       throw new AmountFormatError("too_large", `${display} has too many digits`);
     }
-    const value = (0, import_solver_discovery2.toAtomic)(display, asset5.decimals);
-    assertRepresentable(value, `${display} at ${asset5.decimals} decimals`);
+    const value = (0, import_solver_discovery3.toAtomic)(display, asset6.decimals);
+    assertRepresentable(value, `${display} at ${asset6.decimals} decimals`);
     return value;
   },
   /**
@@ -2679,13 +2746,13 @@ var Amount = {
    * Refuses a negative: every amount on this surface is an obligation, and a
    * negative one is a defect upstream rather than a number to render.
    */
-  format(value, asset5) {
-    assertDecimals(asset5.decimals);
+  format(value, asset6) {
+    assertDecimals(asset6.decimals);
     if (value < 0n) {
       throw new AmountFormatError("negative", `amount must be non-negative, got ${value}`);
     }
     assertRepresentable(value, `${value}`);
-    return (0, import_solver_discovery2.fromAtomic)(value, asset5.decimals);
+    return (0, import_solver_discovery3.fromAtomic)(value, asset6.decimals);
   }
 };
 var toAtomicDecimal = (value) => {
@@ -2696,7 +2763,7 @@ var toAtomicDecimal = (value) => {
   return value.toString();
 };
 var fromAtomicDecimal = (text) => {
-  if (!(0, import_solver_discovery2.isAmount)(text)) {
+  if (!(0, import_solver_discovery3.isAmount)(text)) {
     throw new AmountFormatError(
       "not_canonical",
       `not a canonical atomic amount: ${JSON.stringify(text)}`
@@ -2704,10 +2771,10 @@ var fromAtomicDecimal = (text) => {
   }
   return BigInt(text);
 };
-var isAtomicDecimal = (value) => typeof value === "string" && import_solver_discovery2.AMOUNT_PATTERN.test(value);
+var isAtomicDecimal = (value) => typeof value === "string" && import_solver_discovery3.AMOUNT_PATTERN.test(value);
 
 // src/client/rfqAmount.ts
-var import_solver_discovery3 = require("@arkade-os/solver-discovery");
+var import_solver_discovery4 = require("@arkade-os/solver-discovery");
 var toRfqAmountSide = (on) => on === "give" ? "from" : "to";
 var fromRfqAmountSide = (side) => side === "from" ? "give" : "take";
 var encodeRfqAmount = (value, field) => {
@@ -2724,7 +2791,7 @@ var encodeRfqAmount = (value, field) => {
 };
 var decodeRfqAmount = (raw, field) => {
   if (typeof raw === "string") {
-    if (!(0, import_solver_discovery3.isAmount)(raw)) {
+    if (!(0, import_solver_discovery4.isAmount)(raw)) {
       throw new AmountEncodingUnsupported(
         field,
         raw,
@@ -3010,6 +3077,7 @@ var profileOf = (preparation, paymentHash) => {
           htlcParams: preparation.htlcParams,
           l1Network: preparation.l1Network,
           minConfirmations: preparation.minConfirmations,
+          expectedAmount: toSafeNumber(preparation.expectedAmount, "expectedAmount"),
           payoutPkScript: preparation.payoutPkScript
         })
       };
@@ -3136,6 +3204,9 @@ var depositMatches = (vtxo, record, expected) => {
 };
 var swapRecordOf = async (repository, id) => storageOf(repository).getSwapRecord(id);
 
+// src/client/aliasTable.ts
+init_store();
+
 // src/marketShape.ts
 var MARKET_CORRIDORS = ["arkade", "bolt11", "bitcoin", "eip155"];
 var LEGACY_CORRIDORS = {
@@ -3146,9 +3217,9 @@ var LEGACY_CORRIDORS = {
 };
 var assetOf = (market, side) => side === "base" ? market.base_asset : market.quote_asset;
 var marketAssetId = (market, side) => {
-  const asset5 = assetOf(market, side);
-  if (typeof asset5?.caip19_id === "string") return asset5.caip19_id;
-  return typeof asset5?.id === "string" ? asset5.id : void 0;
+  const asset6 = assetOf(market, side);
+  if (typeof asset6?.caip19_id === "string") return asset6.caip19_id;
+  return typeof asset6?.id === "string" ? asset6.id : void 0;
 };
 var chainNamespaceOf = (id) => {
   if (id === void 0) return void 0;
@@ -3260,30 +3331,26 @@ var LockupNeedsRecoveryError = class extends Error {
     this.recoverableAfter = recoverableAfter;
   }
 };
-async function findLockupVtxos(indexer, swapPkScript) {
-  const scripts = [import_base9.hex.encode(swapPkScript)];
-  const [spendable, recoverable] = await Promise.all([
-    indexer.getVtxos({ scripts, spendableOnly: true }),
-    indexer.getVtxos({ scripts, recoverableOnly: true })
-  ]);
+async function findLockupVtxos(contracts, swapPkScript) {
+  const [row] = await contracts.getContractsWithVtxos({
+    script: import_base9.hex.encode(swapPkScript)
+  });
   const seen = /* @__PURE__ */ new Set();
   const out = [];
-  for (const [vtxos, isRecoverable] of [
-    [spendable.vtxos ?? [], false],
-    [recoverable.vtxos ?? [], true]
-  ]) {
-    for (const vtxo of vtxos) {
-      if (vtxo.isUnrolled) continue;
-      const key = `${vtxo.txid}:${vtxo.vout}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      out.push({
-        txid: vtxo.txid,
-        vout: vtxo.vout,
-        value: Number(vtxo.value),
-        recoverable: isRecoverable
-      });
-    }
+  for (const vtxo of row?.vtxos ?? []) {
+    if (vtxo.isUnrolled) continue;
+    if ((0, import_sdk10.hasTerminalSpend)(vtxo)) continue;
+    const key = `${vtxo.txid}:${vtxo.vout}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({
+      txid: vtxo.txid,
+      vout: vtxo.vout,
+      value: Number(vtxo.value),
+      // The manager's canonical `isSwept` fact; no coercion, because the
+      // normalized row guarantees a boolean.
+      recoverable: vtxo.isSwept
+    });
   }
   return out;
 }
@@ -3684,11 +3751,12 @@ var corridorSet = (base, overrides) => {
 };
 
 // src/client/discovery.ts
-var import_solver_discovery5 = require("@arkade-os/solver-discovery");
+var import_solver_discovery6 = require("@arkade-os/solver-discovery");
 
 // src/markets.ts
-var import_solver_discovery4 = require("@arkade-os/solver-discovery");
+var import_solver_discovery5 = require("@arkade-os/solver-discovery");
 var import_sdk15 = require("@arkade-os/sdk");
+init_store();
 var QUOTE_OPTIONS = { safetyBps: 0 };
 var makeCachedFeedFetch = (ttlMs = 3e4, fetchImpl = fetch) => {
   const cache = /* @__PURE__ */ new Map();
@@ -3745,7 +3813,7 @@ var REGISTRY_URL = {
 };
 var HEX_64 = /^[0-9a-f]{64}$/;
 var LEGACY_ASSET_ID = /^(?:btc|[0-9a-f]{68})$/;
-var isRelayList = (value) => Array.isArray(value) && value.length > 0 && value.length <= import_solver_discovery5.MAX_RELAYS && value.every((relay) => typeof relay === "string" && relay.startsWith("wss://"));
+var isRelayList = (value) => Array.isArray(value) && value.length > 0 && value.length <= import_solver_discovery6.MAX_RELAYS && value.every((relay) => typeof relay === "string" && relay.startsWith("wss://"));
 var isCorridorField = (value) => value === void 0 || CORRIDORS.includes(value);
 var isUsableCard = (value) => {
   const card = value;
@@ -3757,7 +3825,7 @@ var isUsableCard = (value) => {
     const id = marketAssetId(card, side);
     if (id === void 0 || !isAssetId(id) && !LEGACY_ASSET_ID.test(id)) return false;
   }
-  if ((0, import_solver_discovery5.isRfqMarket)(card)) {
+  if ((0, import_solver_discovery6.isRfqMarket)(card)) {
     if (typeof card.discovery_pubkey !== "string" || !HEX_64.test(card.discovery_pubkey)) {
       return false;
     }
@@ -3833,7 +3901,7 @@ var discoveryIndex = (input) => {
     if (!indexed || !url) {
       return unavailable(whyUnavailable());
     }
-    const result = await (0, import_solver_discovery5.discover)({
+    const result = await (0, import_solver_discovery6.discover)({
       registries: [url],
       localCards: [...config.localCards ?? []],
       network: indexed,
@@ -3869,11 +3937,15 @@ var discoveryIndex = (input) => {
 
 // src/client/cancel.ts
 var import_base12 = require("@scure/base");
-var import_sdk17 = require("@arkade-os/sdk");
+var import_sdk18 = require("@arkade-os/sdk");
+init_coverage();
+init_offer();
 
 // src/restore.ts
 var import_base11 = require("@scure/base");
 var import_sdk16 = require("@arkade-os/sdk");
+init_offer();
+init_store();
 var TXS_PER_REQUEST = 50;
 async function fetchParsedTxs(indexer, txids) {
   const parsedByTxid = /* @__PURE__ */ new Map();
@@ -3935,7 +4007,7 @@ function classifyDepositSpend(offer, operatorPubkey, spendTxs, deposit) {
   return "indeterminate";
 }
 async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
-  const { operatorPubkey, scanned = /* @__PURE__ */ new Set(), reopen = [] } = opts;
+  const { operatorPubkey, scanned = /* @__PURE__ */ new Set(), reopen = [], hrp } = opts;
   const reopened = [];
   for (const swap of reopen) {
     try {
@@ -4036,17 +4108,27 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
       restored.push({ ...existing, status, spentTxid, ...completion });
       continue;
     }
+    let swapAddress = "";
+    try {
+      const compiled = offerContract(offer, operatorPubkey);
+      if (import_base11.hex.encode(compiled.pkScript) !== swapPkScript) {
+        unresolved.add(fundingTx.redeemTxid);
+        continue;
+      }
+      if (hrp !== void 0) {
+        swapAddress = compiled.address(hrp, operatorPubkey).encode();
+      }
+    } catch {
+      unresolved.add(fundingTx.redeemTxid);
+      continue;
+    }
     restored.push({
       id: fundingTx.redeemTxid,
       fromAsset,
       toAsset,
       fromAmount,
       toAmount: offer.wantAmount.toString(),
-      // ponytail(arkade-os/ts-sdk#680): empty address makes cancel fall back
-      // to the current operator key; store the funded address if operator-key
-      // rotations become real (cancelOffer now at least diagnoses the
-      // mismatch instead of reporting a missing VTXO)
-      swapAddress: "",
+      swapAddress,
       swapPkScript,
       offerHex,
       fundingTxid: fundingTx.redeemTxid,
@@ -4062,6 +4144,8 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
 }
 
 // src/client/driveRecords.ts
+init_store();
+var import_sdk17 = require("@arkade-os/sdk");
 var splitRecords = (records) => {
   const corridor = [];
   const offer = [];
@@ -4203,7 +4287,44 @@ var applyOfferSpend = (record, changes, now) => ({
   ...changes.completedAt === void 0 ? {} : { completedAt: Math.floor(changes.completedAt / 1e3) },
   updatedAt: now
 });
-var withOfferStatus = (record, status, now) => ({ ...record, status, updatedAt: now });
+var withDepositFate = (record, fate, now) => ({
+  ...record,
+  status: fate.status,
+  ...fate.spentTxid === void 0 ? {} : { spentTxid: fate.spentTxid },
+  ...fate.completedAt === void 0 ? {} : { completedAt: Math.floor(fate.completedAt / 1e3) },
+  updatedAt: now
+});
+var fateMoved = (record, fate) => record.status !== fate.status || fate.spentTxid !== void 0 && record.spentTxid !== fate.spentTxid || fate.completedAt !== void 0 && record.completedAt !== Math.floor(fate.completedAt / 1e3);
+var restoredOfferRecord = (swap, network, now) => {
+  const give = restoredAssetId(network, swap.fromAsset);
+  const take = restoredAssetId(network, swap.toAsset);
+  const createdAt = Math.floor(swap.createdAt / 1e3);
+  return withDepositFate(
+    {
+      id: swap.fundingTxid,
+      family: "offer",
+      route: {
+        give: { corridor: "arkade", asset: give, instrument: { kind: "wallet" } },
+        take: { corridor: "arkade", asset: take, instrument: { kind: "wallet" } }
+      },
+      give: { asset: give, amount: toAtomicDecimal(BigInt(swap.fromAmount)) },
+      take: { asset: take, amount: toAtomicDecimal(BigInt(swap.toAmount)) },
+      fee: { asset: take, amount: toAtomicDecimal(BigInt(0)) },
+      market: { kind: "restored", backend: "feed" },
+      expiresAt: createdAt,
+      status: swap.status,
+      offerHex: swap.offerHex,
+      swapAddress: swap.swapAddress,
+      swapPkScript: swap.swapPkScript,
+      fundingTxid: swap.fundingTxid,
+      createdAt,
+      updatedAt: now
+    },
+    swap,
+    now
+  );
+};
+var restoredAssetId = (network, id) => id === BTC_ASSET_ID ? btcOn("arkade", network) : arkadeAsset(network, import_sdk17.asset.AssetId.fromString(id));
 var walletLockupIndexer = (wallet) => {
   let reader;
   const reading = () => reader ??= wallet.getArkadeReader();
@@ -4293,12 +4414,12 @@ var reconcileDepositSpend = async (record, indexer) => {
   const { txs } = await indexer.getVirtualTxs(candidates);
   const parsed = txs.map((psbt) => {
     try {
-      return import_sdk17.Transaction.fromPSBT(import_base12.base64.decode(psbt));
+      return import_sdk18.Transaction.fromPSBT(import_base12.base64.decode(psbt));
     } catch {
       return void 0;
     }
   }).filter((tx) => tx !== void 0);
-  const operatorPubkey = import_sdk17.ArkAddress.decode(record.swapAddress).serverPubKey;
+  const operatorPubkey = import_sdk18.ArkAddress.decode(record.swapAddress).serverPubKey;
   const kind = classifyDepositSpend(offer, operatorPubkey, parsed, {
     txid: deposit.txid,
     vout: deposit.vout
@@ -4337,14 +4458,14 @@ var retireOfferScripts = async (wallet, repository, record) => {
 var isMissingVtxo = (error) => error instanceof NoSpendableDepositError;
 
 // src/client/drive.ts
-var import_sdk23 = require("@arkade-os/sdk");
+var import_sdk24 = require("@arkade-os/sdk");
 var import_base17 = require("@scure/base");
 
 // src/claim.ts
 var import_base13 = require("@scure/base");
 var import_legacy3 = require("@noble/hashes/legacy.js");
 var import_sha25 = require("@noble/hashes/sha2.js");
-var import_sdk18 = require("@arkade-os/sdk");
+var import_sdk19 = require("@arkade-os/sdk");
 var LockupAmountMismatchError = class extends Error {
   name = "LockupAmountMismatchError";
   reason = "amount_mismatch";
@@ -4388,14 +4509,14 @@ async function pushClaim(operator, input) {
   const info = await operator.getInfo();
   let operatorUnrollScript;
   try {
-    operatorUnrollScript = import_sdk18.CSVMultisigTapscript.decode(import_base13.hex.decode(info.checkpointTapscript));
+    operatorUnrollScript = import_sdk19.CSVMultisigTapscript.decode(import_base13.hex.decode(info.checkpointTapscript));
   } catch {
     throw new Error("invalid checkpointTapscript from the operator");
   }
   const leaf = input.contract.claim();
   const tapTree = input.contract.encode();
-  const txid = await (0, import_sdk18.signAndSubmitOffchainTx)({
-    identity: (0, import_sdk18.claimWithPreimageIdentity)(input.receiver, input.preimage),
+  const txid = await (0, import_sdk19.signAndSubmitOffchainTx)({
+    identity: (0, import_sdk19.claimWithPreimageIdentity)(input.receiver, input.preimage),
     provider: operator,
     inputs: input.vtxos.map((vtxo) => ({
       txid: vtxo.txid,
@@ -4415,10 +4536,11 @@ async function pushClaim(operator, input) {
 
 // src/client/drive.ts
 init_onchainHtlc();
+init_coverage();
 init_lockupContract();
 
 // src/refundBlocked.ts
-var import_sdk19 = require("@arkade-os/sdk");
+var import_sdk20 = require("@arkade-os/sdk");
 var RefundNotLocallyPossibleError = class extends Error {
   constructor(reason, message, options) {
     super(message, options);
@@ -4435,16 +4557,16 @@ async function senderIdentityForSwapRecord(wallet, record) {
     );
   }
   try {
-    return await (0, import_sdk19.contractSigner)(wallet, record.signingDescriptor);
+    return await (0, import_sdk20.contractSigner)(wallet, record.signingDescriptor);
   } catch (cause) {
-    if (cause instanceof import_sdk19.WalletCannotSignError) {
+    if (cause instanceof import_sdk20.WalletCannotSignError) {
       throw new RefundNotLocallyPossibleError(
         "unsignable-wallet",
         `this wallet holds ${record.signingDescriptor} but cannot sign with it; attach its signer`,
         { cause }
       );
     }
-    if (cause instanceof import_sdk19.ForeignDescriptorError) {
+    if (cause instanceof import_sdk20.ForeignDescriptorError) {
       throw new RefundNotLocallyPossibleError(
         "foreign-descriptor",
         `this wallet cannot derive ${record.signingDescriptor}; the swap was created on another wallet`,
@@ -4464,7 +4586,7 @@ function arkadeRefunder(deps) {
         `swap ${swap.rfqId} carries no lockup covenant, so its refund cannot be built`
       );
     }
-    const vtxos = await findLockupVtxos(deps.indexer, swap.lockupPkScript);
+    const vtxos = await findLockupVtxos(deps.contracts, swap.lockupPkScript);
     if (vtxos.length === 0) return null;
     const record = await deps.repository.getRfqSwap(swap.rfqId);
     if (!record) {
@@ -4479,7 +4601,7 @@ function arkadeRefunder(deps) {
 }
 
 // src/rfqRecord.ts
-var import_sdk20 = require("@arkade-os/sdk");
+var import_sdk21 = require("@arkade-os/sdk");
 var import_base14 = require("@scure/base");
 
 // src/rfqSwapState.ts
@@ -4525,7 +4647,7 @@ function assertSameSwap(origin, swap) {
       `rfq swap record is a ${origin.kind} origin paired with a ${swap.kind} swap`
     );
   }
-  const funded = import_base14.hex.encode(import_sdk20.ArkAddress.decode(origin.lockupAddress).pkScript);
+  const funded = import_base14.hex.encode(import_sdk21.ArkAddress.decode(origin.lockupAddress).pkScript);
   const watched = import_base14.hex.encode(swap.lockupPkScript);
   if (funded !== watched) {
     throw new Error(
@@ -4574,8 +4696,8 @@ function rfqSwapOriginOf(record) {
   };
 }
 function lockupScript(params, lockupAddress) {
-  const script = import_sdk20.VHTLCV2ContractHandler.createScript(params);
-  const funded = import_sdk20.ArkAddress.decode(lockupAddress).pkScript;
+  const script = import_sdk21.VHTLCV2ContractHandler.createScript(params);
+  const funded = import_sdk21.ArkAddress.decode(lockupAddress).pkScript;
   if (import_base14.hex.encode(funded) !== import_base14.hex.encode(script.pkScript)) {
     throw new Error(
       `rfq swap covenant params derive ${import_base14.hex.encode(script.pkScript)}, but the record's lockup address holds ${import_base14.hex.encode(funded)} \u2014 these params are not this swap's`
@@ -4615,11 +4737,15 @@ function shouldRetainRfqSwap(record, now) {
   return now - record.updatedAt < RFQ_SWAP_RETENTION_SECONDS;
 }
 
+// src/client/drive.ts
+init_store();
+
 // src/swapManager.ts
 var import_base15 = require("@scure/base");
-var import_sdk21 = require("@arkade-os/sdk");
+var import_sdk22 = require("@arkade-os/sdk");
 init_onchainHtlc();
 init_lockupContract();
+init_coverage();
 function nextOnchainAction(input) {
   switch (input.phase.phase) {
     case "unfunded":
@@ -5116,7 +5242,7 @@ var RfqSwapManager = class {
         });
         return;
       }
-      if (!(0, import_sdk21.isContractVtxoEvent)(event)) return;
+      if (!(0, import_sdk22.isContractVtxoEvent)(event)) return;
       const swap = this.byLockupScript.get(event.contractScript);
       if (!swap) return;
       void this.pollSwap(swap).catch(() => {
@@ -5201,6 +5327,40 @@ var RfqSwapManager = class {
       void this.poll().then(() => this.arm());
     }, this.config.pollIntervalMs);
   }
+  /*
+   * Runs one serialized monitoring pass for a single swap.
+   *
+   * Flow
+   *
+   * 1. Prevents concurrent work
+   *   - Returns immediately if the swap is already in inProgress.
+   *   - Returns if the swap is no longer in monitored.
+   *   - Adds the swap ID to inProgress.
+   *
+   * 2. Runs the state machine
+   *   - Calls runPass(swap).
+   *   - runPass checks the lockup fate, drives claims, and may initiate refunds.
+   *
+   * 3. Persists changes
+   *   - If the pass marked the swap dirty, calls save(swap).
+   *   - A swap is considered persisted only if all configured sinks succeed:
+   *     - the repository, and
+   *     - callbacks.saveSwap, if provided.
+   *
+   * 4. Completes waiters and finalizes
+   *   - If persistence succeeds:
+   *     - clears the dirty flag,
+   *     - settles waitForSwapCompletion waiters,
+   *     - moves terminal swaps from monitored to finished,
+   *     - emits completion or failure notifications through finalize.
+   *
+   * 5. Releases the per-swap lock
+   *   - Deletes the swap ID from inProgress only after all asynchronous work completes.
+   *   - This prevents overlapping poll() calls from submitting duplicate claims or refunds.
+   *
+   * The important safety property is that terminal state is not finalized until its updated record has been
+   * successfully persisted. A failed save leaves the swap dirty and monitored so a later poll can retry.
+   */
   async pollSwap(swap) {
     if (this.inProgress.has(swap.rfqId)) return;
     if (!this.monitored.has(swap.rfqId)) return;
@@ -5217,6 +5377,42 @@ var RfqSwapManager = class {
       this.inProgress.delete(swap.rfqId);
     }
   }
+  /*
+   * executes one monitoring/state-machine pass for a swap.
+   *
+   * Flow
+   * 1. Registers the lockup
+   *   - Calls ensureRegistered(swap).
+   *   - Registration is best effort and does not prevent the rest of the pass from running.
+   *
+   * 2. Reads the Arkade lockup fate
+   *   - Calls readLockupFate.
+   *   - A hash-verified claim is treated as claimed.
+   *   - A fully observed non-claim spend is treated as returned.
+   *   - Indexer errors become unknown, allowing deadline-driven logic to continue.
+   *   - For claimed or returned, it:
+   *     - records spend transaction IDs,
+   *     - records the settlement preimage when applicable,
+   *     - sets the swap state to settled or refunded,
+   *     - ends the pass.
+   *
+   * 3. Handles unilateral exits
+   *   - On receive swaps, an exited lockup is blocked immediately.
+   *   - On send swaps, the L1 half continues to be monitored because an exit only describes the Arkade side.
+   *
+   * 4. Drives the trader’s claim
+   *   - For lightning_receive, calls driveReceiveClaim and ends the pass.
+   *   - For onchain_send, calls driveOnchain to classify and potentially claim the L1 HTLC.
+   *   - A handled L1 action ends the pass; otherwise processing continues.
+   *
+   * 5. Drives an Arkade refund
+   *   - For send swaps whose lockup remains unresolved, calls driveArkadeRefund.
+   *   - This is gated by the refund timelock and local refund capability.
+   *   - Receive swaps never reach this step because their refund path belongs to the solver.
+   *
+   * runPass only decides and performs state-machine actions. Persistence, waiter settlement, terminal finalization,
+   * and the per-swap lock are handled by pollSwap.
+   */
   async runPass(swap) {
     await this.ensureRegistered(swap);
     let fate;
@@ -5235,7 +5431,10 @@ var RfqSwapManager = class {
       return;
     }
     if (swap.kind === "lightning_receive") {
-      return fate.fate === "exited" ? this.blockExitedLockup(swap, fate) : this.driveReceiveClaim(swap);
+      if (fate.fate === "exited") return this.blockExitedLockup(swap, fate);
+      if (fate.fate === "open") return this.driveReceiveClaim(swap);
+      if (this.config.now() >= swap.refundLocktime) return this.driveReceiveClaim(swap);
+      return;
     }
     if (swap.kind === "onchain_send" && swap.state !== "claimed") {
       if (await this.driveOnchain(swap) === "handled") return;
@@ -5290,7 +5489,7 @@ var RfqSwapManager = class {
     if (now < swap.refundLocktime) {
       let vtxos;
       try {
-        vtxos = await findLockupVtxos(this.deps.indexer, swap.lockupPkScript);
+        vtxos = await findLockupVtxos(this.deps.contracts, swap.lockupPkScript);
       } catch (error) {
         this.emitFailed(swap, error);
         return;
@@ -5393,6 +5592,21 @@ var RfqSwapManager = class {
     });
     if (action === "claim" && phase.phase === "claimable") {
       if (swap.claimTxid) return "continue";
+      if (!Number.isSafeInteger(swap.expectedAmount) || swap.expectedAmount <= 0) {
+        this.block(
+          swap,
+          `expectedAmount is not a positive number of sats (${String(swap.expectedAmount)}), so the funded value cannot be checked \u2014 refusing to publish the preimage`
+        );
+        return "handled";
+      }
+      const filled = Number(phase.utxo.amount);
+      if (!Number.isFinite(filled) || filled < swap.expectedAmount) {
+        this.block(
+          swap,
+          `fill holds ${filled} sats, below the agreed ${swap.expectedAmount} \u2014 refusing to publish the preimage`
+        );
+        return "handled";
+      }
       if (this.callbacks && !this.callbacks.claimOnchain) {
         this.block(swap, RFQ_CONFIGURATION_REFUSAL.noClaimOnchainCallback);
         return "handled";
@@ -5443,6 +5657,8 @@ var RfqSwapManager = class {
       if (pushed) {
         swap.refundTxid = pushed.txid;
         this.touch(swap);
+      } else if (now < swap.refundLocktime + REFUND_MTP_LAG_SECONDS) {
+        return;
       }
       this.setState(swap, "refunded");
       this.emitAction(swap, "refundArkade");
@@ -5677,7 +5893,10 @@ var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
 
 // src/watch.ts
 var import_base16 = require("@scure/base");
-var import_sdk22 = require("@arkade-os/sdk");
+var import_sdk23 = require("@arkade-os/sdk");
+init_coverage();
+init_offer();
+init_store();
 var TERMINAL = ["fulfilled", "cancelled", "recoverable"];
 var assetSwapSource = (repository) => ({
   list: () => getAssetSwaps(repository),
@@ -5709,7 +5928,7 @@ async function watchOfferSwaps({
     wallet.getAddress(),
     wallet.getArkadeReader()
   ]);
-  const operatorPubkey = import_sdk22.ArkAddress.decode(address).serverPubKey;
+  const operatorPubkey = import_sdk23.ArkAddress.decode(address).serverPubKey;
   let queue = Promise.resolve();
   const enqueue = (task) => {
     queue = queue.then(task).catch(() => {
@@ -5724,7 +5943,7 @@ async function watchOfferSwaps({
       return classifyDepositSpend(
         decodeOffer(import_base16.hex.decode(swap.offerHex)),
         operatorPubkey,
-        txs.map((psbt) => import_sdk22.Transaction.fromPSBT(import_base16.base64.decode(psbt))),
+        txs.map((psbt) => import_sdk23.Transaction.fromPSBT(import_base16.base64.decode(psbt))),
         { txid: vtxo.txid, vout: vtxo.vout }
       );
     } catch {
@@ -5752,7 +5971,7 @@ async function watchOfferSwaps({
     }
   };
   const unsubscribe = manager.onContractEvent((event) => {
-    if (!(0, import_sdk22.isContractVtxoEvent)(event) || event.type !== "vtxo_spent") return;
+    if (!(0, import_sdk23.isContractVtxoEvent)(event) || event.type !== "vtxo_spent") return;
     enqueue(() => handleSpend(event));
   });
   return {
@@ -5935,7 +6154,7 @@ var createSwapDrive = (config) => {
       const secret = rfqClaimSecretOf(record);
       if (!secret) throw new Error(`rfq swap ${swap.rfqId} carries no claim secret`);
       const preimage = await preimageForSwapRecord(wallet, secret);
-      const signer = await (0, import_sdk23.contractSigner)(wallet, await (0, import_sdk23.identityDescriptor)(wallet.identity));
+      const signer = await (0, import_sdk24.contractSigner)(wallet, await (0, import_sdk24.identityDescriptor)(wallet.identity));
       const claimKey = record.profile.claimKey;
       if (typeof claimKey === "string") {
         const held = import_base17.hex.encode(await signer.xOnlyPublicKey());
@@ -5993,10 +6212,10 @@ var createSwapDrive = (config) => {
     return track(
       pushClaim(operator, {
         contract: script,
-        receiver: await (0, import_sdk23.contractSigner)(wallet, secret.signingDescriptor),
+        receiver: await (0, import_sdk24.contractSigner)(wallet, secret.signingDescriptor),
         preimage: await preimageForSwapRecord(wallet, secret),
         vtxos,
-        destinationPkScript: import_sdk23.ArkAddress.decode(payoutAddress).pkScript,
+        destinationPkScript: import_sdk24.ArkAddress.decode(payoutAddress).pkScript,
         // Passed straight through, both of them: the manager's own value
         // check decides WHEN to act, `pushClaim`'s decides whether `P` is
         // published, and it is the one with nothing between it and the
@@ -6029,7 +6248,7 @@ var createSwapDrive = (config) => {
     if (mode === "readonly") return;
     const push = arkadeRefunder({
       operator,
-      indexer,
+      contracts: lockupSource,
       wallet,
       repository: corridorStore()
     });
@@ -6055,16 +6274,13 @@ var createSwapDrive = (config) => {
   };
   let offerSource;
   const offers = () => offerSource ??= offerRecordSource(storage(), remember, now);
-  const sweepOfferDeposits = async (offer) => {
-    const funded = offer.filter(
-      (record) => record.fundingTxid !== void 0 && !RETIRABLE.includes(record.status)
-    );
-    if (funded.length === 0) return;
+  const restoreOfferDeposits = async (reopen) => {
     const store = storage();
-    const [history, scanned, address] = await Promise.all([
+    const [history, scanned, address, network] = await Promise.all([
       wallet.getTransactionHistory(),
       store.getScannedTxids(),
-      wallet.getAddress()
+      wallet.getAddress(),
+      config.network()
     ]);
     const txs = history.map((tx) => ({
       // `TxType` is `"SENT"`/`"RECEIVED"`; the scan filters on `"sent"`.
@@ -6075,30 +6291,61 @@ var createSwapDrive = (config) => {
       // The scan reads unix SECONDS; a wallet transaction carries ms.
       ...tx.createdAt ? { createdAt: Math.floor(tx.createdAt / 1e3) } : {}
     }));
+    const { hrp, serverPubKey: operatorPubkey } = import_sdk24.ArkAddress.decode(address);
+    const cursor = reopen === void 0 ? scanned : new Set([...scanned].filter((txid) => txid !== reopen));
     const { restored, scannedTxids } = await restoreAssetSwaps(indexer, txs, /* @__PURE__ */ new Set(), {
-      operatorPubkey: import_sdk23.ArkAddress.decode(address).serverPubKey,
-      scanned
+      operatorPubkey,
+      scanned: cursor,
+      hrp
     });
-    const byDeposit = new Map(restored.map((s) => [`${s.swapPkScript}:${s.fundingTxid}`, s]));
-    const stillLive = /* @__PURE__ */ new Set();
-    for (const record of funded) {
-      const found = byDeposit.get(`${record.swapPkScript}:${record.fundingTxid}`);
-      const status = found?.status ?? record.status;
-      if (status !== record.status) {
-        const updated = withOfferStatus(record, status, now());
-        await store.saveSwapRecord(updated);
-        remember(updated);
+    const { offer } = splitRecords(await store.getAllSwapRecords());
+    const current = new Map(offer.map((record) => [record.id, record]));
+    const byDeposit = new Map(
+      offer.filter((record) => record.fundingTxid !== void 0).map((record) => [`${record.swapPkScript}:${record.fundingTxid}`, record])
+    );
+    const unstamped = /* @__PURE__ */ new Map();
+    for (const record of offer) {
+      if (record.fundingTxid !== void 0 || !OFFER_LIVE(record.status)) continue;
+      unstamped.set(record.swapPkScript, [
+        ...unstamped.get(record.swapPkScript) ?? [],
+        record
+      ]);
+    }
+    const write = async (record) => {
+      await store.saveSwapRecord(record);
+      current.set(record.id, record);
+      remember(record);
+    };
+    for (const found of restored) {
+      const known = byDeposit.get(`${found.swapPkScript}:${found.fundingTxid}`);
+      if (known !== void 0) {
+        if (fateMoved(known, found)) await write(withDepositFate(known, found, now()));
+        continue;
+      }
+      const orphan = unstamped.get(found.swapPkScript)?.shift();
+      if (orphan !== void 0) {
+        await write(
+          withDepositFate({ ...orphan, fundingTxid: found.fundingTxid }, found, now())
+        );
+        continue;
       }
-      if (OFFER_LIVE(status) && record.fundingTxid) stillLive.add(record.fundingTxid);
+      await write(restoredOfferRecord(found, network, now()));
+    }
+    const stillLive = /* @__PURE__ */ new Set();
+    for (const record of current.values()) {
+      if (OFFER_LIVE(record.status) && record.fundingTxid) stillLive.add(record.fundingTxid);
     }
     await store.markTxidsScanned(scannedTxids.filter((txid) => !stillLive.has(txid)));
     const registry = managerDeps.contracts;
     if (registry) {
-      const { offer: current } = splitRecords(await store.getAllSwapRecords());
-      await retireSettledOfferContracts(registry, current.map(offerFactsOf));
+      await retireSettledOfferContracts(registry, [...current.values()].map(offerFactsOf));
     }
+    return [...current.values()];
   };
   const contractsOf = async () => managerDeps.contracts ??= await wallet.getContractManager();
+  const lockupSource = {
+    getContractsWithVtxos: async (filter) => (await contractsOf()).getContractsWithVtxos(filter)
+  };
   const registerCorridorSwap = async (record) => {
     if (mode === "readonly") return;
     if (!await drivable(record)) {
@@ -6169,13 +6416,14 @@ var createSwapDrive = (config) => {
         console.warn("[swap] the corridor restore could not drive", error);
       }
     }
+    let offers2 = offer;
     try {
-      await sweepOfferDeposits(offer);
+      offers2 = await restoreOfferDeposits();
     } catch (error) {
-      console.warn("[swap] the offer deposit sweep did not complete", error);
+      console.warn("[swap] the offer deposit restore did not complete", error);
     }
     emitAll();
-    if (mode === "auto" && await hasLiveWork(offer)) {
+    if (mode === "auto" && await hasLiveWork(offers2)) {
       try {
         await arm();
       } catch (error) {
@@ -6203,7 +6451,7 @@ var createSwapDrive = (config) => {
     }
     return probe.call(wallet);
   };
-  const recoverableAt = async (script) => (await findLockupVtxos(indexer, script)).filter((vtxo) => vtxo.recoverable);
+  const recoverableAt = async (script) => (await findLockupVtxos(lockupSource, script)).filter((vtxo) => vtxo.recoverable);
   const recover = async (id) => {
     if (disposed) throw new ClientDisposed("recover");
     if (mode === "readonly") {
@@ -6253,7 +6501,7 @@ var createSwapDrive = (config) => {
       );
     }
     const txid = await track((await recoverer()).recoverVtxos());
-    await sweepOfferDeposits([records.get(id)]);
+    await restoreOfferDeposits(record.fundingTxid);
     const after = records.get(id);
     const recovered = after?.family === "offer" && after.status !== "recoverable";
     return { recovered, txid, swap: swapView(id) };
@@ -6328,22 +6576,22 @@ var createSwapDrive = (config) => {
 };
 
 // src/client/quoteOffer.ts
-var import_solver_discovery7 = require("@arkade-os/solver-discovery");
+var import_solver_discovery8 = require("@arkade-os/solver-discovery");
 
 // src/client/market.ts
-var import_solver_discovery6 = require("@arkade-os/solver-discovery");
+var import_solver_discovery7 = require("@arkade-os/solver-discovery");
 var marketKeyOf = (card) => {
-  const base = (0, import_solver_discovery6.marketLegKey)(card, "base");
-  const quote = (0, import_solver_discovery6.marketLegKey)(card, "quote");
-  const baseIsArkade = (0, import_solver_discovery6.marketCorridor)(card, "base") === "arkade";
-  const quoteIsArkade = (0, import_solver_discovery6.marketCorridor)(card, "quote") === "arkade";
+  const base = (0, import_solver_discovery7.marketLegKey)(card, "base");
+  const quote = (0, import_solver_discovery7.marketLegKey)(card, "quote");
+  const baseIsArkade = (0, import_solver_discovery7.marketCorridor)(card, "base") === "arkade";
+  const quoteIsArkade = (0, import_solver_discovery7.marketCorridor)(card, "quote") === "arkade";
   if (baseIsArkade !== quoteIsArkade) {
     return baseIsArkade ? `${base}/${quote}` : `${quote}/${base}`;
   }
   return base <= quote ? `${base}/${quote}` : `${quote}/${base}`;
 };
-var isAddressable = (card) => !(0, import_solver_discovery6.isRfqMarket)(card) || typeof card.discovery_pubkey === "string" && (card.transports?.nostr?.relays?.length ?? 0) > 0;
-var marketBackendOf = (card) => (0, import_solver_discovery6.isRfqMarket)(card) ? "rfq" : "feed";
+var isAddressable = (card) => !(0, import_solver_discovery7.isRfqMarket)(card) || typeof card.discovery_pubkey === "string" && (card.transports?.nostr?.relays?.length ?? 0) > 0;
+var marketBackendOf = (card) => (0, import_solver_discovery7.isRfqMarket)(card) ? "rfq" : "feed";
 var usableMarkets = (snapshot, policy) => {
   const allowed = policy?.allowedRegistries;
   return (allowed ? snapshot.markets.filter((card) => allowed.includes(card.source)) : snapshot.markets).filter(isAddressable);
@@ -6361,12 +6609,12 @@ var eligibleMarkets = (snapshot, legs, policy, takeAmount) => {
       wantSide: side === "base" ? "quote" : "base",
       ...takeAmount === void 0 ? {} : { wantAmount: takeAmount }
     };
-    const canonical = (0, import_solver_discovery6.selectMarkets)([...markets], {
+    const canonical = (0, import_solver_discovery7.selectMarkets)([...markets], {
       baseId: base.marketId,
       quoteId: quote.marketId,
       ...selection
     });
-    const legacy = (0, import_solver_discovery6.selectMarkets)([...markets], {
+    const legacy = (0, import_solver_discovery7.selectMarkets)([...markets], {
       baseId: `${base.corridor}:${base.assetId}`,
       quoteId: `${quote.corridor}:${quote.assetId}`,
       ...selection
@@ -6426,16 +6674,16 @@ var assembleRoute = (give, take) => {
   }
   return { give, take };
 };
-var endpoint = (corridor, asset5, instrument) => ({
+var endpoint = (corridor, asset6, instrument) => ({
   corridor,
-  asset: asset5,
+  asset: asset6,
   ...instrument === void 0 ? {} : { instrument }
 });
-var legFor = (asset5, expected) => {
-  const leg = toDiscoveryLeg(asset5);
+var legFor = (asset6, expected) => {
+  const leg = toDiscoveryLeg(asset6);
   if (expected !== void 0 && leg.corridor !== expected) {
     throw new UnsupportedRoute(
-      `${asset5} settles on ${leg.corridor}, and this leg is ${expected}`,
+      `${asset6} settles on ${leg.corridor}, and this leg is ${expected}`,
       { give: leg.corridor, take: expected }
     );
   }
@@ -6727,7 +6975,7 @@ var quoteFromFeed = async (input) => {
   if (amount === void 0) {
     throw new Error("an asset swap needs an amount and the side it pins");
   }
-  const plan = await (0, import_solver_discovery7.quoteOffer)(candidate.card, {
+  const plan = await (0, import_solver_discovery8.quoteOffer)(candidate.card, {
     give: candidate.give,
     ...amount.on === "give" ? { giveAmount: amount.value } : { wantAmount: amount.value },
     ...QUOTE_OPTIONS,
@@ -6759,7 +7007,7 @@ var quoteFromFeed = async (input) => {
   };
 };
 var spreadOf = (plan) => {
-  const fair = (0, import_solver_discovery7.computeWantAmount)({
+  const fair = (0, import_solver_discovery8.computeWantAmount)({
     deposit: plan.deposit.atomic,
     give: plan.give,
     price: plan.price,
@@ -6784,17 +7032,17 @@ var verifyPlanLegs = (plan, legs, give) => {
 
 // src/client/quoteRfq.ts
 var import_base18 = require("@scure/base");
-var import_sdk26 = require("@arkade-os/sdk");
+var import_sdk27 = require("@arkade-os/sdk");
 init_claimPacket();
 init_onchainHtlc();
 init_onchainHtlc();
 
 // src/payment/onchainSwap.ts
-var import_sdk25 = require("@arkade-os/sdk");
+var import_sdk26 = require("@arkade-os/sdk");
 init_onchainHtlc();
 
 // src/payment/swapRail.ts
-var import_sdk24 = require("@arkade-os/sdk");
+var import_sdk25 = require("@arkade-os/sdk");
 
 // src/client/sats.ts
 var satsOf = (value, field) => {
@@ -6816,6 +7064,7 @@ init_rfq();
 
 // src/client/rfqWire.ts
 init_rfq();
+init_store();
 var BTC_LEG = {
   arkade: ARKADE_BTC,
   lightning: LIGHTNING_BTC,
@@ -6845,14 +7094,14 @@ var parseRfqQuote = (quote) => ({
 
 // src/client/quoteRfq.ts
 var covenantInputs = (input) => {
-  const network = (0, import_sdk26.networkFromArkadeInfo)(input.info);
+  const network = (0, import_sdk27.networkFromArkadeInfo)(input.info);
   const arkade2 = input.corridors.get("arkade").deps;
   return {
-    operatorPubkey: (0, import_sdk26.toXOnly)(import_base18.hex.decode(input.info.signerPubkey), "ark signer key"),
+    operatorPubkey: (0, import_sdk27.toXOnly)(import_base18.hex.decode(input.info.signerPubkey), "ark signer key"),
     // The per-network pin the arkade module already resolved, never a key
     // the operator reports about itself: this one ends up in a covenant leaf
     // that decides who can move the funds.
-    emulatorPubkey: (0, import_sdk26.toXOnly)(import_base18.hex.decode(arkade2.emulatorPubkey), "emulator signer key"),
+    emulatorPubkey: (0, import_sdk27.toXOnly)(import_base18.hex.decode(arkade2.emulatorPubkey), "emulator signer key"),
     claimDelay: unilateralClaimDelay(Number(input.info.unilateralExitDelay)),
     hrp: network.hrp
   };
@@ -6896,7 +7145,7 @@ var quoteLightningSend = async (input) => {
   }
   const pair = rfqPairFor(input.legs.give, input.legs.take);
   const rfqId = newRfqId();
-  const secrets = await (0, import_sdk26.provisionRefundKey)(input.wallet);
+  const secrets = await (0, import_sdk27.provisionRefundKey)(input.wallet);
   const wire = await input.transport.requestQuote(
     lightningSendRequest({
       rfqId,
@@ -6969,7 +7218,7 @@ var quoteLightningReceive = async (input) => {
   const pinned = pinnedFor(input);
   const pair = rfqPairFor(input.legs.give, input.legs.take);
   const rfqId = newRfqId();
-  const secrets = await (0, import_sdk26.provisionClaimSecret)(input.wallet);
+  const secrets = await (0, import_sdk27.provisionClaimSecret)(input.wallet);
   const paymentHash = import_base18.hex.encode(secrets.paymentHash);
   const payoutAddress = await input.wallet.getAddress();
   const lightning = input.corridors.get("lightning").deps;
@@ -7092,8 +7341,8 @@ var quoteOnchainSend = async (input) => {
     claimVsize: onchain.claimVsize
   }) : void 0;
   const quoted = claimFee === void 0 ? pinned : { on: pinned.on, value: pinned.value + claimFee, source: pinned.source };
-  const secrets = await (0, import_sdk26.provisionClaimSecret)(input.wallet);
-  const payoutKey = await (0, import_sdk26.provisionRefundKey)(input.wallet);
+  const secrets = await (0, import_sdk27.provisionClaimSecret)(input.wallet);
+  const payoutKey = await (0, import_sdk27.provisionRefundKey)(input.wallet);
   const paymentHash = import_base18.hex.encode(secrets.paymentHash);
   const wire = await input.transport.requestQuote(
     withCanonicalAmount(
@@ -7189,6 +7438,10 @@ var quoteOnchainSend = async (input) => {
       secrets,
       refundAddress: payoutKey.address,
       fundAmount: parsed.give,
+      // The gross wire leg, not `reportedTake`: the claim fee comes out of
+      // the HTLC output, so netting it here would accept an HTLC funded
+      // short by exactly that fee.
+      expectedAmount: parsed.take,
       payoutKey,
       payoutPkScript,
       htlc: derived.htlc,
@@ -7200,7 +7453,7 @@ var quoteOnchainSend = async (input) => {
 };
 
 // src/client/verbs.ts
-var import_sdk27 = require("@arkade-os/sdk");
+var import_sdk28 = require("@arkade-os/sdk");
 var enforceFeeCeiling = (quote, call, policy) => {
   let ceiling;
   for (const [source, limit] of [
@@ -7225,9 +7478,9 @@ var settle = async (deps, input, maxFee) => {
   return deps.accept(quote);
 };
 var pay = async (deps, destination, options = {}) => {
-  const arkade2 = (0, import_sdk27.arkTarget)(destination);
+  const arkade2 = (0, import_sdk28.arkTarget)(destination);
   if (arkade2 !== void 0) {
-    const amount = (0, import_sdk27.resolveSendAmount)(
+    const amount = (0, import_sdk28.resolveSendAmount)(
       "ark",
       destination,
       options.amount === void 0 ? void 0 : satsOf(options.amount, "amount")
@@ -7310,6 +7563,7 @@ var createSwapClient = (config) => {
     operator,
     ...config.repository === void 0 ? {} : { repository: config.repository },
     corridors: async () => (await resolved()).corridors,
+    network: async () => (await resolved()).base.networkName,
     ...config.policy?.drive === void 0 ? {} : { mode: config.policy.drive },
     indexer
   });
@@ -7547,7 +7801,7 @@ var createSwapClient = (config) => {
 var import_base20 = require("@scure/base");
 var import_legacy4 = require("@noble/hashes/legacy.js");
 var import_sha26 = require("@noble/hashes/sha2.js");
-var import_sdk28 = require("@arkade-os/sdk");
+var import_sdk29 = require("@arkade-os/sdk");
 init_claimPacket();
 var CovclaimdRevealError = class extends Error {
   name = "CovclaimdRevealError";
@@ -7652,7 +7906,7 @@ function revealFieldsFromScript(script) {
 }
 async function revealClaimPacket(client, input) {
   const fields = revealFieldsFromScript(input.script);
-  if (import_base20.hex.encode(import_sdk28.ArkAddress.decode(input.address).pkScript) !== import_base20.hex.encode(input.script.pkScript)) {
+  if (import_base20.hex.encode(import_sdk29.ArkAddress.decode(input.address).pkScript) !== import_base20.hex.encode(input.script.pkScript)) {
     throw new Error("address does not belong to this covenant");
   }
   if (import_base20.hex.encode((0, import_legacy4.ripemd160)((0, import_sha26.sha256)(input.preimage))) !== import_base20.hex.encode(input.script.options.preimageHash)) {
@@ -7743,6 +7997,7 @@ async function revealClaimPacket(client, input) {
   esploraTip,
   exchange,
   familyOfSwapId,
+  fateMoved,
   feedFetch,
   formatAssetId,
   fromAtomicDecimal,
@@ -7790,6 +8045,7 @@ async function revealClaimPacket(client, input) {
   resolveCorridorBase,
   resolveCorridorDeps,
   resolveRoute,
+  restoredOfferRecord,
   revealClaimPacket,
   revealFieldsFromScript,
   rfqLeg,
@@ -7817,6 +8073,6 @@ async function revealClaimPacket(client, input) {
   verifyingDerivation,
   walletLockupIndexer,
   withCanonicalAmount,
-  withOfferStatus,
+  withDepositFate,
   withRfqState
 });