@arkade-os/swap 0.0.2 → 0.0.4

package/dist/{chunk-C5P7R7JT.js → chunk-DLM6BVTB.js}

@@ -204,176 +204,11 @@ async function classifyOnchainHtlc(chain, input) {
   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";
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
 var HKDF_INFO = new TextEncoder().encode("covclaimd/preimage/v1");
 async function sealClaimPacket(input) {
   return sealWithEntropy(
@@ -389,7 +224,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(sha2563, sharedX, ephemeralPub, HKDF_INFO, 32);
+  const key = hkdf(sha2562, 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"
@@ -413,7 +248,7 @@ async function sealWithEntropy(input, ephemeralKey, nonce) {
 }
 
 // src/lockupContract.ts
-import { hex as hex3 } from "@scure/base";
+import { hex as hex2 } 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";
@@ -437,7 +272,7 @@ async function registerLockupContract(contracts, script, address) {
     await contracts.createContract({
       type: SWAP_LOCKUP_CONTRACT_TYPE,
       params: VHTLCV2ContractHandler.serializeParams(script.options),
-      script: hex3.encode(script.pkScript),
+      script: hex2.encode(script.pkScript),
       address,
       label: SWAP_LOCKUP_CONTRACT_LABEL,
       metadata: { genericallySpendable: false, kind: SWAP_LOCKUP_CONTRACT_KIND }
@@ -448,13 +283,18 @@ async function registerLockupContract(contracts, script, address) {
 }
 
 // src/rfq.ts
-import { hex as hex4 } from "@scure/base";
+import { hex as hex3 } from "@scure/base";
 import { ripemd160 as ripemd1602 } from "@noble/hashes/legacy.js";
 import {
   ArkAddress,
   RestArkProvider,
   VHTLC,
-  getNetwork
+  getNetwork,
+  resolveEmulatorPubkey
+} from "@arkade-os/sdk";
+import {
+  provisionClaimSecret,
+  provisionRefundKey
 } from "@arkade-os/sdk";
 var xOnly = (key, label) => {
   if (key.length === 32) return key;
@@ -465,7 +305,7 @@ var xOnly = (key, label) => {
 };
 var solverHex = (value, field) => {
   try {
-    return hex4.decode(value);
+    return hex3.decode(value);
   } catch {
     throw new Error(`solver sent malformed hex for ${field}`);
   }
@@ -500,7 +340,7 @@ var AddressMismatch = class extends Error {
     this.quoted = quoted;
   }
 };
-var newRfqId = () => hex4.encode(crypto.getRandomValues(new Uint8Array(32)));
+var newRfqId = () => hex3.encode(crypto.getRandomValues(new Uint8Array(32)));
 var lightningSendRequest = (input) => ({
   v: 1,
   type: "rfq_request",
@@ -510,7 +350,7 @@ var lightningSendRequest = (input) => ({
   profile: {
     invoice: input.invoice,
     refund_address: input.refundAddress,
-    client_refund_pubkey: hex4.encode(input.senderPubkey)
+    client_refund_pubkey: hex3.encode(input.senderPubkey)
   }
 });
 var arkadeSwapRequest = (input) => {
@@ -528,8 +368,8 @@ var arkadeSwapRequest = (input) => {
     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()) }
+      ...input.offerAsset && { offer_asset: hex3.encode(input.offerAsset.serialize()) },
+      ...input.wantAsset && { want_asset: hex3.encode(input.wantAsset.serialize()) }
     }
   };
 };
@@ -730,7 +570,7 @@ function lightningSendVtxoScript(params) {
     sender: params.senderPubkey,
     receiver: params.solverPubkey,
     server: params.serverPubkey,
-    preimageHash: ripemd1602(hex4.decode(params.paymentHash)),
+    preimageHash: ripemd1602(hex3.decode(params.paymentHash)),
     refundLocktime: BigInt(params.refundLocktime),
     unilateralClaimDelay: seconds(params.claimDelay),
     unilateralRefundDelay: seconds(unilateralRefundDelay(params.claimDelay)),
@@ -747,15 +587,10 @@ function lightningSendVtxoScript(params) {
     }
   });
 }
-async function requestLightningSend(wallet, arkServerUrl, emulatorPubkey, transport, params) {
+async function requestLightningSend(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
-  const secrets = await deriveSwapSecrets(wallet) ?? randomSwapSecrets();
-  if (!secrets.derivable) {
-    console.warn(
-      "[swap] wallet cannot allocate an HD descriptor: the sender key is random and MUST be persisted before funding"
-    );
-  }
-  const senderPubkey = await senderPubkeyForRfqSecrets(wallet, secrets);
+  const secrets = await provisionRefundKey(wallet);
+  const senderPubkey = secrets.pubkey;
   const [info, refundAddress] = await Promise.all([
     new RestArkProvider(arkServerUrl).getInfo(),
     wallet.getAddress()
@@ -780,19 +615,23 @@ async function requestLightningSend(wallet, arkServerUrl, emulatorPubkey, transp
       `quote from_amount ${quote.from_amount} is below the invoice amount \u2014 a negative spread is not a quote`
     );
   }
-  const serverPubkey = xOnly(hex4.decode(info.signerPubkey), "ark signer key");
+  const serverPubkey = xOnly(hex3.decode(info.signerPubkey), "ark signer key");
+  const network = getNetwork(info.network);
   const script = lightningSendVtxoScript({
-    solverPubkey: xOnly(hex4.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: xOnly(hex3.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"),
+    emulatorPubkey: xOnly(
+      hex3.decode(resolveEmulatorPubkey(network, params.emulatorPubkey)),
+      "emulator signer key"
+    ),
     senderPubkey,
     receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
     refundPkScript: ArkAddress.decode(refundAddress).pkScript
   });
-  const address = script.address(getNetwork(info.network).hrp, serverPubkey).encode();
+  const address = script.address(network.hrp, serverPubkey).encode();
   verifyLockupAddress(quote, address);
   assertFundable({
     quote,
@@ -830,9 +669,9 @@ var onchainSendRequest = (input) => ({
   amount: input.amount,
   profile: {
     payment_hash: input.paymentHash,
-    payout_pubkey: hex4.encode(input.payoutPubkey),
+    payout_pubkey: hex3.encode(input.payoutPubkey),
     refund_address: input.refundAddress,
-    client_refund_pubkey: hex4.encode(input.senderPubkey)
+    client_refund_pubkey: hex3.encode(input.senderPubkey)
   }
 });
 var lightningReceiveRequest = (input) => ({
@@ -845,7 +684,7 @@ var lightningReceiveRequest = (input) => ({
   profile: {
     payment_hash: input.paymentHash,
     payout_address: input.payoutAddress,
-    payout_pubkey: hex4.encode(input.payoutPubkey),
+    payout_pubkey: hex3.encode(input.payoutPubkey),
     claim_packet: input.claimPacket
   }
 });
@@ -859,9 +698,9 @@ var onchainReceiveRequest = (input) => ({
   profile: {
     payment_hash: input.paymentHash,
     claim_packet: input.claimPacket,
-    refund_pubkey: hex4.encode(input.refundPubkey),
+    refund_pubkey: hex3.encode(input.refundPubkey),
     payout_address: input.payoutAddress,
-    payout_pubkey: hex4.encode(input.payoutPubkey)
+    payout_pubkey: hex3.encode(input.payoutPubkey)
   }
 });
 function deriveOnchainSend(input) {
@@ -877,7 +716,7 @@ function deriveOnchainSend(input) {
     throw new Error("onchain-send quote is missing a binding field");
   }
   const script = lightningSendVtxoScript({
-    solverPubkey: xOnly(hex4.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: xOnly(hex3.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -893,7 +732,7 @@ function deriveOnchainSend(input) {
     {
       paymentHash: input.paymentHash,
       claimKey: input.payoutPubkey,
-      refundKey: xOnly(hex4.decode(htlcPubkey), "solver L1 htlc key"),
+      refundKey: xOnly(hex3.decode(htlcPubkey), "solver L1 htlc key"),
       refundLocktime: htlcLocktime
     },
     input.l1Network
@@ -909,25 +748,16 @@ function deriveOnchainSend(input) {
     minConfirmations
   };
 }
-async function requestOnchainSend(wallet, arkServerUrl, emulatorPubkey, transport, params) {
+async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
-  if (params.preimage && params.preimage.length !== 32) {
-    throw new Error(`preimage must be 32 bytes, got ${params.preimage.length}`);
-  }
-  const derivedSecrets = await deriveSwapSecrets(wallet);
-  const secrets = derivedSecrets ? params.preimage ? { ...derivedSecrets, preimage: params.preimage } : derivedSecrets : randomSwapSecrets({ preimage: params.preimage ?? true });
-  if (!secrets.derivable) {
-    console.warn(
-      params.preimage ? "[swap] this swap's sender key is random; the supplied preimage and sender key MUST be persisted before funding" : "[swap] this swap's preimage and sender key are random and MUST be persisted before funding"
-    );
-  } else if (params.preimage) {
+  const secrets = await provisionClaimSecret(wallet, { preimage: params.preimage });
+  if (secrets.mustPersistPreimage) {
     console.warn(
-      "[swap] this swap's preimage was supplied by the caller and MUST be persisted with the signing descriptor before funding"
+      "[swap] this swap's preimage cannot be re-derived from the seed and MUST be persisted with the record before funding"
     );
   }
-  const preimage = await preimageForRfqSecrets(wallet, secrets);
-  const paymentHash = paymentHashOf(preimage);
-  const senderPubkey = await senderPubkeyForRfqSecrets(wallet, secrets);
+  const paymentHash = hex3.encode(secrets.paymentHash);
+  const senderPubkey = secrets.pubkey;
   const [info, refundAddress] = await Promise.all([
     new RestArkProvider(arkServerUrl).getInfo(),
     wallet.getAddress()
@@ -943,14 +773,18 @@ async function requestOnchainSend(wallet, arkServerUrl, emulatorPubkey, transpor
       amountSide: params.amountSide
     })
   );
+  const network = getNetwork(info.network);
   const derived = deriveOnchainSend({
     quote,
     paymentHash,
     payoutPubkey: params.payoutPubkey,
-    serverPubkey: xOnly(hex4.decode(info.signerPubkey), "ark signer key"),
-    emulatorPubkey: xOnly(emulatorPubkey, "emulator pubkey"),
+    serverPubkey: xOnly(hex3.decode(info.signerPubkey), "ark signer key"),
+    emulatorPubkey: xOnly(
+      hex3.decode(resolveEmulatorPubkey(network, params.emulatorPubkey)),
+      "emulator signer key"
+    ),
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
-    hrp: getNetwork(info.network).hrp,
+    hrp: network.hrp,
     l1Network: l1NetworkFromArk(info.network),
     refundAddress,
     senderPubkey
@@ -1058,7 +892,7 @@ function receiveVtxoScript(params) {
     sender: params.solverPubkey,
     receiver: params.payoutPubkey,
     server: params.serverPubkey,
-    preimageHash: ripemd1602(hex4.decode(params.paymentHash)),
+    preimageHash: ripemd1602(hex3.decode(params.paymentHash)),
     refundLocktime: BigInt(params.refundLocktime),
     unilateralClaimDelay: seconds(params.claimDelay),
     unilateralRefundDelay: seconds(unilateralRefundDelay(params.claimDelay)),
@@ -1085,7 +919,7 @@ function deriveLightningReceive(input) {
     throw new Error("lightning-receive quote is missing a binding field");
   }
   const script = receiveVtxoScript({
-    solverPubkey: xOnly(hex4.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: xOnly(hex3.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -1099,17 +933,17 @@ function deriveLightningReceive(input) {
   verifyLockupAddress(quote, address);
   return { address, swapPkScript: script.pkScript, script, invoice, refundLocktime };
 }
-async function requestLightningReceive(wallet, arkServerUrl, emulatorPubkey, transport, params) {
+async function requestLightningReceive(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
-  const secrets = await deriveSwapSecrets(wallet) ?? randomSwapSecrets({ preimage: true });
-  if (!secrets.derivable) {
+  const secrets = await provisionClaimSecret(wallet);
+  if (secrets.mustPersistPreimage) {
     console.warn(
-      "[swap] this swap's preimage and payout key are random and MUST be persisted before paying"
+      "[swap] this swap's preimage cannot be re-derived from the seed and MUST be persisted with the record before paying"
     );
   }
-  const preimage = await preimageForRfqSecrets(wallet, secrets);
-  const paymentHash = paymentHashOf(preimage);
-  const payoutPubkey = await senderPubkeyForRfqSecrets(wallet, secrets);
+  const preimage = secrets.preimage;
+  const paymentHash = hex3.encode(secrets.paymentHash);
+  const payoutPubkey = secrets.pubkey;
   const [info, payoutAddress] = await Promise.all([
     new RestArkProvider(arkServerUrl).getInfo(),
     wallet.getAddress()
@@ -1130,15 +964,19 @@ async function requestLightningReceive(wallet, arkServerUrl, emulatorPubkey, tra
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
+  const network = getNetwork(info.network);
   const derived = deriveLightningReceive({
     quote,
     paymentHash,
     payoutPubkey,
     payoutAddress,
-    serverPubkey: xOnly(hex4.decode(info.signerPubkey), "ark signer key"),
-    emulatorPubkey: xOnly(emulatorPubkey, "emulator pubkey"),
+    serverPubkey: xOnly(hex3.decode(info.signerPubkey), "ark signer key"),
+    emulatorPubkey: xOnly(
+      hex3.decode(resolveEmulatorPubkey(network, params.emulatorPubkey)),
+      "emulator signer key"
+    ),
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
-    hrp: getNetwork(info.network).hrp
+    hrp: network.hrp
   });
   const now = Math.floor(Date.now() / 1e3);
   const { payDeadline } = verifyReceiveInvoice({
@@ -1181,7 +1019,7 @@ function deriveOnchainReceive(input) {
     throw new Error("onchain-receive quote is missing a binding field");
   }
   const script = receiveVtxoScript({
-    solverPubkey: xOnly(hex4.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: xOnly(hex3.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -1196,7 +1034,7 @@ function deriveOnchainReceive(input) {
   const htlc = onchainHtlcScript(
     {
       paymentHash: input.paymentHash,
-      claimKey: xOnly(hex4.decode(claimPubkey), "solver L1 claim key"),
+      claimKey: xOnly(hex3.decode(claimPubkey), "solver L1 claim key"),
       refundKey: input.refundPubkey,
       refundLocktime: htlcLocktime
     },
@@ -1213,17 +1051,17 @@ function deriveOnchainReceive(input) {
     minConfirmations
   };
 }
-async function requestOnchainReceive(wallet, arkServerUrl, emulatorPubkey, transport, params) {
+async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
-  const secrets = await deriveSwapSecrets(wallet) ?? randomSwapSecrets({ preimage: true });
-  if (!secrets.derivable) {
+  const secrets = await provisionClaimSecret(wallet);
+  if (secrets.mustPersistPreimage) {
     console.warn(
-      "[swap] this swap's preimage and payout key are random and MUST be persisted before funding"
+      "[swap] this swap's preimage cannot be re-derived from the seed and MUST be persisted with the record before funding"
     );
   }
-  const preimage = await preimageForRfqSecrets(wallet, secrets);
-  const paymentHash = paymentHashOf(preimage);
-  const payoutPubkey = await senderPubkeyForRfqSecrets(wallet, secrets);
+  const preimage = secrets.preimage;
+  const paymentHash = hex3.encode(secrets.paymentHash);
+  const payoutPubkey = secrets.pubkey;
   const [info, payoutAddress] = await Promise.all([
     new RestArkProvider(arkServerUrl).getInfo(),
     wallet.getAddress()
@@ -1245,16 +1083,20 @@ async function requestOnchainReceive(wallet, arkServerUrl, emulatorPubkey, trans
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
+  const network = getNetwork(info.network);
   const derived = deriveOnchainReceive({
     quote,
     paymentHash,
     payoutPubkey,
     payoutAddress,
     refundPubkey: params.refundPubkey,
-    serverPubkey: xOnly(hex4.decode(info.signerPubkey), "ark signer key"),
-    emulatorPubkey: xOnly(emulatorPubkey, "emulator pubkey"),
+    serverPubkey: xOnly(hex3.decode(info.signerPubkey), "ark signer key"),
+    emulatorPubkey: xOnly(
+      hex3.decode(resolveEmulatorPubkey(network, params.emulatorPubkey)),
+      "emulator signer key"
+    ),
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
-    hrp: getNetwork(info.network).hrp,
+    hrp: network.hrp,
     l1Network: l1NetworkFromArk(info.network)
   });
   assertFundable({
@@ -1301,20 +1143,6 @@ export {
   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,