@arkade-os/swap 0.0.18 → 0.0.20

package/dist/{chunk-N3W6LXH6.js → chunk-QJKMTPRQ.js}

@@ -1,6 +1,775 @@
-// src/onchainHtlc.ts
+// src/coverage.ts
+var RETIRABLE = ["fulfilled", "cancelled"];
+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(
+    () => {
+    },
+    () => {
+    }
+  );
+  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
 import { hex } from "@scure/base";
 import { sha256 } from "@noble/hashes/sha2.js";
+import { contractPreimage } from "@arkade-os/sdk";
+var BTC_ASSET_ID = "btc";
+var byNewest = (a, b) => b.createdAt - a.createdAt;
+var getAssetSwapsOrThrow = async (repository) => {
+  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 addAssetSwap = async (repository, swap) => {
+  const swaps = await getAssetSwapsOrThrow(repository);
+  if (swaps.some((s) => s.id === swap.id)) return swaps;
+  await saveSwapOrThrow(repository, swap);
+  const at = swaps.findIndex((s) => byNewest(swap, s) <= 0);
+  const merged = [...swaps];
+  merged.splice(at === -1 ? merged.length : at, 0, swap);
+  return merged;
+};
+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: hex.encode(secrets.preimage) } : {},
+  ..."preimageSalt" in secrets && secrets.preimageSalt ? { preimageSaltHex: hex.encode(secrets.preimageSalt) } : {}
+});
+var decodeHex32 = (value, field) => {
+  const bytes = hex.decode(value);
+  if (bytes.length !== 32) {
+    throw new Error(`${field} must be 32 bytes, got ${bytes.length}`);
+  }
+  return bytes;
+};
+var PreimageNotRecoverableError = class extends Error {
+  constructor(reason, message, options) {
+    super(message, options);
+    this.reason = reason;
+  }
+  reason;
+  name = "PreimageNotRecoverableError";
+};
+var preimageForSwapRecord = async (wallet, record) => {
+  if (!record.signingDescriptor) {
+    throw new PreimageNotRecoverableError(
+      "no-secrets",
+      "this swap record carries no signing descriptor"
+    );
+  }
+  let stored;
+  let salt;
+  try {
+    stored = record.preimageHex ? decodeHex32(record.preimageHex, "preimageHex") : void 0;
+    salt = record.preimageSaltHex ? decodeHex32(record.preimageSaltHex, "preimageSaltHex") : void 0;
+  } catch (cause) {
+    throw new PreimageNotRecoverableError(
+      "malformed-record",
+      `this swap record's secrets projection is unreadable: ${String(cause)}`,
+      { cause }
+    );
+  }
+  let preimage;
+  try {
+    preimage = await contractPreimage(wallet, record.signingDescriptor, { stored, salt });
+  } catch (cause) {
+    throw new PreimageNotRecoverableError(
+      "not-derivable",
+      `this wallet cannot produce the preimage for ${record.signingDescriptor}`,
+      { cause }
+    );
+  }
+  if (record.paymentHash && hex.encode(sha256(preimage)) !== record.paymentHash.toLowerCase()) {
+    throw new PreimageNotRecoverableError(
+      "hash-mismatch",
+      "the derived preimage does not match this swap's payment hash: wrong wallet, or a tampered salt"
+    );
+  }
+  return preimage;
+};
+
+// src/offer.ts
+import { hex as hex2 } from "@scure/base";
+import { concatBytes } from "@scure/btc-signer/utils.js";
+import {
+  ASSET_CARRIER_SATS as SDK_ASSET_CARRIER_SATS,
+  ArkAddress,
+  RestArkProvider,
+  RestEmulatorProvider,
+  RestIndexerProvider,
+  arkade,
+  asset,
+  getNetwork,
+  resolveEmulatorPubkey,
+  toXOnlySignerHex
+} from "@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/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"] }
+    }
+  }
+};
+
+// src/offer.ts
+var swapPrograms = {
+  wantAsset: arkade.parseArtifact(swap_want_asset_program_default),
+  wantBtc: 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" } }
+      }
+    }
+  };
+}
+function swapProgramBinding(offer, serverPubkey) {
+  if (offer.makerPkScript.length !== FIELDS.makerPkScript.width) {
+    throw new Error("makerPkScript is not a 34-byte taproot scriptPubKey");
+  }
+  return {
+    program: withExitClosure(
+      offer.wantAsset ? swapPrograms.wantAsset : swapPrograms.wantBtc,
+      offer.exitDelay
+    ),
+    args: {
+      makerWP: offer.makerPkScript.subarray(2),
+      wantAmount: offer.wantAmount,
+      server: serverPubkey,
+      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: serverPubkey,
+      userKey: offer.makerPublicKey,
+      emulatorKey: offer.emulatorPubkey
+    }
+  };
+}
+function offerVtxoScript(offer, serverPubkey) {
+  const { program, args, keys } = swapProgramBinding(offer, serverPubkey);
+  return new 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)`);
+  }
+  const out = new Uint8Array(8);
+  new DataView(out.buffer).setBigUint64(0, value, false);
+  return out;
+}
+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 concatBytes(Uint8Array.of(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");
+  }
+  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 concatBytes(...recs);
+}
+function encodeExitDelay(exit) {
+  return 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: asset.AssetId.fromBytes(fields.wantAsset) },
+    ...fields.offerAsset && { offerAsset: 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, arkServerUrl, network, binding, serverPubkey, expectedPkScript, opts = {}) {
+  const contractManager = opts.contractManager ?? await wallet.getContractManager();
+  const client = opts.client ?? await arkade.Arkade.connect({
+    arkade: new RestArkProvider(arkServerUrl),
+    indexer: new RestIndexerProvider(arkServerUrl),
+    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: getNetwork(network),
+    contractManager
+  });
+  await contractManager.createContract(
+    offerContractParams(client, binding, serverPubkey, expectedPkScript)
+  );
+  await promoteOfferContract(contractManager, hex2.encode(expectedPkScript), opts.issued);
+}
+function offerContractParams(client, binding, serverPubkey, expectedPkScript) {
+  const { program, args, keys } = swapProgramBinding(binding, serverPubkey);
+  const contract = new arkade.ArkadeContract(client, program, args, keys);
+  if (hex2.encode(contract.pkScript) !== hex2.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 }
+  };
+}
+async function restoreOfferCoverage(wallet, arkServerUrl, swaps) {
+  const live = swaps.filter((s) => !RETIRABLE.includes(s.status));
+  if (live.length === 0) return;
+  const arkProvider = new RestArkProvider(arkServerUrl);
+  const info = await arkProvider.getInfo();
+  const serverPubKey = hex2.decode(toXOnlySignerHex(info.signerPubkey));
+  const contractManager = await wallet.getContractManager();
+  const client = await arkade.Arkade.connect({
+    arkade: arkProvider,
+    indexer: new RestIndexerProvider(arkServerUrl),
+    identity: wallet.identity,
+    network: getNetwork(info.network),
+    contractManager
+  });
+  const done = /* @__PURE__ */ new Set();
+  const covenants = [];
+  for (const swap of live) {
+    if (done.has(swap.swapPkScript)) continue;
+    done.add(swap.swapPkScript);
+    try {
+      const { swapPkScript: _, ...binding } = decodeOffer(hex2.decode(swap.offerHex));
+      covenants.push({
+        script: swap.swapPkScript,
+        issued: swap.createdAt,
+        params: offerContractParams(
+          client,
+          binding,
+          serverPubKey,
+          hex2.decode(swap.swapPkScript)
+        )
+      });
+    } catch (err) {
+      console.warn(`[swap] could not restore coverage for ${swap.swapPkScript}`, err);
+    }
+  }
+  if (covenants.length === 0) return;
+  const paramsList = covenants.map((c) => c.params);
+  if (contractManager.createContracts) {
+    await contractManager.createContracts(paramsList);
+  } else {
+    for (const params of paramsList) await contractManager.createContract(params);
+  }
+  for (const c of covenants) await promoteOfferContract(contractManager, c.script, c.issued);
+}
+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, arkServerUrl, 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([
+    new RestArkProvider(arkServerUrl).getInfo(),
+    wallet.getAddress(),
+    wallet.identity.xOnlyPublicKey()
+  ]);
+  const serverPubKey = hex2.decode(toXOnlySignerHex(info.signerPubkey));
+  const network = getNetwork(info.network);
+  const emuKey = hex2.decode(
+    toXOnlySignerHex(resolveEmulatorPubkey(network, params.emulatorPubkey))
+  );
+  const binding = {
+    wantAmount: params.wantAmount,
+    wantAsset: params.wantAsset,
+    offerAsset: params.offerAsset,
+    makerPkScript: 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 = offerVtxoScript(binding, serverPubKey);
+  const offer = { ...binding, swapPkScript: script.pkScript };
+  await registerOfferContract(
+    wallet,
+    arkServerUrl,
+    info.network,
+    binding,
+    serverPubKey,
+    script.pkScript
+  );
+  const payload = encodeOffer(offer);
+  return {
+    offerHex: hex2.encode(payload),
+    extension: { type: OFFER_PACKET_TYPE, payload },
+    // VtxoScript.address owns address construction; assembling an ArkAddress
+    // from tweakedPublicKey here would silently miss any future step it gains
+    address: script.address(network.hrp, serverPubKey).encode(),
+    swapPkScript: script.pkScript
+  };
+}
+async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
+  const { repository, fundingTxid, swapAddress } = opts;
+  const offer = decodeOffer(hex2.decode(offerHex));
+  const contractManager = await wallet.getContractManager();
+  const client = await arkade.Arkade.connect({
+    arkade: new RestArkProvider(arkServerUrl),
+    indexer: new RestIndexerProvider(arkServerUrl),
+    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 ? ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
+  const { program, args, keys } = swapProgramBinding(offer, operatorPubkey);
+  const rebuilt = new arkade.ArkadeProgramScript(program, args, keys);
+  if (hex2.encode(rebuilt.pkScript) !== hex2.encode(offer.swapPkScript)) {
+    throw new Error(
+      "rebuilt covenant does not match the offer's swapPkScript \u2014 the server signing key has likely rotated since funding; pass swapAddress (the funded address) to pin the original key"
+    );
+  }
+  const contract = new 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 Error("no spendable VTXO at the swap address");
+  const makerPkScript = 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) }]
+    });
+  }
+  const swapId = fundingTxid ?? vtxo.txid;
+  const hasLocalRecord = (await getAssetSwapsOrThrow(repository)).some((s) => s.id === swapId);
+  if (hasLocalRecord) await updateAssetSwap(repository, swapId, { status: "cancelling" });
+  const { txid } = await cancel.send();
+  if (hasLocalRecord) {
+    const { persisted, swaps } = await updateAssetSwapBestEffort(repository, swapId, {
+      status: "cancelled",
+      spentTxid: txid
+    });
+    if (persisted) {
+      await retireOfferContract(contractManager, swaps, hex2.encode(offer.swapPkScript));
+    }
+  }
+  return txid;
+}
+var ASSET_CARRIER_SATS = BigInt(SDK_ASSET_CARRIER_SATS);
+async function fillOffer(wallet, arkServerUrl, offerHex, opts) {
+  const {
+    fund,
+    payoutScript,
+    fundingTxid,
+    swapAddress,
+    assetCarrierSats = ASSET_CARRIER_SATS,
+    emulator,
+    emulatorPubkey
+  } = opts;
+  const offer = decodeOffer(hex2.decode(offerHex));
+  const wantedAssetId = offer.wantAsset?.toString();
+  if (fund.length === 0) {
+    throw new Error("fillOffer needs coins to pay wantAmount with \u2014 `fund` is empty");
+  }
+  if (wantedAssetId !== void 0) {
+    const supplied = fund.reduce(
+      (sum, coin) => sum + amountOfAsset(coin.assets, wantedAssetId),
+      BigInt(0)
+    );
+    if (supplied < offer.wantAmount) {
+      throw new Error(
+        `fillOffer needs ${offer.wantAmount} of ${wantedAssetId} to pay the maker, but \`fund\` declares ${supplied} \u2014 pass coins carrying it, and declare their assets`
+      );
+    }
+  }
+  const contractManager = await wallet.getContractManager();
+  const client = await arkade.Arkade.connect({
+    arkade: new RestArkProvider(arkServerUrl),
+    indexer: new RestIndexerProvider(arkServerUrl),
+    identity: wallet.identity,
+    contractManager,
+    // `fulfill` is a covenant path, so the emulator executes the arkade
+    // script and finalizes with arkd. Without it the spend is built and then
+    // refused at submission — there is no default to fall back on.
+    emulator: typeof emulator === "string" ? new RestEmulatorProvider(emulator) : emulator,
+    // Only reached for the client's own emulatorKey, which this fill never
+    // derives against — the offer's own key is bound below. It still has to
+    // resolve, and on a network with no pinned key it throws without this.
+    ...emulatorPubkey ? { emulatorPubkey } : {}
+  });
+  const serverKey = swapAddress ? ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
+  const { program, args, keys } = swapProgramBinding(offer, serverKey);
+  const rebuilt = new arkade.ArkadeProgramScript(program, args, keys);
+  if (hex2.encode(rebuilt.pkScript) !== hex2.encode(offer.swapPkScript)) {
+    throw new Error(
+      "rebuilt covenant does not match the offer's swapPkScript \u2014 the server signing key has likely rotated since funding; pass swapAddress (the funded address) to pin the original key"
+    );
+  }
+  const contract = new arkade.ArkadeContract(client, program, args, keys);
+  const [vtxos, takerAddress] = 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 Error("no spendable VTXO at the swap address");
+  if (offer.offerAsset) {
+    const offered = offer.offerAsset.toString();
+    const deposited = amountOfAsset(vtxo.assets, offered);
+    if (deposited <= BigInt(0)) {
+      throw new Error(
+        `the deposit at the swap address carries no ${offered}, which this offer sells \u2014 filling it would pay wantAmount for nothing. The indexer may be behind, or the offer may not be backed by what it advertises`
+      );
+    }
+  }
+  const payout = payoutScript ?? ArkAddress.decode(takerAddress).pkScript;
+  const makerSats = wantedAssetId === void 0 ? offer.wantAmount : assetCarrierSats;
+  const fill = contract.functions.fulfill().from({ txid: vtxo.txid, vout: vtxo.vout, value: vtxo.value }).fund(fund).to(offer.makerPkScript, makerSats).change(payout);
+  const held = /* @__PURE__ */ new Map();
+  const hold = (vin, assets) => {
+    for (const a of assets ?? []) {
+      const amount = BigInt(a.amount);
+      if (amount <= BigInt(0)) continue;
+      held.set(a.assetId, [...held.get(a.assetId) ?? [], { vin, amount }]);
+    }
+  };
+  hold(0, vtxo.assets);
+  fund.forEach((coin, i) => hold(i + 1, coin.assets));
+  const outputsSum = makerSats;
+  const inputsSum = fund.reduce((s, c) => s + BigInt(c.value), BigInt(vtxo.value));
+  const hasPayoutOutput = inputsSum > outputsSum;
+  const emitWanted = () => {
+    if (wantedAssetId === void 0) return;
+    const supplying = held.get(wantedAssetId) ?? [];
+    const supplied = supplying.reduce((s, i) => s + i.amount, BigInt(0));
+    const outputs = [{ vout: 0, amount: offer.wantAmount }];
+    const surplus = supplied - offer.wantAmount;
+    if (surplus > BigInt(0)) {
+      if (!hasPayoutOutput) {
+        throw new Error(
+          `fillOffer has ${surplus} of ${wantedAssetId} to return but no payout output \u2014 fund with more sats than the maker's output takes`
+        );
+      }
+      outputs.push({ vout: 1, amount: surplus });
+    }
+    fill.withAsset({ assetId: wantedAssetId, inputs: supplying, outputs });
+    held.delete(wantedAssetId);
+  };
+  emitWanted();
+  for (const [assetId, inputs] of held) {
+    const amount = inputs.reduce((s, i) => s + i.amount, BigInt(0));
+    if (!hasPayoutOutput) {
+      throw new Error(
+        `fillOffer has ${amount} of ${assetId} to return but no payout output \u2014 fund with more sats than the maker's output takes`
+      );
+    }
+    fill.withAsset({ assetId, inputs, outputs: [{ vout: 1, amount }] });
+  }
+  const { txid } = await fill.send();
+  return txid;
+}
+var amountOfAsset = (assets, assetId) => {
+  let total = BigInt(0);
+  for (const a of assets ?? []) {
+    if (a.assetId === assetId) total += BigInt(a.amount);
+  }
+  return total;
+};
+
+// src/onchainHtlc.ts
+import { hex as hex3 } from "@scure/base";
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
 import { ripemd160 } from "@noble/hashes/legacy.js";
 import * as btc from "@scure/btc-signer";
 var ONCHAIN_ORDER_MARGIN_SECONDS = 2 * 60 * 60;
@@ -10,8 +779,8 @@ var LOCKTIME_THRESHOLD = 5e8;
 var ONCHAIN_SECONDS_PER_BLOCK = 600;
 var ONCHAIN_DUST_SATS = BigInt(330);
 var newPreimage = () => crypto.getRandomValues(new Uint8Array(32));
-var paymentHashOf = (preimage) => hex.encode(sha256(preimage));
-var h160FromPaymentHash = (paymentHash) => ripemd160(hex.decode(paymentHash));
+var paymentHashOf = (preimage) => hex3.encode(sha2562(preimage));
+var h160FromPaymentHash = (paymentHash) => ripemd160(hex3.decode(paymentHash));
 var L1_NETWORKS = {
   bitcoin: btc.NETWORK,
   testnet: btc.TEST_NETWORK,
@@ -63,7 +832,7 @@ function onchainHtlcScript(params, network) {
   );
   const controlBlockFor = (leaf) => {
     for (const [block, script] of payment.tapLeafScript ?? []) {
-      if (script.length - 1 === leaf.length && hex.encode(script.subarray(0, leaf.length)) === hex.encode(leaf)) {
+      if (script.length - 1 === leaf.length && hex3.encode(script.subarray(0, leaf.length)) === hex3.encode(leaf)) {
         return btc.TaprootControlBlock.encode(block);
       }
     }
@@ -156,13 +925,13 @@ var buildHtlcRefund = (input) => buildLeafSpend({
 function extractPreimage(txHex, paymentHash) {
   let raw;
   try {
-    raw = btc.RawTx.decode(hex.decode(txHex));
+    raw = btc.RawTx.decode(hex3.decode(txHex));
   } catch {
     return null;
   }
   for (const stack of raw.witnesses ?? []) {
     for (const item of stack) {
-      if (item.length === 32 && hex.encode(sha256(item)) === paymentHash) return item;
+      if (item.length === 32 && hex3.encode(sha2562(item)) === paymentHash) return item;
     }
   }
   return null;
@@ -207,7 +976,7 @@ async function classifyOnchainHtlc(chain, input) {
     );
     if (!spend) return { phase: "unfunded" };
     const preimage = extractPreimage(spend.txHex, input.htlc.paymentHash);
-    const txid = btc.Transaction.fromRaw(hex.decode(spend.txHex), {
+    const txid = btc.Transaction.fromRaw(hex3.decode(spend.txHex), {
       allowUnknownInputs: true,
       allowUnknownOutputs: true
     }).id;
@@ -222,11 +991,11 @@ async function classifyOnchainHtlc(chain, input) {
 
 // src/claimPacket.ts
 import { base64 } from "@scure/base";
-import { concatBytes } from "@scure/btc-signer/utils.js";
+import { concatBytes as concatBytes2 } from "@scure/btc-signer/utils.js";
 import { gcm } from "@noble/ciphers/aes.js";
 import { secp256k1 } from "@noble/curves/secp256k1.js";
 import { hkdf } from "@noble/hashes/hkdf.js";
-import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+import { sha256 as sha2563 } from "@noble/hashes/sha2.js";
 var HKDF_INFO = new TextEncoder().encode("covclaimd/preimage/v1");
 async function sealClaimPacket(input) {
   return sealWithEntropy(
@@ -242,7 +1011,7 @@ async function sealWithEntropy(input, ephemeralKey, nonce) {
   }
   const ephemeralPub = secp256k1.getPublicKey(ephemeralKey, true);
   const sharedX = secp256k1.getSharedSecret(ephemeralKey, input.covclaimdPubkey, true).subarray(1);
-  const key = hkdf(sha2562, sharedX, ephemeralPub, HKDF_INFO, 32);
+  const key = hkdf(sha2563, sharedX, ephemeralPub, HKDF_INFO, 32);
   if (nonce.length !== 12) throw new Error("nonce must be 12 bytes");
   const sealed = gcm(key, nonce, ephemeralPub).encrypt(input.preimage);
   const ciphertext = new Uint8Array(33 + 12 + sealed.length);
@@ -252,9 +1021,9 @@ async function sealWithEntropy(input, ephemeralKey, nonce) {
   return {
     ciphertext: base64.encode(ciphertext),
     packet: base64.encode(
-      concatBytes(
-        tlv(TLV_CIPHERTEXT, ciphertext),
-        tlv(TLV_COVCLAIMD_PUBKEY, input.covclaimdPubkey)
+      concatBytes2(
+        tlv2(TLV_CIPHERTEXT, ciphertext),
+        tlv2(TLV_COVCLAIMD_PUBKEY, input.covclaimdPubkey)
       )
     )
   };
@@ -265,8 +1034,8 @@ var TLV_COVCLAIMD_PUBKEY = 3;
 var COMPRESSED_PUBKEY_LENGTH = 33;
 var SEALED_CIPHERTEXT_LENGTH = 93;
 var CLAIM_PACKET_TYPE = 4;
-var tlv = (type, value) => Uint8Array.from([type, value.length >> 8 & 255, value.length & 255, ...value]);
-var appendArkadeScript = (body, arkadeScript) => Uint8Array.from([...body, ...tlv(TLV_ARKADE_SCRIPT, arkadeScript)]);
+var tlv2 = (type, value) => Uint8Array.from([type, value.length >> 8 & 255, value.length & 255, ...value]);
+var appendArkadeScript = (body, arkadeScript) => Uint8Array.from([...body, ...tlv2(TLV_ARKADE_SCRIPT, arkadeScript)]);
 var parseTlv = (data) => {
   let ciphertextLength;
   let hasArkadeScript = false;
@@ -315,9 +1084,9 @@ var claimPacketShape = (b64) => {
 };
 
 // src/lockupContract.ts
-import { hex as hex2 } from "@scure/base";
+import { hex as hex4 } from "@scure/base";
 import {
-  ArkAddress,
+  ArkAddress as ArkAddress2,
   VHTLCV2ContractHandler
 } from "@arkade-os/sdk";
 var SWAP_LOCKUP_CONTRACT_TYPE = "vhtlc-v2";
@@ -356,7 +1125,7 @@ async function registerLockupContract(contracts, script, address) {
     await contracts.createContract({
       type: SWAP_LOCKUP_CONTRACT_TYPE,
       params: VHTLCV2ContractHandler.serializeParams(script.options),
-      script: hex2.encode(script.pkScript),
+      script: hex4.encode(script.pkScript),
       address,
       label: SWAP_LOCKUP_CONTRACT_LABEL,
       metadata: { genericallySpendable: false, kind: SWAP_LOCKUP_CONTRACT_KIND }
@@ -366,21 +1135,21 @@ async function registerLockupContract(contracts, script, address) {
   }
 }
 async function lockupContractParams(contracts, lockupAddress) {
-  const script = hex2.encode(ArkAddress.decode(lockupAddress).pkScript);
+  const script = hex4.encode(ArkAddress2.decode(lockupAddress).pkScript);
   const [row] = await contracts.getContracts({ script });
   if (!row) throw new LockupContractMissing(lockupAddress, script);
   return row.params;
 }
 
 // src/rfq.ts
-import { hex as hex3 } from "@scure/base";
+import { hex as hex5 } from "@scure/base";
 import { ripemd160 as ripemd1602 } from "@noble/hashes/legacy.js";
 import {
-  ArkAddress as ArkAddress2,
-  RestArkProvider,
+  ArkAddress as ArkAddress3,
+  RestArkProvider as RestArkProvider2,
   VHTLC,
-  getNetwork,
-  resolveEmulatorPubkey,
+  getNetwork as getNetwork2,
+  resolveEmulatorPubkey as resolveEmulatorPubkey2,
   toXOnly
 } from "@arkade-os/sdk";
 import {
@@ -389,11 +1158,17 @@ import {
 } from "@arkade-os/sdk";
 var solverHex = (value, field) => {
   try {
-    return hex3.decode(value);
+    return hex5.decode(value);
   } catch {
     throw new Error(`solver sent malformed hex for ${field}`);
   }
 };
+var quoteSats = (value, field) => {
+  if (typeof value !== "number" || !Number.isSafeInteger(value)) {
+    throw new Error(`HTLC quote carries a non-sats ${field}: ${String(value)}`);
+  }
+  return value;
+};
 var ARKADE_BTC = "arkade:BTC";
 var LIGHTNING_BTC = "lightning:BTC";
 var ONCHAIN_BTC = "onchain:BTC";
@@ -489,7 +1264,7 @@ var AddressMismatch = class extends Error {
     this.quoted = quoted;
   }
 };
-var newRfqId = () => hex3.encode(crypto.getRandomValues(new Uint8Array(32)));
+var newRfqId = () => hex5.encode(crypto.getRandomValues(new Uint8Array(32)));
 var lightningSendRequest = (input) => ({
   v: 1,
   type: "rfq_request",
@@ -499,18 +1274,13 @@ var lightningSendRequest = (input) => ({
   profile: {
     invoice: input.invoice,
     refund_address: input.refundAddress,
-    client_refund_pubkey: hex3.encode(input.senderPubkey)
+    client_refund_pubkey: hex5.encode(input.senderPubkey)
   }
 });
 var arkadeSwapRequest = (input) => {
   if (!input.wantAsset && !input.offerAsset) {
     throw new Error(
-      "set exactly one of wantAsset (BTC->asset) or offerAsset (asset->BTC) \u2014 with neither set both legs are BTC, which is not a swap"
-    );
-  }
-  if (input.wantAsset && input.offerAsset) {
-    throw new Error(
-      "set exactly one of wantAsset (BTC->asset) or offerAsset (asset->BTC) \u2014 asset->asset is nameable on the wire but no solver quotes it yet"
+      "set at least one of wantAsset or offerAsset \u2014 with neither set both legs are BTC, which is not a swap"
     );
   }
   const pair = rfqPair(
@@ -523,16 +1293,59 @@ var arkadeSwapRequest = (input) => {
     type: "rfq_request",
     rfq_id: input.rfqId,
     pair,
-    amount_side: input.amountSide,
-    amount: input.amount,
-    // The pair is the only place the asset ids appear. Repeating them here
-    // would be a key the solver's `.strict()` profile schema does not
-    // declare, and an undeclared key is `unsupported_payload` — a refusal,
-    // not an ignored extra. Empty, not absent: `profile` is required on
-    // every other request shape this wire carries.
-    profile: {}
+    amount_side: input.amountSide ?? "from",
+    amount: canonicalAssetAmount(input.amount),
+    // The pair names the assets; the profile names the trader. Both are
+    // covenant parameters, and the solver's `.strict()` schema refuses
+    // anything else — an undeclared key is `unsupported_payload`.
+    profile: {
+      maker_pk_script: normalizeMakerPkScript(input.makerPkScript),
+      maker_public_key: normalizeMakerPublicKey(input.makerPublicKey)
+    }
   };
 };
+var canonicalAssetAmount = (amount) => {
+  if (typeof amount === "bigint") {
+    if (amount <= 0n) throw new Error(`amount must be positive, got ${amount}`);
+    return amount.toString();
+  }
+  if (typeof amount === "number") {
+    if (!Number.isSafeInteger(amount) || amount <= 0) {
+      throw new Error(`amount must be a positive safe integer, got ${amount}`);
+    }
+    return String(amount);
+  }
+  if (!/^(0|[1-9][0-9]*)$/.test(amount) || BigInt(amount) <= 0n) {
+    throw new Error(`amount must be a canonical decimal string of atomic units, got ${amount}`);
+  }
+  return amount;
+};
+var normalizeHexBytes = (value, expectedBytes, label) => {
+  if (value === void 0 || value === null) {
+    throw new Error(`${label} is required`);
+  }
+  const bytes = typeof value === "string" ? solverHex(value, label) : value;
+  if (!(bytes instanceof Uint8Array) || bytes.length !== expectedBytes) {
+    const got = bytes instanceof Uint8Array ? bytes.length : typeof bytes;
+    throw new Error(`${label} must be ${expectedBytes} bytes, got ${got}`);
+  }
+  return hex5.encode(bytes);
+};
+var normalizeMakerPkScript = (value) => {
+  const encoded = normalizeHexBytes(value, 34, "maker_pk_script");
+  if (!encoded.startsWith("5100") && !encoded.startsWith("5120")) {
+    throw new Error("maker_pk_script must be a taproot scriptPubKey (OP_1 <32-byte program>)");
+  }
+  return encoded;
+};
+var normalizeMakerPublicKey = (value) => {
+  const raw = typeof value === "string" ? value : hex5.encode(value);
+  const bytes = solverHex(raw, "maker_public_key");
+  if (bytes.length === 33) {
+    throw new Error("maker_public_key must be x-only (32 bytes), not compressed (33 bytes)");
+  }
+  return normalizeHexBytes(bytes, 32, "maker_public_key");
+};
 var MIN_HEADROOM_SECONDS = 90 * 60;
 var gateError = (reason, message) => {
   const error = new Error(message);
@@ -580,6 +1393,9 @@ var assertFundable = (input) => {
   }
   if (input.now >= input.quote.valid_until)
     fail("quote_expired", "quote expired \u2014 request a fresh one");
+  if (quoteSats(input.quote.from_amount, "from_amount") <= 0 || quoteSats(input.quote.to_amount, "to_amount") <= 0) {
+    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");
   }
@@ -609,13 +1425,12 @@ var assertFundable = (input) => {
         `maxFee.referenceRate must be a positive finite number, got ${referenceRate}`
       );
     }
-    const fee = sameAsset ? 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)
+    const fromSats = quoteSats(input.quote.from_amount, "from_amount");
+    const toSats = quoteSats(input.quote.to_amount, "to_amount");
+    const fee = sameAsset ? 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`);
     }
@@ -814,7 +1629,7 @@ function lightningSendVtxoScript(params) {
     sender: params.senderPubkey,
     receiver: params.solverPubkey,
     server: params.serverPubkey,
-    preimageHash: ripemd1602(hex3.decode(params.paymentHash)),
+    preimageHash: ripemd1602(hex5.decode(params.paymentHash)),
     refundLocktime: BigInt(params.refundLocktime),
     unilateralClaimDelay: seconds(params.claimDelay),
     unilateralRefundDelay: seconds(unilateralRefundDelay(params.claimDelay)),
@@ -834,7 +1649,7 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
   const secrets = await provisionRefundKey(wallet);
   const senderPubkey = secrets.pubkey;
   const refundAddress = secrets.address;
-  const info = await new RestArkProvider(arkServerUrl).getInfo();
+  const info = await new RestArkProvider2(arkServerUrl).getInfo();
   const quote = await transport.requestQuote(
     lightningSendRequest({ rfqId, invoice: params.invoice.raw, refundAddress, senderPubkey })
   );
@@ -857,27 +1672,27 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
   if (receiverPkScriptHex === void 0) {
     throw new Error("lightning-send quote is missing profile.receiver_pk_script");
   }
-  if (quote.to_amount !== params.invoice.amountSats) {
+  if (quoteSats(quote.to_amount, "to_amount") !== params.invoice.amountSats) {
     throw new Error(
       `quote to_amount ${quote.to_amount} does not match the invoice's ${params.invoice.amountSats}`
     );
   }
-  if (quote.from_amount < quote.to_amount) {
+  if (quoteSats(quote.from_amount, "from_amount") < quoteSats(quote.to_amount, "to_amount")) {
     throw new Error(
       `quote from_amount ${quote.from_amount} is below the invoice amount \u2014 a negative spread is not a quote`
     );
   }
-  const serverPubkey = toXOnly(hex3.decode(info.signerPubkey), "ark signer key");
-  const network = getNetwork(info.network);
+  const serverPubkey = toXOnly(hex5.decode(info.signerPubkey), "ark signer key");
+  const network = getNetwork2(info.network);
   const treeParams = {
-    solverPubkey: toXOnly(hex3.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: toXOnly(hex5.decode(quote.solver_pubkey), "solver key"),
     refundLocktime: quote.refund_locktime,
     serverPubkey,
     paymentHash: params.invoice.paymentHash,
     claimDelay,
     refundWithoutReceiverDelay,
     emulatorPubkey: toXOnly(
-      hex3.decode(resolveEmulatorPubkey(network, params.emulatorPubkey)),
+      hex5.decode(resolveEmulatorPubkey2(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
     senderPubkey,
@@ -908,7 +1723,7 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
     address,
     // What the lockup must carry: the quote's `from_amount` — the invoice
     // PLUS the corridor's fee, never the bare invoice amount.
-    fundAmount: quote.from_amount,
+    fundAmount: quoteSats(quote.from_amount, "from_amount"),
     swapPkScript: script.pkScript,
     script,
     refundAddress,
@@ -918,11 +1733,116 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
   };
 }
 var offerTermsFromQuote = (quote, assets) => {
-  if (Boolean(assets.wantAsset) === Boolean(assets.offerAsset)) {
-    throw new Error("set exactly one of wantAsset or offerAsset");
+  if (!assets.wantAsset && !assets.offerAsset) {
+    throw new Error("set at least one of wantAsset or offerAsset");
+  }
+  const wantAmount = BigInt(quote.to_amount);
+  if (assets.wantAsset) return { wantAmount, wantAsset: assets.wantAsset };
+  return { wantAmount, offerAsset: assets.offerAsset };
+};
+var verifyOfferAddress = (quote, derived) => {
+  const quotedAddress = quote.profile?.offer_address;
+  const quotedScript = quote.profile?.offer_pk_script;
+  const derivedScript = hex5.encode(derived.swapPkScript);
+  if (quotedAddress !== derived.address || quotedScript !== derivedScript) {
+    throw new AddressMismatch([derived.address], quotedAddress);
+  }
+  return derived;
+};
+var assertArkadeFundable = (input) => {
+  const now = input.now ?? Math.floor(Date.now() / 1e3);
+  if (!Number.isSafeInteger(input.quote.valid_until)) {
+    throw gateError("quote_expired", "quote carries no valid_until");
+  }
+  if (now >= input.quote.valid_until) {
+    throw gateError("quote_expired", `quote lapsed at ${input.quote.valid_until} (now ${now})`);
+  }
+  if (BigInt(input.quote.from_amount) <= 0n || BigInt(input.quote.to_amount) <= 0n) {
+    throw gateError("quote_expired", "quote carries a non-positive amount");
   }
-  return { wantAmount: BigInt(quote.to_amount), ...assets };
 };
+var quoteCarrierSats = (quote) => {
+  const published = quote.carrier_sats === void 0 ? 0n : BigInt(quote.carrier_sats);
+  return published > 0n ? published : ASSET_CARRIER_SATS;
+};
+async function requestArkadeSwap(wallet, arkServerUrl, transport, params) {
+  if (!params.wantAsset && !params.offerAsset) {
+    throw new Error("set at least one of wantAsset or offerAsset; BTC-to-BTC is not a swap");
+  }
+  const rfqId = params.rfqId ?? newRfqId();
+  const amountSide = params.amountSide ?? "from";
+  const [makerAddress, makerPublicKey] = await Promise.all([
+    wallet.getAddress(),
+    wallet.identity.xOnlyPublicKey()
+  ]);
+  const makerPkScript = ArkAddress3.decode(makerAddress).pkScript;
+  const pair = rfqPair(
+    params.offerAsset ? arkadeAssetLeg(params.offerAsset) : ARKADE_BTC,
+    params.wantAsset ? arkadeAssetLeg(params.wantAsset) : ARKADE_BTC
+  );
+  const quote = await transport.requestQuote(
+    arkadeSwapRequest({
+      rfqId,
+      ...params.offerAsset !== void 0 ? { offerAsset: params.offerAsset } : {},
+      ...params.wantAsset !== void 0 ? { wantAsset: params.wantAsset } : {},
+      amount: params.amount,
+      amountSide,
+      makerPkScript,
+      makerPublicKey
+    })
+  );
+  if (quote.pair !== pair) {
+    throw new Error(`solver quoted ${JSON.stringify(quote.pair)}, not the requested ${pair}`);
+  }
+  assertArkadeFundable({ quote, ...params.now !== void 0 ? { now: params.now } : {} });
+  const terms = offerTermsFromQuote(quote, {
+    ...params.offerAsset !== void 0 ? { offerAsset: params.offerAsset } : {},
+    ...params.wantAsset !== void 0 ? { wantAsset: params.wantAsset } : {}
+  });
+  const quoted = amountSide === "from" ? quote.from_amount : quote.to_amount;
+  if (BigInt(quoted).toString() !== canonicalAssetAmount(params.amount)) {
+    throw new Error(
+      `quote ${amountSide}_amount ${quoted} does not match the requested ${canonicalAssetAmount(params.amount)}`
+    );
+  }
+  if (params.maxFromAmount !== void 0) {
+    const cap = BigInt(canonicalAssetAmount(params.maxFromAmount));
+    if (BigInt(quote.from_amount) > cap) {
+      throw gateError(
+        "quote_amount_rejected",
+        `quote from_amount ${quote.from_amount} exceeds maxFromAmount ${cap}`
+      );
+    }
+  }
+  if (params.minToAmount !== void 0) {
+    const floorAmount = BigInt(canonicalAssetAmount(params.minToAmount));
+    if (BigInt(quote.to_amount) < floorAmount) {
+      throw gateError(
+        "quote_amount_rejected",
+        `quote to_amount ${quote.to_amount} is under minToAmount ${floorAmount}`
+      );
+    }
+  }
+  const offer = await createOffer(wallet, arkServerUrl, {
+    wantAmount: terms.wantAmount,
+    ...terms.wantAsset !== void 0 ? { wantAsset: terms.wantAsset } : {},
+    ...terms.offerAsset !== void 0 ? { offerAsset: terms.offerAsset } : {},
+    ...params.emulatorPubkey !== void 0 ? { emulatorPubkey: params.emulatorPubkey } : {}
+  });
+  verifyOfferAddress(quote, offer);
+  const fundAmount = BigInt(quote.from_amount);
+  return {
+    rfqId,
+    quote,
+    pair,
+    address: offer.address,
+    fundAmount,
+    carrierSats: params.offerAsset !== void 0 ? quoteCarrierSats(quote) : 0n,
+    swapPkScript: offer.swapPkScript,
+    offerHex: offer.offerHex,
+    extension: offer.extension
+  };
+}
 var l1NetworkFromArk = (network) => network === "bitcoin" ? "bitcoin" : network === "regtest" ? "regtest" : "testnet";
 var onchainSendRequest = (input) => ({
   v: 1,
@@ -933,9 +1853,9 @@ var onchainSendRequest = (input) => ({
   amount: input.amount,
   profile: {
     payment_hash: input.paymentHash,
-    payout_pubkey: hex3.encode(input.payoutPubkey),
+    payout_pubkey: hex5.encode(input.payoutPubkey),
     refund_address: input.refundAddress,
-    client_refund_pubkey: hex3.encode(input.senderPubkey)
+    client_refund_pubkey: hex5.encode(input.senderPubkey)
   }
 });
 var lightningReceiveRequest = (input) => ({
@@ -948,7 +1868,7 @@ var lightningReceiveRequest = (input) => ({
   profile: {
     payment_hash: input.paymentHash,
     payout_address: input.payoutAddress,
-    payout_pubkey: hex3.encode(input.payoutPubkey),
+    payout_pubkey: hex5.encode(input.payoutPubkey),
     ...input.claimPacket === void 0 ? {} : { claim_packet: input.claimPacket }
   }
 });
@@ -962,9 +1882,9 @@ var onchainReceiveRequest = (input) => ({
   profile: {
     payment_hash: input.paymentHash,
     ...input.claimPacket === void 0 ? {} : { claim_packet: input.claimPacket },
-    refund_pubkey: hex3.encode(input.refundPubkey),
+    refund_pubkey: hex5.encode(input.refundPubkey),
     payout_address: input.payoutAddress,
-    payout_pubkey: hex3.encode(input.payoutPubkey)
+    payout_pubkey: hex5.encode(input.payoutPubkey)
   }
 });
 function deriveOnchainSend(input) {
@@ -980,7 +1900,7 @@ function deriveOnchainSend(input) {
     throw new Error("onchain-send quote is missing a binding field");
   }
   const treeParams = {
-    solverPubkey: toXOnly(hex3.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: toXOnly(hex5.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -988,7 +1908,7 @@ function deriveOnchainSend(input) {
     emulatorPubkey: input.emulatorPubkey,
     senderPubkey: input.senderPubkey,
     receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
-    refundPkScript: ArkAddress2.decode(input.refundAddress).pkScript
+    refundPkScript: ArkAddress3.decode(input.refundAddress).pkScript
   };
   const { script, address } = matchQuotedLockup(
     quote,
@@ -999,7 +1919,7 @@ function deriveOnchainSend(input) {
   const htlcParams = {
     paymentHash: input.paymentHash,
     claimKey: input.payoutPubkey,
-    refundKey: toXOnly(hex3.decode(htlcPubkey), "solver L1 htlc key"),
+    refundKey: toXOnly(hex5.decode(htlcPubkey), "solver L1 htlc key"),
     refundLocktime: htlcLocktime
   };
   const htlc = onchainHtlcScript(htlcParams, input.l1Network);
@@ -1013,7 +1933,8 @@ function deriveOnchainSend(input) {
     l1Network: input.l1Network,
     refundLocktime,
     htlcLocktime,
-    minConfirmations
+    minConfirmations,
+    expectedAmount: quoteSats(quote.to_amount, "to_amount")
   };
 }
 async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
@@ -1024,10 +1945,10 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
       "[swap] this swap's preimage cannot be re-derived from the seed and MUST be persisted with the record before funding"
     );
   }
-  const paymentHash = hex3.encode(secrets.paymentHash);
+  const paymentHash = hex5.encode(secrets.paymentHash);
   const senderPubkey = secrets.pubkey;
   const [info, refundAddress] = await Promise.all([
-    new RestArkProvider(arkServerUrl).getInfo(),
+    new RestArkProvider2(arkServerUrl).getInfo(),
     wallet.getAddress()
   ]);
   const quote = await transport.requestQuote(
@@ -1042,14 +1963,14 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
-  const network = getNetwork(info.network);
+  const network = getNetwork2(info.network);
   const derived = deriveOnchainSend({
     quote,
     paymentHash,
     payoutPubkey: params.payoutPubkey,
-    serverPubkey: toXOnly(hex3.decode(info.signerPubkey), "ark signer key"),
+    serverPubkey: toXOnly(hex5.decode(info.signerPubkey), "ark signer key"),
     emulatorPubkey: toXOnly(
-      hex3.decode(resolveEmulatorPubkey(network, params.emulatorPubkey)),
+      hex5.decode(resolveEmulatorPubkey2(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
@@ -1076,7 +1997,8 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
     rfqId,
     quote,
     address: derived.address,
-    fundAmount: quote.from_amount,
+    fundAmount: quoteSats(quote.from_amount, "from_amount"),
+    expectedAmount: quoteSats(quote.to_amount, "to_amount"),
     swapPkScript: derived.swapPkScript,
     script: derived.script,
     refundAddress,
@@ -1089,7 +2011,7 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
   };
 }
 var assertQuotedAmount = (quote, amountSide, amount) => {
-  const quoted = amountSide === "from" ? quote.from_amount : quote.to_amount;
+  const quoted = amountSide === "from" ? quoteSats(quote.from_amount, "from_amount") : quoteSats(quote.to_amount, "to_amount");
   if (quoted !== amount) {
     throw new Error(
       `quote ${amountSide === "from" ? "from_amount" : "to_amount"} ${quoted} does not match the requested ${amount} \u2014 not this trade's quote`
@@ -1148,7 +2070,7 @@ var assertReceivable = (input) => {
       `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) {
+  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`
@@ -1164,7 +2086,7 @@ function receiveVtxoScript(params) {
     sender: params.solverPubkey,
     receiver: params.payoutPubkey,
     server: params.serverPubkey,
-    preimageHash: ripemd1602(hex3.decode(params.paymentHash)),
+    preimageHash: ripemd1602(hex5.decode(params.paymentHash)),
     refundLocktime: BigInt(params.refundLocktime),
     unilateralClaimDelay: seconds(params.claimDelay),
     unilateralRefundDelay: seconds(unilateralRefundDelay(params.claimDelay)),
@@ -1189,7 +2111,7 @@ function deriveLightningReceive(input) {
     throw new Error("lightning-receive quote is missing a binding field");
   }
   const treeParams = {
-    solverPubkey: toXOnly(hex3.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: toXOnly(hex5.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -1197,7 +2119,7 @@ function deriveLightningReceive(input) {
     emulatorPubkey: input.emulatorPubkey,
     solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
     payoutPubkey: input.payoutPubkey,
-    payoutPkScript: ArkAddress2.decode(input.payoutAddress).pkScript
+    payoutPkScript: ArkAddress3.decode(input.payoutAddress).pkScript
   };
   const matched = matchQuotedLockup(
     quote,
@@ -1226,10 +2148,10 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
     );
   }
   const preimage = secrets.preimage;
-  const paymentHash = hex3.encode(secrets.paymentHash);
+  const paymentHash = hex5.encode(secrets.paymentHash);
   const payoutPubkey = secrets.pubkey;
   const [info, payoutAddress] = await Promise.all([
-    new RestArkProvider(arkServerUrl).getInfo(),
+    new RestArkProvider2(arkServerUrl).getInfo(),
     wallet.getAddress()
   ]);
   const claimPacket = params.covclaimdPubkey ? await sealClaimPacket({
@@ -1248,15 +2170,15 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
-  const network = getNetwork(info.network);
+  const network = getNetwork2(info.network);
   const derived = deriveLightningReceive({
     quote,
     paymentHash,
     payoutPubkey,
     payoutAddress,
-    serverPubkey: toXOnly(hex3.decode(info.signerPubkey), "ark signer key"),
+    serverPubkey: toXOnly(hex5.decode(info.signerPubkey), "ark signer key"),
     emulatorPubkey: toXOnly(
-      hex3.decode(resolveEmulatorPubkey(network, params.emulatorPubkey)),
+      hex5.decode(resolveEmulatorPubkey2(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
@@ -1279,8 +2201,8 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
     rfqId,
     quote,
     invoice: derived.invoice,
-    payAmount: quote.from_amount,
-    expectedAmount: quote.to_amount,
+    payAmount: quoteSats(quote.from_amount, "from_amount"),
+    expectedAmount: quoteSats(quote.to_amount, "to_amount"),
     invoiceExpiresAt: payDeadline,
     address: derived.address,
     swapPkScript: derived.swapPkScript,
@@ -1304,7 +2226,7 @@ function deriveOnchainReceive(input) {
     throw new Error("onchain-receive quote is missing a binding field");
   }
   const treeParams = {
-    solverPubkey: toXOnly(hex3.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: toXOnly(hex5.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -1312,7 +2234,7 @@ function deriveOnchainReceive(input) {
     emulatorPubkey: input.emulatorPubkey,
     solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
     payoutPubkey: input.payoutPubkey,
-    payoutPkScript: ArkAddress2.decode(input.payoutAddress).pkScript
+    payoutPkScript: ArkAddress3.decode(input.payoutAddress).pkScript
   };
   const { script, address } = matchQuotedLockup(
     quote,
@@ -1323,7 +2245,7 @@ function deriveOnchainReceive(input) {
   const htlc = onchainHtlcScript(
     {
       paymentHash: input.paymentHash,
-      claimKey: toXOnly(hex3.decode(claimPubkey), "solver L1 claim key"),
+      claimKey: toXOnly(hex5.decode(claimPubkey), "solver L1 claim key"),
       refundKey: input.refundPubkey,
       refundLocktime: htlcLocktime
     },
@@ -1349,10 +2271,10 @@ async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
     );
   }
   const preimage = secrets.preimage;
-  const paymentHash = hex3.encode(secrets.paymentHash);
+  const paymentHash = hex5.encode(secrets.paymentHash);
   const payoutPubkey = secrets.pubkey;
   const [info, payoutAddress] = await Promise.all([
-    new RestArkProvider(arkServerUrl).getInfo(),
+    new RestArkProvider2(arkServerUrl).getInfo(),
     wallet.getAddress()
   ]);
   const claimPacket = params.covclaimdPubkey ? await sealClaimPacket({
@@ -1372,16 +2294,16 @@ async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
-  const network = getNetwork(info.network);
+  const network = getNetwork2(info.network);
   const derived = deriveOnchainReceive({
     quote,
     paymentHash,
     payoutPubkey,
     payoutAddress,
     refundPubkey: params.refundPubkey,
-    serverPubkey: toXOnly(hex3.decode(info.signerPubkey), "ark signer key"),
+    serverPubkey: toXOnly(hex5.decode(info.signerPubkey), "ark signer key"),
     emulatorPubkey: toXOnly(
-      hex3.decode(resolveEmulatorPubkey(network, params.emulatorPubkey)),
+      hex5.decode(resolveEmulatorPubkey2(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
@@ -1406,8 +2328,8 @@ async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
     rfqId,
     quote,
     address: derived.address,
-    fundAmount: quote.from_amount,
-    expectedAmount: quote.to_amount,
+    fundAmount: quoteSats(quote.from_amount, "from_amount"),
+    expectedAmount: quoteSats(quote.to_amount, "to_amount"),
     swapPkScript: derived.swapPkScript,
     script: derived.script,
     htlc: derived.htlc,
@@ -1418,6 +2340,29 @@ async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
 }
 
 export {
+  RETIRABLE,
+  retireOfferContract,
+  retireSettledOfferContracts,
+  BTC_ASSET_ID,
+  getAssetSwapsOrThrow,
+  getAssetSwaps,
+  addAssetSwap,
+  updateAssetSwap,
+  updateAssetSwapBestEffort,
+  swapSecretsToRecord,
+  PreimageNotRecoverableError,
+  preimageForSwapRecord,
+  swapPrograms,
+  offerVtxoScript,
+  OFFER_PACKET_TYPE,
+  encodeOffer,
+  decodeOffer,
+  OFFER_CONTRACT_KIND,
+  restoreOfferCoverage,
+  createOffer,
+  cancelOffer,
+  ASSET_CARRIER_SATS,
+  fillOffer,
   ONCHAIN_ORDER_MARGIN_SECONDS,
   ONCHAIN_CLAIM_MARGIN_SECONDS,
   MAX_MIN_CONFIRMATIONS,
@@ -1465,6 +2410,9 @@ export {
   newRfqId,
   lightningSendRequest,
   arkadeSwapRequest,
+  canonicalAssetAmount,
+  normalizeMakerPkScript,
+  normalizeMakerPublicKey,
   MIN_HEADROOM_SECONDS,
   verifyLockupAddress,
   assertFundable,
@@ -1479,6 +2427,9 @@ export {
   lightningSendVtxoScript,
   requestLightningSend,
   offerTermsFromQuote,
+  verifyOfferAddress,
+  assertArkadeFundable,
+  requestArkadeSwap,
   onchainSendRequest,
   lightningReceiveRequest,
   onchainReceiveRequest,