@arkade-os/swap 0.0.1

package/dist/chunk-C5P7R7JT.js

@@ -0,0 +1,1363 @@
+// src/onchainHtlc.ts
+import { hex } from "@scure/base";
+import { sha256 } 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;
+var ONCHAIN_CLAIM_MARGIN_SECONDS = 90 * 60;
+var MAX_MIN_CONFIRMATIONS = 6;
+var ONCHAIN_SECONDS_PER_BLOCK = 600;
+var ONCHAIN_DUST_SATS = BigInt(330);
+var newPreimage = () => crypto.getRandomValues(new Uint8Array(32));
+var paymentHashOf = (preimage) => hex.encode(sha256(preimage));
+var h160FromPaymentHash = (paymentHash) => ripemd160(hex.decode(paymentHash));
+var L1_NETWORKS = {
+  bitcoin: btc.NETWORK,
+  testnet: btc.TEST_NETWORK,
+  regtest: { ...btc.TEST_NETWORK, bech32: "bcrt" }
+};
+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}`
+    );
+  }
+  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 && hex.encode(script.subarray(0, leaf.length)) === 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
+  };
+}
+var 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 };
+};
+var 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
+  });
+};
+var buildHtlcRefund = (input) => buildLeafSpend({
+  htlc: input.htlc,
+  utxo: input.utxo,
+  leaf: input.htlc.leaves.refund,
+  controlBlock: input.htlc.controlBlocks.refund,
+  stackAboveSig: [],
+  payoutPkScript: input.payoutPkScript,
+  feeRateSatVb: input.feeRateSatVb,
+  sign: input.sign,
+  lockTime: input.htlc.refundLocktime,
+  // any value below 0xffffffff enables nLockTime enforcement
+  sequence: 4294967294
+});
+function extractPreimage(txHex, paymentHash) {
+  let raw;
+  try {
+    raw = btc.RawTx.decode(hex.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;
+    }
+  }
+  return null;
+}
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function awaitOnchainFill(chain, htlc, minConfirmations, options = {}) {
+  const pollMs = options.pollMs ?? 5e3;
+  for (; ; ) {
+    const utxos = await chain.getScriptUtxos(htlc.pkScript);
+    const eligible = utxos.filter((u) => u.confirmations >= minConfirmations).sort((a, b) => b.amount > a.amount ? 1 : -1);
+    if (eligible[0]) return eligible[0];
+    if (options.deadline !== void 0 && Date.now() / 1e3 >= options.deadline) {
+      const error = new Error("HTLC was not filled before the deadline");
+      error.reason = "fill_timeout";
+      throw error;
+    }
+    await sleep(pollMs);
+  }
+}
+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);
+    if (!spend) return { phase: "unfunded" };
+    const preimage = extractPreimage(spend.txHex, input.htlc.paymentHash);
+    const txid = btc.Transaction.fromRaw(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 };
+}
+
+// src/secrets.ts
+import { hex as hex2 } from "@scure/base";
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+import { randomBytes } from "@noble/hashes/utils.js";
+import { schnorr } from "@noble/curves/secp256k1.js";
+import {
+  SingleKey,
+  isHDAllocationCapable,
+  isHDWalletCapable
+} from "@arkade-os/sdk";
+var RFQ_PREIMAGE_TAG = "Arkade-RFQ-Preimage-v1";
+function buildPreimageMessage(xonly, index) {
+  if (xonly.length !== 32) {
+    throw new Error(`x-only pubkey must be 32 bytes, got ${xonly.length}`);
+  }
+  if (!Number.isInteger(index) || index < 0 || index > 4294967295) {
+    throw new Error(`index must be a u32, got ${index}`);
+  }
+  const tag = new TextEncoder().encode(RFQ_PREIMAGE_TAG);
+  const message = new Uint8Array(tag.length + 32 + 4);
+  message.set(tag, 0);
+  message.set(xonly, tag.length);
+  new DataView(message.buffer).setUint32(tag.length + 32, index, true);
+  return message;
+}
+var PREIMAGE_INDEX = 0;
+async function deriveSwapSecrets(wallet) {
+  if (!isHDAllocationCapable(wallet)) return void 0;
+  const signingDescriptor = await wallet.getNextSigningDescriptor();
+  if (!signingDescriptor) return void 0;
+  return { derivable: true, signingDescriptor };
+}
+function randomSwapSecrets(opts = {}) {
+  if (opts.preimage instanceof Uint8Array && opts.preimage.length !== 32) {
+    throw new Error(`preimage must be 32 bytes, got ${opts.preimage.length}`);
+  }
+  const preimage = opts.preimage instanceof Uint8Array ? opts.preimage : opts.preimage ? randomBytes(32) : void 0;
+  return {
+    derivable: false,
+    senderPrivateKey: schnorr.utils.randomSecretKey(),
+    ...preimage ? { preimage } : {}
+  };
+}
+function rfqSecretsToRecord(secrets) {
+  if (secrets.derivable) {
+    return {
+      signingDescriptor: secrets.signingDescriptor,
+      ...secrets.preimage ? { preimageHex: hex2.encode(secrets.preimage) } : {}
+    };
+  }
+  return {
+    fallbackSecrets: {
+      version: 1,
+      type: "stored",
+      senderPrivateKeyHex: hex2.encode(secrets.senderPrivateKey),
+      ...secrets.preimage ? { preimageHex: hex2.encode(secrets.preimage) } : {}
+    }
+  };
+}
+function rfqSecretsOfRecord(record) {
+  if (record.signingDescriptor) {
+    return {
+      derivable: true,
+      signingDescriptor: record.signingDescriptor,
+      ...record.preimageHex ? { preimage: decodeHex32(record.preimageHex, "preimageHex") } : {}
+    };
+  }
+  const fallback = record.fallbackSecrets;
+  if (!fallback) return void 0;
+  if (fallback.version !== 1 || fallback.type !== "stored") {
+    throw new Error("unsupported RFQ fallback secrets record");
+  }
+  return {
+    derivable: false,
+    senderPrivateKey: decodeHex32(fallback.senderPrivateKeyHex, "senderPrivateKeyHex"),
+    ...fallback.preimageHex ? { preimage: decodeHex32(fallback.preimageHex, "preimageHex") } : {}
+  };
+}
+function decodeHex32(value, label) {
+  const bytes = hex2.decode(value);
+  if (bytes.length !== 32) {
+    throw new Error(label + " must be 32 bytes, got " + bytes.length);
+  }
+  return bytes;
+}
+async function adoptSwapDescriptor(wallet, signingDescriptor) {
+  if (!isHDAllocationCapable(wallet)) return;
+  await wallet.advanceSigningDescriptorWatermark(signingDescriptor);
+}
+var RefundNotLocallyPossibleError = class extends Error {
+  constructor(reason, message, options) {
+    super(message, options);
+    this.reason = reason;
+  }
+  reason;
+  name = "RefundNotLocallyPossibleError";
+};
+async function senderIdentityForRfqSecrets(wallet, secrets) {
+  if (!secrets.derivable) return SingleKey.fromPrivateKey(secrets.senderPrivateKey);
+  const signer = isHDWalletCapable(wallet) ? await wallet.signerForDescriptor(secrets.signingDescriptor) : void 0;
+  if (!signer || !isDeterministicSigner(signer)) {
+    throw new RefundNotLocallyPossibleError(
+      "foreign-descriptor",
+      `this wallet cannot derive ${secrets.signingDescriptor}; the swap was created on another wallet`
+    );
+  }
+  return signer;
+}
+async function senderIdentityForSwapRecord(wallet, record) {
+  let secrets;
+  try {
+    secrets = rfqSecretsOfRecord(record);
+  } catch (error) {
+    throw new RefundNotLocallyPossibleError(
+      "unreadable-secrets",
+      error instanceof Error ? error.message : String(error),
+      // the record's own diagnosis, kept for a caller that wants more
+      // than the message
+      { cause: error }
+    );
+  }
+  if (!secrets) {
+    throw new RefundNotLocallyPossibleError(
+      "no-secrets",
+      "this swap record carries no signing descriptor and no fallback secrets"
+    );
+  }
+  return senderIdentityForRfqSecrets(wallet, secrets);
+}
+async function senderPubkeyForRfqSecrets(wallet, secrets) {
+  if (!secrets.derivable) return schnorr.getPublicKey(secrets.senderPrivateKey);
+  return (await senderIdentityForRfqSecrets(wallet, secrets)).xOnlyPublicKey();
+}
+function isDeterministicSigner(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return typeof v.signSchnorrDeterministic === "function" && typeof v.xOnlyPublicKey === "function";
+}
+async function derivePreimage(signer) {
+  const xonly = await signer.xOnlyPublicKey();
+  const message = buildPreimageMessage(xonly, PREIMAGE_INDEX);
+  return sha2562(await signer.signSchnorrDeterministic(sha2562(message)));
+}
+async function preimageForRfqSecrets(wallet, secrets) {
+  if (!secrets.derivable) {
+    if (!secrets.preimage) throw new Error("this swap carries no stored preimage");
+    return secrets.preimage;
+  }
+  if (secrets.preimage) return secrets.preimage;
+  const signer = await senderIdentityForRfqSecrets(wallet, secrets);
+  if (!isDeterministicSigner(signer)) {
+    throw new Error(
+      `wallet cannot sign deterministically for ${secrets.signingDescriptor}; its preimage is not derivable`
+    );
+  }
+  try {
+    return await derivePreimage(signer);
+  } catch (cause) {
+    throw new Error(
+      `wallet cannot sign deterministically for ${secrets.signingDescriptor}; its preimage is not derivable`,
+      { cause }
+    );
+  }
+}
+
+// src/claimPacket.ts
+import { base64 } from "@scure/base";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { hkdf } from "@noble/hashes/hkdf.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(
+    input,
+    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");
+  }
+  const ephemeralPub = secp256k1.getPublicKey(ephemeralKey, true);
+  const sharedX = secp256k1.getSharedSecret(ephemeralKey, input.covclaimdPubkey, true).subarray(1);
+  const key = hkdf(sha2563, sharedX, ephemeralPub, HKDF_INFO, 32);
+  if (nonce.length !== 12) throw new Error("nonce must be 12 bytes");
+  const aesKey = await crypto.subtle.importKey("raw", key, "AES-GCM", false, [
+    "encrypt"
+  ]);
+  const sealed = new Uint8Array(
+    await crypto.subtle.encrypt(
+      {
+        name: "AES-GCM",
+        iv: nonce,
+        additionalData: ephemeralPub
+      },
+      aesKey,
+      input.preimage
+    )
+  );
+  const packet = new Uint8Array(33 + 12 + sealed.length);
+  packet.set(ephemeralPub, 0);
+  packet.set(nonce, 33);
+  packet.set(sealed, 45);
+  return { ciphertext: base64.encode(packet) };
+}
+
+// src/lockupContract.ts
+import { hex as hex3 } from "@scure/base";
+import { VHTLCV2ContractHandler } from "@arkade-os/sdk";
+var SWAP_LOCKUP_CONTRACT_TYPE = "vhtlc-v2";
+var SWAP_LOCKUP_CONTRACT_LABEL = "Arkade RFQ swap lockup";
+var SWAP_LOCKUP_CONTRACT_KIND = "rfq-swap-lockup";
+var 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;
+  }
+};
+async function registerLockupContract(contracts, script, address) {
+  try {
+    await contracts.createContract({
+      type: SWAP_LOCKUP_CONTRACT_TYPE,
+      params: VHTLCV2ContractHandler.serializeParams(script.options),
+      script: hex3.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/rfq.ts
+import { hex as hex4 } from "@scure/base";
+import { ripemd160 as ripemd1602 } from "@noble/hashes/legacy.js";
+import {
+  ArkAddress,
+  RestArkProvider,
+  VHTLC,
+  getNetwork
+} from "@arkade-os/sdk";
+var xOnly = (key, label) => {
+  if (key.length === 32) return key;
+  if (key.length !== 33 || key[0] !== 2 && key[0] !== 3) {
+    throw new Error(`${label} is not a compressed or x-only public key`);
+  }
+  return key.slice(1);
+};
+var solverHex = (value, field) => {
+  try {
+    return hex4.decode(value);
+  } catch {
+    throw new Error(`solver sent malformed hex for ${field}`);
+  }
+};
+var ARKADE_BTC = "arkade:BTC";
+var ARKADE_ASSET = "arkade:ASSET";
+var LIGHTNING_BTC = "lightning:BTC";
+var ONCHAIN_BTC = "onchain:BTC";
+var rfqPair = (from, to) => `${from}->${to}`;
+var LIGHTNING_SEND_PAIR = rfqPair(ARKADE_BTC, LIGHTNING_BTC);
+var LIGHTNING_RECEIVE_PAIR = rfqPair(LIGHTNING_BTC, ARKADE_BTC);
+var ONCHAIN_SEND_PAIR = rfqPair(ARKADE_BTC, ONCHAIN_BTC);
+var ONCHAIN_RECEIVE_PAIR = rfqPair(ONCHAIN_BTC, ARKADE_BTC);
+var RFQ_TERMINAL_STATES = ["settled", "refused", "expired", "refunded", "stuck"];
+var SwapRefusal = class extends Error {
+  reason;
+  rfqId;
+  constructor(reason, rfqId) {
+    super(`solver refused: ${reason}`);
+    this.name = "SwapRefusal";
+    this.reason = reason;
+    this.rfqId = rfqId;
+  }
+};
+var 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;
+  }
+};
+var newRfqId = () => hex4.encode(crypto.getRandomValues(new Uint8Array(32)));
+var 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: hex4.encode(input.senderPubkey)
+  }
+});
+var arkadeSwapRequest = (input) => {
+  if (Boolean(input.wantAsset) === Boolean(input.offerAsset)) {
+    throw new Error("set exactly one of wantAsset (BTC->asset) or offerAsset (asset->BTC)");
+  }
+  return {
+    v: 1,
+    type: "rfq_request",
+    rfq_id: input.rfqId,
+    pair: rfqPair(
+      input.offerAsset ? ARKADE_ASSET : ARKADE_BTC,
+      input.wantAsset ? ARKADE_ASSET : ARKADE_BTC
+    ),
+    amount_side: input.amountSide,
+    amount: input.amount,
+    profile: {
+      ...input.offerAsset && { offer_asset: hex4.encode(input.offerAsset.serialize()) },
+      ...input.wantAsset && { want_asset: hex4.encode(input.wantAsset.serialize()) }
+    }
+  };
+};
+var MIN_HEADROOM_SECONDS = 90 * 60;
+var gateError = (reason, message) => {
+  const error = new Error(message);
+  error.reason = reason;
+  return error;
+};
+var assertFinite = (value, reason, label) => {
+  if (value !== void 0 && !Number.isFinite(value)) {
+    throw gateError(reason, `${label} is not a finite number (${String(value)})`);
+  }
+};
+var verifyLockupAddress = (quote, derivedAddress) => {
+  const quoted = quote.profile?.lockup_address;
+  if (derivedAddress !== quoted) throw new AddressMismatch(derivedAddress, quoted);
+  return derivedAddress;
+};
+var assertFundable = (input) => {
+  const fail = (reason, message) => {
+    throw gateError(reason, message);
+  };
+  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.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"
+        );
+      }
+    }
+  }
+};
+var expectQuote = (payload, rfqId) => {
+  const p = payload;
+  if (p?.type === "rfq_refusal") throw new SwapRefusal(p.reason ?? "unknown", p.rfq_id ?? rfqId);
+  if (p?.type !== "rfq_quote" || p.rfq_id !== rfqId) {
+    throw new Error(`unexpected reply: ${p?.type ?? "no payload"}`);
+  }
+  return payload;
+};
+var httpTransport = (baseUrl, options = {}) => {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const readJson = async (response, what) => {
+    const body = await response.text();
+    try {
+      return JSON.parse(body);
+    } catch {
+      throw new Error(
+        `${what} returned HTTP ${response.status} with a non-JSON body: ${body.slice(0, 200)}`
+      );
+    }
+  };
+  return {
+    async requestQuote(payload) {
+      const response = await fetchImpl(`${baseUrl}/v1/swap`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(payload)
+      });
+      return expectQuote(await readJson(response, "quote request"), String(payload.rfq_id));
+    },
+    async status(rfqId) {
+      const response = await fetchImpl(`${baseUrl}/v1/rfq/${rfqId}`, { method: "GET" });
+      if (response.status === 404) return null;
+      const payload = await readJson(response, "status request");
+      return payload?.type === "rfq_status" ? payload : null;
+    },
+    async close() {
+    }
+  };
+};
+var relayTransport = (relayUrl, options) => {
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const Ctor = options.WebSocketCtor ?? WebSocket;
+  const pending = /* @__PURE__ */ new Map();
+  let sequence = 0;
+  const socketReady = new Promise((resolve, reject) => {
+    const ws = new Ctor(relayUrl);
+    ws.addEventListener("open", () => {
+      ws.send(
+        JSON.stringify({
+          op: "sub",
+          id: "s1",
+          filter: { recipient: options.clientPubkey }
+        })
+      );
+      resolve(ws);
+    });
+    ws.addEventListener("error", () => reject(new Error("relay connection failed")));
+    ws.addEventListener("message", (event) => {
+      let frame;
+      try {
+        frame = JSON.parse(String(event.data));
+      } catch {
+        return;
+      }
+      if (frame.op !== "event") return;
+      const payload = frame.event?.payload;
+      const rfqId = payload?.rfq_id;
+      const settle = rfqId !== void 0 ? pending.get(rfqId) : void 0;
+      if (settle && rfqId !== void 0) {
+        pending.delete(rfqId);
+        settle(payload);
+      }
+    });
+  });
+  const roundTrip = async (payload, rfqId) => {
+    const ws = await socketReady;
+    const reply = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pending.delete(rfqId);
+        reject(new Error(`no reply within ${timeoutMs}ms`));
+      }, timeoutMs);
+      pending.set(rfqId, (p) => {
+        clearTimeout(timer);
+        resolve(p);
+      });
+    });
+    ws.send(
+      JSON.stringify({
+        op: "event",
+        event: {
+          id: `${options.clientPubkey}:${sequence += 1}`,
+          author: options.clientPubkey,
+          recipient: options.solverPubkey,
+          createdAtMs: Date.now(),
+          payload
+        }
+      })
+    );
+    return reply;
+  };
+  return {
+    async requestQuote(payload) {
+      return expectQuote(
+        await roundTrip(payload, String(payload.rfq_id)),
+        String(payload.rfq_id)
+      );
+    },
+    async status(rfqId) {
+      const payload = await roundTrip(
+        { v: 1, type: "rfq_status_request", rfq_id: rfqId },
+        rfqId
+      );
+      return payload?.type === "rfq_status" ? payload : null;
+    },
+    async close() {
+      try {
+        (await socketReady).close();
+      } catch {
+      }
+    }
+  };
+};
+var SEQUENCE_GRANULARITY_SECONDS = 512;
+var unilateralClaimDelay = (serverExitDelaySeconds) => {
+  if (!Number.isFinite(serverExitDelaySeconds) || serverExitDelaySeconds < SEQUENCE_GRANULARITY_SECONDS) {
+    throw new Error(
+      `server exit delay must be at least ${SEQUENCE_GRANULARITY_SECONDS}s of seconds, got ${serverExitDelaySeconds}`
+    );
+  }
+  if (serverExitDelaySeconds > (65535 - 2) * SEQUENCE_GRANULARITY_SECONDS) {
+    throw new Error(
+      `server exit delay ${serverExitDelaySeconds}s exceeds what BIP68 can encode once the two refund tiers are stacked above it`
+    );
+  }
+  return Math.ceil(serverExitDelaySeconds / SEQUENCE_GRANULARITY_SECONDS) * SEQUENCE_GRANULARITY_SECONDS;
+};
+var unilateralRefundDelay = (claimDelay) => claimDelay + SEQUENCE_GRANULARITY_SECONDS;
+var unilateralRefundWithoutReceiverDelay = (claimDelay) => claimDelay + 2 * SEQUENCE_GRANULARITY_SECONDS;
+function lightningSendVtxoScript(params) {
+  const seconds = (value) => ({
+    type: "seconds",
+    value: BigInt(value)
+  });
+  return new VHTLC.ScriptV2({
+    sender: params.senderPubkey,
+    receiver: params.solverPubkey,
+    server: params.serverPubkey,
+    preimageHash: ripemd1602(hex4.decode(params.paymentHash)),
+    refundLocktime: BigInt(params.refundLocktime),
+    unilateralClaimDelay: seconds(params.claimDelay),
+    unilateralRefundDelay: seconds(unilateralRefundDelay(params.claimDelay)),
+    unilateralRefundWithoutReceiverDelay: seconds(
+      unilateralRefundWithoutReceiverDelay(params.claimDelay)
+    ),
+    nonInteractiveClaim: {
+      receiverPkScript: params.receiverPkScript,
+      emulatorPubkey: params.emulatorPubkey
+    },
+    nonInteractiveRefund: {
+      senderPkScript: params.refundPkScript,
+      emulatorPubkey: params.emulatorPubkey
+    }
+  });
+}
+async function requestLightningSend(wallet, arkServerUrl, emulatorPubkey, transport, params) {
+  const rfqId = params.rfqId ?? newRfqId();
+  const secrets = await deriveSwapSecrets(wallet) ?? randomSwapSecrets();
+  if (!secrets.derivable) {
+    console.warn(
+      "[swap] wallet cannot allocate an HD descriptor: the sender key is random and MUST be persisted before funding"
+    );
+  }
+  const senderPubkey = await senderPubkeyForRfqSecrets(wallet, secrets);
+  const [info, refundAddress] = await Promise.all([
+    new RestArkProvider(arkServerUrl).getInfo(),
+    wallet.getAddress()
+  ]);
+  const quote = await transport.requestQuote(
+    lightningSendRequest({ rfqId, invoice: params.invoice.raw, refundAddress, senderPubkey })
+  );
+  if (quote.refund_locktime === void 0) {
+    throw new Error("lightning-send quote is missing refund_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 (quote.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) {
+    throw new Error(
+      `quote from_amount ${quote.from_amount} is below the invoice amount \u2014 a negative spread is not a quote`
+    );
+  }
+  const serverPubkey = xOnly(hex4.decode(info.signerPubkey), "ark signer key");
+  const script = lightningSendVtxoScript({
+    solverPubkey: xOnly(hex4.decode(quote.solver_pubkey), "solver key"),
+    refundLocktime: quote.refund_locktime,
+    serverPubkey,
+    paymentHash: params.invoice.paymentHash,
+    claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
+    emulatorPubkey: xOnly(emulatorPubkey, "emulator pubkey"),
+    senderPubkey,
+    receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
+    refundPkScript: ArkAddress.decode(refundAddress).pkScript
+  });
+  const address = script.address(getNetwork(info.network).hrp, serverPubkey).encode();
+  verifyLockupAddress(quote, address);
+  assertFundable({
+    quote,
+    invoiceExpiresAt: params.invoice.expiresAt,
+    now: Math.floor(Date.now() / 1e3)
+  });
+  await registerLockupContract(await wallet.getContractManager(), script, address);
+  return {
+    rfqId,
+    quote,
+    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,
+    swapPkScript: script.pkScript,
+    script,
+    refundAddress,
+    senderPubkey,
+    secrets
+  };
+}
+var offerTermsFromQuote = (quote, assets) => {
+  if (Boolean(assets.wantAsset) === Boolean(assets.offerAsset)) {
+    throw new Error("set exactly one of wantAsset or offerAsset");
+  }
+  return { wantAmount: BigInt(quote.to_amount), ...assets };
+};
+var l1NetworkFromArk = (network) => network === "bitcoin" ? "bitcoin" : network === "regtest" ? "regtest" : "testnet";
+var 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: hex4.encode(input.payoutPubkey),
+    refund_address: input.refundAddress,
+    client_refund_pubkey: hex4.encode(input.senderPubkey)
+  }
+});
+var 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: hex4.encode(input.payoutPubkey),
+    claim_packet: input.claimPacket
+  }
+});
+var onchainReceiveRequest = (input) => ({
+  v: 1,
+  type: "rfq_request",
+  rfq_id: input.rfqId,
+  pair: ONCHAIN_RECEIVE_PAIR,
+  amount_side: input.amountSide,
+  amount: input.amount,
+  profile: {
+    payment_hash: input.paymentHash,
+    claim_packet: input.claimPacket,
+    refund_pubkey: hex4.encode(input.refundPubkey),
+    payout_address: input.payoutAddress,
+    payout_pubkey: hex4.encode(input.payoutPubkey)
+  }
+});
+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 script = lightningSendVtxoScript({
+    solverPubkey: xOnly(hex4.decode(quote.solver_pubkey), "solver key"),
+    refundLocktime,
+    serverPubkey: input.serverPubkey,
+    paymentHash: input.paymentHash,
+    claimDelay: input.claimDelay,
+    emulatorPubkey: input.emulatorPubkey,
+    senderPubkey: input.senderPubkey,
+    receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
+    refundPkScript: ArkAddress.decode(input.refundAddress).pkScript
+  });
+  const address = script.address(input.hrp, input.serverPubkey).encode();
+  verifyLockupAddress(quote, address);
+  const htlc = onchainHtlcScript(
+    {
+      paymentHash: input.paymentHash,
+      claimKey: input.payoutPubkey,
+      refundKey: xOnly(hex4.decode(htlcPubkey), "solver L1 htlc key"),
+      refundLocktime: htlcLocktime
+    },
+    input.l1Network
+  );
+  if (htlc.address !== htlcAddress) throw new AddressMismatch(htlc.address, htlcAddress);
+  return {
+    address,
+    swapPkScript: script.pkScript,
+    script,
+    htlc,
+    refundLocktime,
+    htlcLocktime,
+    minConfirmations
+  };
+}
+async function requestOnchainSend(wallet, arkServerUrl, emulatorPubkey, transport, params) {
+  const rfqId = params.rfqId ?? newRfqId();
+  if (params.preimage && params.preimage.length !== 32) {
+    throw new Error(`preimage must be 32 bytes, got ${params.preimage.length}`);
+  }
+  const derivedSecrets = await deriveSwapSecrets(wallet);
+  const secrets = derivedSecrets ? params.preimage ? { ...derivedSecrets, preimage: params.preimage } : derivedSecrets : randomSwapSecrets({ preimage: params.preimage ?? true });
+  if (!secrets.derivable) {
+    console.warn(
+      params.preimage ? "[swap] this swap's sender key is random; the supplied preimage and sender key MUST be persisted before funding" : "[swap] this swap's preimage and sender key are random and MUST be persisted before funding"
+    );
+  } else if (params.preimage) {
+    console.warn(
+      "[swap] this swap's preimage was supplied by the caller and MUST be persisted with the signing descriptor before funding"
+    );
+  }
+  const preimage = await preimageForRfqSecrets(wallet, secrets);
+  const paymentHash = paymentHashOf(preimage);
+  const senderPubkey = await senderPubkeyForRfqSecrets(wallet, secrets);
+  const [info, refundAddress] = await Promise.all([
+    new RestArkProvider(arkServerUrl).getInfo(),
+    wallet.getAddress()
+  ]);
+  const quote = await transport.requestQuote(
+    onchainSendRequest({
+      rfqId,
+      paymentHash,
+      payoutPubkey: params.payoutPubkey,
+      refundAddress,
+      senderPubkey,
+      amount: params.amount,
+      amountSide: params.amountSide
+    })
+  );
+  const derived = deriveOnchainSend({
+    quote,
+    paymentHash,
+    payoutPubkey: params.payoutPubkey,
+    serverPubkey: xOnly(hex4.decode(info.signerPubkey), "ark signer key"),
+    emulatorPubkey: xOnly(emulatorPubkey, "emulator pubkey"),
+    claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
+    hrp: getNetwork(info.network).hrp,
+    l1Network: l1NetworkFromArk(info.network),
+    refundAddress,
+    senderPubkey
+  });
+  assertFundable({
+    quote,
+    now: Math.floor(Date.now() / 1e3),
+    onchain: {
+      htlcLocktime: derived.htlcLocktime,
+      minConfirmations: derived.minConfirmations,
+      direction: "send"
+    }
+  });
+  await registerLockupContract(
+    await wallet.getContractManager(),
+    derived.script,
+    derived.address
+  );
+  return {
+    rfqId,
+    quote,
+    address: derived.address,
+    fundAmount: quote.from_amount,
+    swapPkScript: derived.swapPkScript,
+    script: derived.script,
+    refundAddress,
+    htlc: derived.htlc,
+    senderPubkey,
+    secrets
+  };
+}
+var assertQuotedAmount = (quote, amountSide, amount) => {
+  const quoted = amountSide === "from" ? quote.from_amount : quote.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`
+    );
+  }
+  if (quote.to_amount > quote.from_amount) {
+    throw new Error("quote pays out more than it takes in \u2014 not a quote to fund");
+  }
+};
+var MIN_CLAIM_WINDOW_SECONDS = 30 * 60;
+var verifyReceiveInvoice = (input) => {
+  let decoded;
+  try {
+    decoded = input.decode(input.invoice);
+  } catch (error) {
+    throw gateError(
+      "invoice_undecodable",
+      `solver sent an undecodable invoice: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  assertFinite(decoded.expiresAt, "invoice_undecodable", "the decoded invoice expiry");
+  assertFinite(input.quote.valid_until, "quote_malformed", "quote valid_until");
+  if (decoded.paymentHash !== input.paymentHash) {
+    throw gateError(
+      "invoice_hash_mismatch",
+      `solver's invoice pays ${decoded.paymentHash}, not this swap's ${input.paymentHash}`
+    );
+  }
+  if (decoded.amountSats <= 0) {
+    throw gateError("invoice_amount_mismatch", "solver's invoice names no amount");
+  }
+  if (decoded.amountSats !== input.quote.from_amount) {
+    throw gateError(
+      "invoice_amount_mismatch",
+      `solver's invoice asks for ${decoded.amountSats}, not the quoted from_amount ${input.quote.from_amount}`
+    );
+  }
+  return { payDeadline: Math.min(decoded.expiresAt, input.quote.valid_until) };
+};
+var 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`
+    );
+  }
+};
+function receiveVtxoScript(params) {
+  const seconds = (value) => ({
+    type: "seconds",
+    value: BigInt(value)
+  });
+  return new VHTLC.ScriptV2({
+    sender: params.solverPubkey,
+    receiver: params.payoutPubkey,
+    server: params.serverPubkey,
+    preimageHash: ripemd1602(hex4.decode(params.paymentHash)),
+    refundLocktime: BigInt(params.refundLocktime),
+    unilateralClaimDelay: seconds(params.claimDelay),
+    unilateralRefundDelay: seconds(unilateralRefundDelay(params.claimDelay)),
+    unilateralRefundWithoutReceiverDelay: seconds(
+      unilateralRefundWithoutReceiverDelay(params.claimDelay)
+    ),
+    nonInteractiveClaim: {
+      receiverPkScript: params.payoutPkScript,
+      emulatorPubkey: params.emulatorPubkey
+    },
+    nonInteractiveRefund: {
+      senderPkScript: params.solverRefundPkScript,
+      emulatorPubkey: params.emulatorPubkey
+    }
+  });
+}
+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");
+  }
+  const script = receiveVtxoScript({
+    solverPubkey: xOnly(hex4.decode(quote.solver_pubkey), "solver key"),
+    refundLocktime,
+    serverPubkey: input.serverPubkey,
+    paymentHash: input.paymentHash,
+    claimDelay: input.claimDelay,
+    emulatorPubkey: input.emulatorPubkey,
+    solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
+    payoutPubkey: input.payoutPubkey,
+    payoutPkScript: ArkAddress.decode(input.payoutAddress).pkScript
+  });
+  const address = script.address(input.hrp, input.serverPubkey).encode();
+  verifyLockupAddress(quote, address);
+  return { address, swapPkScript: script.pkScript, script, invoice, refundLocktime };
+}
+async function requestLightningReceive(wallet, arkServerUrl, emulatorPubkey, transport, params) {
+  const rfqId = params.rfqId ?? newRfqId();
+  const secrets = await deriveSwapSecrets(wallet) ?? randomSwapSecrets({ preimage: true });
+  if (!secrets.derivable) {
+    console.warn(
+      "[swap] this swap's preimage and payout key are random and MUST be persisted before paying"
+    );
+  }
+  const preimage = await preimageForRfqSecrets(wallet, secrets);
+  const paymentHash = paymentHashOf(preimage);
+  const payoutPubkey = await senderPubkeyForRfqSecrets(wallet, secrets);
+  const [info, payoutAddress] = await Promise.all([
+    new RestArkProvider(arkServerUrl).getInfo(),
+    wallet.getAddress()
+  ]);
+  const claimPacket = await sealClaimPacket({
+    preimage,
+    covclaimdPubkey: params.covclaimdPubkey
+  });
+  const quote = await transport.requestQuote(
+    lightningReceiveRequest({
+      rfqId,
+      paymentHash,
+      payoutAddress,
+      payoutPubkey,
+      claimPacket: claimPacket.ciphertext,
+      amount: params.amount,
+      amountSide: params.amountSide
+    })
+  );
+  assertQuotedAmount(quote, params.amountSide, params.amount);
+  const derived = deriveLightningReceive({
+    quote,
+    paymentHash,
+    payoutPubkey,
+    payoutAddress,
+    serverPubkey: xOnly(hex4.decode(info.signerPubkey), "ark signer key"),
+    emulatorPubkey: xOnly(emulatorPubkey, "emulator pubkey"),
+    claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
+    hrp: getNetwork(info.network).hrp
+  });
+  const now = Math.floor(Date.now() / 1e3);
+  const { payDeadline } = verifyReceiveInvoice({
+    invoice: derived.invoice,
+    decode: params.decodeInvoice,
+    paymentHash,
+    quote
+  });
+  assertReceivable({ quote, payDeadline, now, maxPayAmount: params.maxPayAmount });
+  await registerLockupContract(
+    await wallet.getContractManager(),
+    derived.script,
+    derived.address
+  );
+  return {
+    rfqId,
+    quote,
+    invoice: derived.invoice,
+    payAmount: quote.from_amount,
+    expectedAmount: quote.to_amount,
+    invoiceExpiresAt: payDeadline,
+    address: derived.address,
+    swapPkScript: derived.swapPkScript,
+    script: derived.script,
+    payoutAddress,
+    payoutPubkey,
+    secrets
+  };
+}
+function deriveOnchainReceive(input) {
+  const { quote } = input;
+  const profile = quote.profile ?? {};
+  const refundLocktime = quote.refund_locktime;
+  const claimPubkey = profile.claim_pubkey;
+  const htlcLocktime = profile.htlc_locktime;
+  const htlcAddress = profile.htlc_address;
+  const minConfirmations = profile.min_confirmations;
+  const solverRefundPkScriptHex = profile.solver_refund_pk_script;
+  if (refundLocktime === void 0 || claimPubkey === void 0 || htlcLocktime === void 0 || minConfirmations === void 0 || solverRefundPkScriptHex === void 0) {
+    throw new Error("onchain-receive quote is missing a binding field");
+  }
+  const script = receiveVtxoScript({
+    solverPubkey: xOnly(hex4.decode(quote.solver_pubkey), "solver key"),
+    refundLocktime,
+    serverPubkey: input.serverPubkey,
+    paymentHash: input.paymentHash,
+    claimDelay: input.claimDelay,
+    emulatorPubkey: input.emulatorPubkey,
+    solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
+    payoutPubkey: input.payoutPubkey,
+    payoutPkScript: ArkAddress.decode(input.payoutAddress).pkScript
+  });
+  const address = script.address(input.hrp, input.serverPubkey).encode();
+  verifyLockupAddress(quote, address);
+  const htlc = onchainHtlcScript(
+    {
+      paymentHash: input.paymentHash,
+      claimKey: xOnly(hex4.decode(claimPubkey), "solver L1 claim key"),
+      refundKey: input.refundPubkey,
+      refundLocktime: htlcLocktime
+    },
+    input.l1Network
+  );
+  if (htlc.address !== htlcAddress) throw new AddressMismatch(htlc.address, htlcAddress);
+  return {
+    address,
+    swapPkScript: script.pkScript,
+    script,
+    htlc,
+    refundLocktime,
+    htlcLocktime,
+    minConfirmations
+  };
+}
+async function requestOnchainReceive(wallet, arkServerUrl, emulatorPubkey, transport, params) {
+  const rfqId = params.rfqId ?? newRfqId();
+  const secrets = await deriveSwapSecrets(wallet) ?? randomSwapSecrets({ preimage: true });
+  if (!secrets.derivable) {
+    console.warn(
+      "[swap] this swap's preimage and payout key are random and MUST be persisted before funding"
+    );
+  }
+  const preimage = await preimageForRfqSecrets(wallet, secrets);
+  const paymentHash = paymentHashOf(preimage);
+  const payoutPubkey = await senderPubkeyForRfqSecrets(wallet, secrets);
+  const [info, payoutAddress] = await Promise.all([
+    new RestArkProvider(arkServerUrl).getInfo(),
+    wallet.getAddress()
+  ]);
+  const claimPacket = await sealClaimPacket({
+    preimage,
+    covclaimdPubkey: params.covclaimdPubkey
+  });
+  const quote = await transport.requestQuote(
+    onchainReceiveRequest({
+      rfqId,
+      paymentHash,
+      payoutAddress,
+      payoutPubkey,
+      refundPubkey: params.refundPubkey,
+      claimPacket: claimPacket.ciphertext,
+      amount: params.amount,
+      amountSide: params.amountSide
+    })
+  );
+  assertQuotedAmount(quote, params.amountSide, params.amount);
+  const derived = deriveOnchainReceive({
+    quote,
+    paymentHash,
+    payoutPubkey,
+    payoutAddress,
+    refundPubkey: params.refundPubkey,
+    serverPubkey: xOnly(hex4.decode(info.signerPubkey), "ark signer key"),
+    emulatorPubkey: xOnly(emulatorPubkey, "emulator pubkey"),
+    claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
+    hrp: getNetwork(info.network).hrp,
+    l1Network: l1NetworkFromArk(info.network)
+  });
+  assertFundable({
+    quote,
+    now: Math.floor(Date.now() / 1e3),
+    onchain: {
+      htlcLocktime: derived.htlcLocktime,
+      minConfirmations: derived.minConfirmations,
+      direction: "receive"
+    }
+  });
+  await registerLockupContract(
+    await wallet.getContractManager(),
+    derived.script,
+    derived.address
+  );
+  return {
+    rfqId,
+    quote,
+    address: derived.address,
+    fundAmount: quote.from_amount,
+    expectedAmount: quote.to_amount,
+    swapPkScript: derived.swapPkScript,
+    script: derived.script,
+    htlc: derived.htlc,
+    payoutAddress,
+    payoutPubkey,
+    secrets
+  };
+}
+
+export {
+  ONCHAIN_ORDER_MARGIN_SECONDS,
+  ONCHAIN_CLAIM_MARGIN_SECONDS,
+  MAX_MIN_CONFIRMATIONS,
+  ONCHAIN_SECONDS_PER_BLOCK,
+  ONCHAIN_DUST_SATS,
+  newPreimage,
+  paymentHashOf,
+  onchainHtlcScript,
+  buildHtlcClaim,
+  buildHtlcRefund,
+  extractPreimage,
+  awaitOnchainFill,
+  claimOnchainFill,
+  classifyOnchainHtlc,
+  RFQ_PREIMAGE_TAG,
+  buildPreimageMessage,
+  deriveSwapSecrets,
+  randomSwapSecrets,
+  rfqSecretsToRecord,
+  rfqSecretsOfRecord,
+  adoptSwapDescriptor,
+  RefundNotLocallyPossibleError,
+  senderIdentityForRfqSecrets,
+  senderIdentityForSwapRecord,
+  senderPubkeyForRfqSecrets,
+  isDeterministicSigner,
+  derivePreimage,
+  preimageForRfqSecrets,
+  sealClaimPacket,
+  SWAP_LOCKUP_CONTRACT_TYPE,
+  SWAP_LOCKUP_CONTRACT_LABEL,
+  SWAP_LOCKUP_CONTRACT_KIND,
+  LockupRegistrationFailed,
+  registerLockupContract,
+  ARKADE_BTC,
+  ARKADE_ASSET,
+  LIGHTNING_BTC,
+  ONCHAIN_BTC,
+  rfqPair,
+  LIGHTNING_SEND_PAIR,
+  LIGHTNING_RECEIVE_PAIR,
+  ONCHAIN_SEND_PAIR,
+  ONCHAIN_RECEIVE_PAIR,
+  RFQ_TERMINAL_STATES,
+  SwapRefusal,
+  AddressMismatch,
+  newRfqId,
+  lightningSendRequest,
+  arkadeSwapRequest,
+  MIN_HEADROOM_SECONDS,
+  verifyLockupAddress,
+  assertFundable,
+  httpTransport,
+  relayTransport,
+  unilateralClaimDelay,
+  unilateralRefundDelay,
+  unilateralRefundWithoutReceiverDelay,
+  lightningSendVtxoScript,
+  requestLightningSend,
+  offerTermsFromQuote,
+  onchainSendRequest,
+  lightningReceiveRequest,
+  onchainReceiveRequest,
+  deriveOnchainSend,
+  requestOnchainSend,
+  MIN_CLAIM_WINDOW_SECONDS,
+  verifyReceiveInvoice,
+  assertReceivable,
+  receiveVtxoScript,
+  deriveLightningReceive,
+  requestLightningReceive,
+  deriveOnchainReceive,
+  requestOnchainReceive
+};