@arkade-os/swap 0.0.2 → 0.0.3

package/README.md

@@ -16,7 +16,7 @@ Arkade Intents names two participants:
   contract, and tracks it to a fill or a cancellation.
 - **solver** — supplies inventory and pricing, and fills the funded contract by delivering
   `wantAmount` to the user's script over the covenant's `fulfill` path. Some specifications and
-  repositories use *provider* or *market maker* as synonyms.
+  repositories use _provider_ or _market maker_ as synonyms.
 
 **`maker` and `taker` in this package name contract positions, not product roles.** The covenant
 programs bind `makerWP`, and the `Offer` type carries `makerPkScript` and `makerPublicKey`; those
@@ -25,14 +25,14 @@ identify the side that funds the swap and receives `wantAmount`. Read them as sc
 Arkade Intents documentation deliberately avoids maker and taker for the participants themselves.
 A resting maker order is firm once taken, and nothing here is: the user funds first, and if no
 solver fills, the deposit comes back through `cancelOffer` rather than through an executed trade.
-Naming the sides *user* and *solver* says who does what without borrowing a guarantee the contract
+Naming the sides _user_ and _solver_ says who does what without borrowing a guarantee the contract
 does not make.
 
 ## Request for quote
 
 Every Arkade Intents route is request-for-quote: the user states an intent, receives the solver's
 terms as a quote, funds the contract it derives from those terms, and a solver fills it. This
-route is no exception — what is specific to it is *where the quote is resolved*. `quoteOffer`
+route is no exception — what is specific to it is _where the quote is resolved_. `quoteOffer`
 prices the swap client-side from the market card the solver publishes: its price feed and its fee,
 the same two inputs a relay quote would carry. Same protocol, one fewer network hop, and a quote
 that is ready before the user finishes typing an amount.
@@ -52,7 +52,7 @@ with then.
 
 Every swap has the same two beats, on this route and on the cross-ledger corridors:
 
-1. **Funding** — the user funds the contract it derived from the quote. Funding *is* acceptance;
+1. **Funding** — the user funds the contract it derived from the quote. Funding _is_ acceptance;
    there is no accept message to send, here or anywhere in Arkade Intents.
 2. **Fill, or cancel** — a solver fills by delivering the other side, or the user takes the
    deposit back.
@@ -90,8 +90,8 @@ funds an offer should keep cancelling within reach.
 6. **`rfq`** — the user side of quoted swaps: RFQ negotiation over HTTP or a
    relay, then non-interactive filling (see below). All four reference-solver corridors:
    `arkade:BTC -> lightning:BTC` and `arkade:BTC -> onchain:BTC` (send), `lightning:BTC ->
-   arkade:BTC` and `onchain:BTC -> arkade:BTC` (receive), plus `arkade:BTC|asset ->
-   arkade:BTC|asset` (quote, then take by funding an offer from layer 1).
+arkade:BTC` and `onchain:BTC -> arkade:BTC` (receive), plus `arkade:BTC|asset ->
+arkade:BTC|asset` (quote, then take by funding an offer from layer 1).
 7. **`onchainHtlc`** — the Bitcoin-L1 side of `arkade:BTC <-> onchain:BTC`: a NUMS-keyed taproot
    HTLC as pure local derivation (golden-pinned), claim/refund spend builders with signing as a
    callback, the injected `ChainSource` seam (the package holds no L1 backend and no keys),
@@ -113,11 +113,11 @@ the rest:
 
 ```ts
 // BTC -> asset
-const o = await createOffer(wallet, ARK, EMULATOR_PUBKEY, { wantAmount: 1000n, wantAsset });
+const o = await createOffer(wallet, ARK, { wantAmount: 1000n, wantAsset });
 await wallet.send({ address: o.address, amount: 1000, extensions: [o.extension] });
 
 // asset -> BTC (the sats are the VTXO carrier for the asset)
-const o = await createOffer(wallet, ARK, EMULATOR_PUBKEY, { wantAmount: 1000n, offerAsset });
+const o = await createOffer(wallet, ARK, { wantAmount: 1000n, offerAsset });
 await wallet.send({
     address: o.address,
     amount: 500,
@@ -126,10 +126,11 @@ await wallet.send({
 });
 ```
 
-`EMULATOR_PUBKEY` is the covenant co-signer's x-only key — the solver's deployment, not yours.
-`createOffer` does not fetch or verify it: clients have no network path to the emulator, only the
-solver and covclaimd do. Obtain it out of band, before calling `createOffer`, from the solver's
-signed registry/corridor card and check it against whatever value you independently trust.
+The covenant co-signer ("emulator") key defaults to the SDK's per-network pin, resolved from the
+network the Ark server reports — never fetched from the emulator itself. Pass
+`params.emulatorPubkey` (33-byte compressed hex, the same contract as `Arkade.connect`'s option)
+to override it for a self-hosted emulator, an unpinned network (signet, testnet), or a key
+rotation the SDK hasn't shipped yet.
 
 ### What `createOffer` gives you back
 
@@ -232,15 +233,9 @@ message anywhere: **acceptance is funding**.
 import { httpTransport, requestLightningSend } from "@arkade-os/swap";
 
 // invoice facts from YOUR OWN decoder — the module takes facts, not a decoder
-const swap = await requestLightningSend(
-    wallet,
-    arkServerUrl,
-    emulatorPubkey,
-    httpTransport(solverUrl),
-    {
-        invoice: { raw: bolt11, paymentHash, amountSats, expiresAt },
-    },
-);
+const swap = await requestLightningSend(wallet, arkServerUrl, httpTransport(solverUrl), {
+    invoice: { raw: bolt11, paymentHash, amountSats, expiresAt },
+});
 // quote verified against the LOCAL derivation and gated; now fund and go offline:
 await wallet.send({ address: swap.address, amount: swap.fundAmount });
 ```
@@ -256,10 +251,8 @@ which the manager can only poll and cannot retire the row when the swap ends.
 The trust model is the offer side's, applied to quotes: only `solver_pubkey`,
 `refund_locktime`, `valid_until` and the amounts are used from a quote; every other contract
 parameter is the trader's own data, and anything address-shaped from the solver is compare-only
-(`AddressMismatch` means refuse-to-fund). `emulatorPubkey` is neither: it is not fetched or
-verified by this library at all — clients have no network path to the emulator, only the solver
-and covclaimd do — so it must arrive already obtained out of band, from the solver's signed
-registry/corridor card, and already checked against whatever value you independently trust.
+(`AddressMismatch` means refuse-to-fund). The emulator key is neither: as above, it is a
+per-network pin inside the SDK, not solver data.
 Refusals carry a closed reason set (`SwapRefusal`); unknown reasons are a generic decline. The
 `swap-lightning-send.program.json` bytes are frozen the same way the offer programs are — a
 golden test pins the compiled leaves and scriptPubKey to the reference solver's exact script.
@@ -314,13 +307,11 @@ import {
     rfqSecretsToRecord,
 } from "@arkade-os/swap";
 
-const swap = await requestOnchainSend(
-    wallet,
-    arkServerUrl,
-    emulatorPubkey,
-    httpTransport(solverUrl),
-    { amount: 100_000, amountSide: "to", payoutPubkey },
-);
+const swap = await requestOnchainSend(wallet, arkServerUrl, httpTransport(solverUrl), {
+    amount: 100_000,
+    amountSide: "to",
+    payoutPubkey,
+});
 // Persist the record, including secrets, BEFORE funding. This must succeed:
 // if addAssetSwap throws, do not call wallet.send.
 await addAssetSwap(repository, {
@@ -377,7 +368,7 @@ against the quote's compare-only addresses → gate. `requestLightningReceive` r
 hold invoice to pay; `requestOnchainReceive` returns the L1 HTLC to fund — the payment/broadcast
 itself is the trader's own wallet's job, exactly as on the send corridors.
 
-The invoice on the lightning-receive leg is the *solver's*, so the SDK owns the comparison rather
+The invoice on the lightning-receive leg is the _solver's_, so the SDK owns the comparison rather
 than taking the caller's facts about it: `requestLightningReceive` requires a `decodeInvoice`
 callback (no BOLT11 dependency is added) and `verifyReceiveInvoice` binds the decoded invoice to
 this swap's `H` and to `quote.from_amount` — an invoice on another payment hash is the one attack
@@ -403,11 +394,11 @@ implementation and marked provisional (`TODO(claim-packet-vectors)`).
 
 `RfqSwapManager` drives the lightning-receive leg too, as `kind: "lightning_receive"` records
 carrying `expectedAmount` and wired to a `claimLockup` callback (`pushClaim`, with `expectedAmount`
-and `partiallyClaimed` passed through — the manager's value check decides *when* to act, the inner
+and `partiallyClaimed` passed through — the manager's value check decides _when_ to act, the inner
 one decides whether `P` is published). Nothing is asked of the solver: the reference solver's
 `rfq_status_request` consults neither receive store, so a status poll answers `unknown` for every
 one of these swaps and chain observation is the only workable design. States mean what they do on
-the send legs with the roles swapped — `settled` is *our own* claim landing, matched by a
+the send legs with the roles swapped — `settled` is _our own_ claim landing, matched by a
 hash-verified preimage spend rather than by the txid we submitted, so a claim that lands without us
 still counts; `claimed` is a local belief and not terminal; and **`refunded` is a loss**, the solver
 having taken back a lockup we failed to claim. A lockup funded below `expectedAmount` is reported
@@ -471,7 +462,7 @@ alone will not compile against the fallback. A caller-supplied preimage on an HD
 `signingDescriptor` for the sender key and stores only `preimageHex` as secret material.
 
 Each swap **allocates** its own descriptor rather than peeking at the current one: two swaps sharing
-a descriptor derive the *identical* preimage, so one solver learning its own preimage would learn the
+a descriptor derive the _identical_ preimage, so one solver learning its own preimage would learn the
 other swap's. On restore, `adoptSwapDescriptor` moves the wallet's watermark past a restored record's
 index so it cannot be handed out twice.
 
@@ -486,7 +477,7 @@ too little public quote data to rediscover, so the record remains required.
 
 **Gap-limit interaction:** every swap request — including one whose quote is refused — consumes one
 index from the wallet's receive stream, and a swap index never becomes a funded receive contract,
-so it looks *unused* to a seed-only `restore()` gap scan. Many consecutive swap allocations between
+so it looks _unused_ to a seed-only `restore()` gap scan. Many consecutive swap allocations between
 two funded receive indices can therefore exceed the scan's `gapLimit` (default 20) and stop it
 before later-funded addresses are found. Keep the swap repository in backups (restore then adopts
 each record's descriptor via `adoptSwapDescriptor`), or raise `gapLimit` on seed-only restores

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

@@ -454,7 +454,8 @@ import {
   ArkAddress,
   RestArkProvider,
   VHTLC,
-  getNetwork
+  getNetwork,
+  resolveEmulatorPubkey
 } from "@arkade-os/sdk";
 var xOnly = (key, label) => {
   if (key.length === 32) return key;
@@ -747,7 +748,7 @@ 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) {
@@ -781,18 +782,22 @@ async function requestLightningSend(wallet, arkServerUrl, emulatorPubkey, transp
     );
   }
   const serverPubkey = xOnly(hex4.decode(info.signerPubkey), "ark signer key");
+  const network = getNetwork(info.network);
   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"),
+    emulatorPubkey: xOnly(
+      hex4.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,
@@ -909,7 +914,7 @@ 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}`);
@@ -943,14 +948,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"),
+    emulatorPubkey: xOnly(
+      hex4.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
@@ -1099,7 +1108,7 @@ 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) {
@@ -1130,15 +1139,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"),
+    emulatorPubkey: xOnly(
+      hex4.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({
@@ -1213,7 +1226,7 @@ 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) {
@@ -1245,6 +1258,7 @@ async function requestOnchainReceive(wallet, arkServerUrl, emulatorPubkey, trans
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
+  const network = getNetwork(info.network);
   const derived = deriveOnchainReceive({
     quote,
     paymentHash,
@@ -1252,9 +1266,12 @@ async function requestOnchainReceive(wallet, arkServerUrl, emulatorPubkey, trans
     payoutAddress,
     refundPubkey: params.refundPubkey,
     serverPubkey: xOnly(hex4.decode(info.signerPubkey), "ark signer key"),
-    emulatorPubkey: xOnly(emulatorPubkey, "emulator pubkey"),
+    emulatorPubkey: xOnly(
+      hex4.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({

package/dist/index.cjs

@@ -380,14 +380,6 @@ var FIELDS = {
   offerAsset: { tag: 11, width: void 0 }
 };
 var NAMES = Object.fromEntries(Object.entries(FIELDS).map(([k, f]) => [f.tag, k]));
-var XONLY_LEN = 32;
-var xOnly = (key, label) => {
-  if (key.length === XONLY_LEN) return key;
-  if (key.length !== 33 || key[0] !== 2 && key[0] !== 3) {
-    throw new Error(`${label} is not a compressed or x-only public key`);
-  }
-  return key.slice(1);
-};
 function tlv(type, value) {
   if (value.length > 65535) throw new Error("TLV value exceeds the u16 length field");
   return (0, import_utils.concatBytes)(Uint8Array.of(type, value.length >> 8 & 255, value.length & 255), value);
@@ -489,7 +481,7 @@ async function registerOfferContract(wallet, arkServerUrl, network, binding, ser
   });
   await promoteOfferContract(contractManager, import_base.hex.encode(expectedPkScript));
 }
-async function createOffer(wallet, arkServerUrl, emulatorPubkey, params) {
+async function createOffer(wallet, arkServerUrl, params) {
   if (Boolean(params.wantAsset) === Boolean(params.offerAsset)) {
     throw new Error("set exactly one of wantAsset (BTC->asset) or offerAsset (asset->BTC)");
   }
@@ -498,8 +490,11 @@ async function createOffer(wallet, arkServerUrl, emulatorPubkey, params) {
     wallet.getAddress(),
     wallet.identity.xOnlyPublicKey()
   ]);
-  const serverPubKey = xOnly(import_base.hex.decode(info.signerPubkey), "ark signer key");
-  const emuKey = xOnly(emulatorPubkey, "emulator pubkey");
+  const serverPubKey = import_base.hex.decode((0, import_sdk.toXOnlySignerHex)(info.signerPubkey));
+  const network = (0, import_sdk.getNetwork)(info.network);
+  const emuKey = import_base.hex.decode(
+    (0, import_sdk.toXOnlySignerHex)((0, import_sdk.resolveEmulatorPubkey)(network, params.emulatorPubkey))
+  );
   const binding = {
     wantAmount: params.wantAmount,
     wantAsset: params.wantAsset,
@@ -524,7 +519,7 @@ async function createOffer(wallet, arkServerUrl, emulatorPubkey, params) {
     extension: { type: OFFER_PACKET_TYPE, payload },
     // VtxoScript.address owns address construction; assembling an ArkAddress
     // from tweakedPublicKey here would silently miss any future step it gains
-    address: script.address((0, import_sdk.getNetwork)(info.network).hrp, serverPubKey).encode(),
+    address: script.address(network.hrp, serverPubKey).encode(),
     swapPkScript: script.pkScript
   };
 }
@@ -1541,7 +1536,7 @@ async function registerLockupContract(contracts, script, address) {
 }
 
 // src/rfq.ts
-var xOnly2 = (key, label) => {
+var xOnly = (key, label) => {
   if (key.length === 32) return key;
   if (key.length !== 33 || key[0] !== 2 && key[0] !== 3) {
     throw new Error(`${label} is not a compressed or x-only public key`);
@@ -1832,7 +1827,7 @@ 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) {
@@ -1865,19 +1860,23 @@ async function requestLightningSend(wallet, arkServerUrl, emulatorPubkey, transp
       `quote from_amount ${quote.from_amount} is below the invoice amount \u2014 a negative spread is not a quote`
     );
   }
-  const serverPubkey = xOnly2(import_base8.hex.decode(info.signerPubkey), "ark signer key");
+  const serverPubkey = xOnly(import_base8.hex.decode(info.signerPubkey), "ark signer key");
+  const network = (0, import_sdk8.getNetwork)(info.network);
   const script = lightningSendVtxoScript({
-    solverPubkey: xOnly2(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: xOnly(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime: quote.refund_locktime,
     serverPubkey,
     paymentHash: params.invoice.paymentHash,
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
-    emulatorPubkey: xOnly2(emulatorPubkey, "emulator pubkey"),
+    emulatorPubkey: xOnly(
+      import_base8.hex.decode((0, import_sdk8.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
+      "emulator signer key"
+    ),
     senderPubkey,
     receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
     refundPkScript: import_sdk8.ArkAddress.decode(refundAddress).pkScript
   });
-  const address = script.address((0, import_sdk8.getNetwork)(info.network).hrp, serverPubkey).encode();
+  const address = script.address(network.hrp, serverPubkey).encode();
   verifyLockupAddress(quote, address);
   assertFundable({
     quote,
@@ -1962,7 +1961,7 @@ function deriveOnchainSend(input) {
     throw new Error("onchain-send quote is missing a binding field");
   }
   const script = lightningSendVtxoScript({
-    solverPubkey: xOnly2(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: xOnly(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -1978,7 +1977,7 @@ function deriveOnchainSend(input) {
     {
       paymentHash: input.paymentHash,
       claimKey: input.payoutPubkey,
-      refundKey: xOnly2(import_base8.hex.decode(htlcPubkey), "solver L1 htlc key"),
+      refundKey: xOnly(import_base8.hex.decode(htlcPubkey), "solver L1 htlc key"),
       refundLocktime: htlcLocktime
     },
     input.l1Network
@@ -1994,7 +1993,7 @@ 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}`);
@@ -2028,14 +2027,18 @@ async function requestOnchainSend(wallet, arkServerUrl, emulatorPubkey, transpor
       amountSide: params.amountSide
     })
   );
+  const network = (0, import_sdk8.getNetwork)(info.network);
   const derived = deriveOnchainSend({
     quote,
     paymentHash,
     payoutPubkey: params.payoutPubkey,
-    serverPubkey: xOnly2(import_base8.hex.decode(info.signerPubkey), "ark signer key"),
-    emulatorPubkey: xOnly2(emulatorPubkey, "emulator pubkey"),
+    serverPubkey: xOnly(import_base8.hex.decode(info.signerPubkey), "ark signer key"),
+    emulatorPubkey: xOnly(
+      import_base8.hex.decode((0, import_sdk8.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
+      "emulator signer key"
+    ),
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
-    hrp: (0, import_sdk8.getNetwork)(info.network).hrp,
+    hrp: network.hrp,
     l1Network: l1NetworkFromArk(info.network),
     refundAddress,
     senderPubkey
@@ -2170,7 +2173,7 @@ function deriveLightningReceive(input) {
     throw new Error("lightning-receive quote is missing a binding field");
   }
   const script = receiveVtxoScript({
-    solverPubkey: xOnly2(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: xOnly(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -2184,7 +2187,7 @@ 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) {
@@ -2215,15 +2218,19 @@ async function requestLightningReceive(wallet, arkServerUrl, emulatorPubkey, tra
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
+  const network = (0, import_sdk8.getNetwork)(info.network);
   const derived = deriveLightningReceive({
     quote,
     paymentHash,
     payoutPubkey,
     payoutAddress,
-    serverPubkey: xOnly2(import_base8.hex.decode(info.signerPubkey), "ark signer key"),
-    emulatorPubkey: xOnly2(emulatorPubkey, "emulator pubkey"),
+    serverPubkey: xOnly(import_base8.hex.decode(info.signerPubkey), "ark signer key"),
+    emulatorPubkey: xOnly(
+      import_base8.hex.decode((0, import_sdk8.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
+      "emulator signer key"
+    ),
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
-    hrp: (0, import_sdk8.getNetwork)(info.network).hrp
+    hrp: network.hrp
   });
   const now = Math.floor(Date.now() / 1e3);
   const { payDeadline } = verifyReceiveInvoice({
@@ -2266,7 +2273,7 @@ function deriveOnchainReceive(input) {
     throw new Error("onchain-receive quote is missing a binding field");
   }
   const script = receiveVtxoScript({
-    solverPubkey: xOnly2(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: xOnly(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -2281,7 +2288,7 @@ function deriveOnchainReceive(input) {
   const htlc = onchainHtlcScript(
     {
       paymentHash: input.paymentHash,
-      claimKey: xOnly2(import_base8.hex.decode(claimPubkey), "solver L1 claim key"),
+      claimKey: xOnly(import_base8.hex.decode(claimPubkey), "solver L1 claim key"),
       refundKey: input.refundPubkey,
       refundLocktime: htlcLocktime
     },
@@ -2298,7 +2305,7 @@ 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) {
@@ -2330,16 +2337,20 @@ async function requestOnchainReceive(wallet, arkServerUrl, emulatorPubkey, trans
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
+  const network = (0, import_sdk8.getNetwork)(info.network);
   const derived = deriveOnchainReceive({
     quote,
     paymentHash,
     payoutPubkey,
     payoutAddress,
     refundPubkey: params.refundPubkey,
-    serverPubkey: xOnly2(import_base8.hex.decode(info.signerPubkey), "ark signer key"),
-    emulatorPubkey: xOnly2(emulatorPubkey, "emulator pubkey"),
+    serverPubkey: xOnly(import_base8.hex.decode(info.signerPubkey), "ark signer key"),
+    emulatorPubkey: xOnly(
+      import_base8.hex.decode((0, import_sdk8.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
+      "emulator signer key"
+    ),
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
-    hrp: (0, import_sdk8.getNetwork)(info.network).hrp,
+    hrp: network.hrp,
     l1Network: l1NetworkFromArk(info.network)
   });
   assertFundable({

package/dist/index.d.cts

@@ -1,6 +1,6 @@
 import { asset, IWallet, arkade, RestIndexerProvider, Transaction, IContractManager, RestArkProvider, VHTLC, Identity } from '@arkade-os/sdk';
-import { A as AssetSwapRepository, a as AssetSwap, M as MarketsCacheEntry, R as RfqStatus, b as RfqTransport, O as OnchainHtlc, C as ChainSource, c as ChainUtxo, d as OnchainHtlcPhase } from './rfq-CRgIOQ_y.cjs';
-export { e as ARKADE_ASSET, f as ARKADE_BTC, g as AddressMismatch, h as AssetSwapFallbackSecrets, i as AssetSwapStatus, B as BTC_ASSET_ID, D as DerivedSwapSecrets, j as DeterministicSigner, H as HtlcUtxo, I as InMemoryAssetSwapRepository, k as InvoiceFacts, L as LIGHTNING_BTC, l as LIGHTNING_RECEIVE_PAIR, m as LIGHTNING_SEND_PAIR, n as MAX_MIN_CONFIRMATIONS, o as MIN_CLAIM_WINDOW_SECONDS, p as MIN_HEADROOM_SECONDS, q as ONCHAIN_BTC, r as ONCHAIN_CLAIM_MARGIN_SECONDS, s as ONCHAIN_DUST_SATS, t as ONCHAIN_ORDER_MARGIN_SECONDS, u as ONCHAIN_RECEIVE_PAIR, v as ONCHAIN_SECONDS_PER_BLOCK, w as ONCHAIN_SEND_PAIR, x as OnchainHtlcParams, y as OnchainNetwork, z as RFQ_PREIMAGE_TAG, E as RFQ_TERMINAL_STATES, F as RefundBlockedReason, G as RefundNotLocallyPossibleError, J as RelaySocket, K as RfqQuote, N as RfqRefusalReason, S as StoredSwapSecrets, P as SwapRefusal, Q as SwapSecrets, T as addAssetSwap, U as adoptSwapDescriptor, V as arkadeSwapRequest, W as assertFundable, X as assertReceivable, Y as awaitOnchainFill, Z as buildHtlcClaim, _ as buildHtlcRefund, $ as buildPreimageMessage, a0 as claimOnchainFill, a1 as classifyOnchainHtlc, a2 as deriveLightningReceive, a3 as deriveOnchainReceive, a4 as deriveOnchainSend, a5 as derivePreimage, a6 as deriveSwapSecrets, a7 as extractPreimage, a8 as getAssetSwaps, a9 as getAssetSwapsOrThrow, aa as httpTransport, ab as isDeterministicSigner, ac as lightningReceiveRequest, ad as lightningSendRequest, ae as lightningSendVtxoScript, af as newPreimage, ag as newRfqId, ah as offerTermsFromQuote, ai as onchainHtlcScript, aj as onchainReceiveRequest, ak as onchainSendRequest, al as paymentHashOf, am as preimageForRfqSecrets, an as randomSwapSecrets, ao as receiveVtxoScript, ap as relayTransport, aq as requestLightningReceive, ar as requestLightningSend, as as requestOnchainReceive, at as requestOnchainSend, au as rfqPair, av as rfqSecretsOfRecord, aw as rfqSecretsToRecord, ax as senderIdentityForRfqSecrets, ay as senderIdentityForSwapRecord, az as senderPubkeyForRfqSecrets, aA as unilateralClaimDelay, aB as unilateralRefundDelay, aC as unilateralRefundWithoutReceiverDelay, aD as updateAssetSwap, aE as updateAssetSwapBestEffort, aF as verifyLockupAddress, aG as verifyReceiveInvoice } from './rfq-CRgIOQ_y.cjs';
+import { A as AssetSwapRepository, a as AssetSwap, M as MarketsCacheEntry, R as RfqStatus, b as RfqTransport, O as OnchainHtlc, C as ChainSource, c as ChainUtxo, d as OnchainHtlcPhase } from './rfq-CCAFoFtR.cjs';
+export { e as ARKADE_ASSET, f as ARKADE_BTC, g as AddressMismatch, h as AssetSwapFallbackSecrets, i as AssetSwapStatus, B as BTC_ASSET_ID, D as DerivedSwapSecrets, j as DeterministicSigner, H as HtlcUtxo, I as InMemoryAssetSwapRepository, k as InvoiceFacts, L as LIGHTNING_BTC, l as LIGHTNING_RECEIVE_PAIR, m as LIGHTNING_SEND_PAIR, n as MAX_MIN_CONFIRMATIONS, o as MIN_CLAIM_WINDOW_SECONDS, p as MIN_HEADROOM_SECONDS, q as ONCHAIN_BTC, r as ONCHAIN_CLAIM_MARGIN_SECONDS, s as ONCHAIN_DUST_SATS, t as ONCHAIN_ORDER_MARGIN_SECONDS, u as ONCHAIN_RECEIVE_PAIR, v as ONCHAIN_SECONDS_PER_BLOCK, w as ONCHAIN_SEND_PAIR, x as OnchainHtlcParams, y as OnchainNetwork, z as RFQ_PREIMAGE_TAG, E as RFQ_TERMINAL_STATES, F as RefundBlockedReason, G as RefundNotLocallyPossibleError, J as RelaySocket, K as RfqQuote, N as RfqRefusalReason, S as StoredSwapSecrets, P as SwapRefusal, Q as SwapSecrets, T as addAssetSwap, U as adoptSwapDescriptor, V as arkadeSwapRequest, W as assertFundable, X as assertReceivable, Y as awaitOnchainFill, Z as buildHtlcClaim, _ as buildHtlcRefund, $ as buildPreimageMessage, a0 as claimOnchainFill, a1 as classifyOnchainHtlc, a2 as deriveLightningReceive, a3 as deriveOnchainReceive, a4 as deriveOnchainSend, a5 as derivePreimage, a6 as deriveSwapSecrets, a7 as extractPreimage, a8 as getAssetSwaps, a9 as getAssetSwapsOrThrow, aa as httpTransport, ab as isDeterministicSigner, ac as lightningReceiveRequest, ad as lightningSendRequest, ae as lightningSendVtxoScript, af as newPreimage, ag as newRfqId, ah as offerTermsFromQuote, ai as onchainHtlcScript, aj as onchainReceiveRequest, ak as onchainSendRequest, al as paymentHashOf, am as preimageForRfqSecrets, an as randomSwapSecrets, ao as receiveVtxoScript, ap as relayTransport, aq as requestLightningReceive, ar as requestLightningSend, as as requestOnchainReceive, at as requestOnchainSend, au as rfqPair, av as rfqSecretsOfRecord, aw as rfqSecretsToRecord, ax as senderIdentityForRfqSecrets, ay as senderIdentityForSwapRecord, az as senderPubkeyForRfqSecrets, aA as unilateralClaimDelay, aB as unilateralRefundDelay, aC as unilateralRefundWithoutReceiverDelay, aD as updateAssetSwap, aE as updateAssetSwapBestEffort, aF as verifyLockupAddress, aG as verifyReceiveInvoice } from './rfq-CCAFoFtR.cjs';
 import { Network, LocalCardInput, DiscoveredMarket, Side, OfferPlan } from '@arkade-os/solver-discovery';
 
 /** The contracts — pure data, shared verbatim with any other implementation. */
@@ -38,11 +38,11 @@ declare function decodeOffer(data: Uint8Array): Offer;
  * you deposit, embedding the returned extension, and the solver does the rest:
  *
  *   // BTC -> asset
- *   const o = await createOffer(wallet, ARK, EMULATOR_PUBKEY, { wantAmount: 1000n, wantAsset })
+ *   const o = await createOffer(wallet, ARK, { wantAmount: 1000n, wantAsset })
  *   await wallet.send({ address: o.address, amount: 1000, extensions: [o.extension] })
  *
  *   // asset -> BTC (the sats are the VTXO carrier for the asset)
- *   const o = await createOffer(wallet, ARK, EMULATOR_PUBKEY, { wantAmount: 1000n, offerAsset })
+ *   const o = await createOffer(wallet, ARK, { wantAmount: 1000n, offerAsset })
  *   await wallet.send({ address: o.address, amount: 500,
  *                       assets: [{ assetId, amount: 1000n }],
  *                       extensions: [o.extension] })
@@ -55,20 +55,13 @@ declare function decodeOffer(data: Uint8Array): Offer;
  * and be retried, where the same failure after `wallet.send` would leave a
  * funded deposit unwatched with no way to notice.
  */
-declare function createOffer(wallet: IWallet, arkServerUrl: string, 
-/** Covenant co-signer (emulator) x-only key — the SOLVER's deployment,
- * not the user's. This library does NOT fetch or verify it: clients
- * have no network path to the emulator, only the solver and covclaimd
- * do. The caller must obtain this out-of-band, before calling this
- * function, from the solver's signed registry/corridor card (its
- * `emulator_pubkey`, added in arkade-os/solver-registry#18) or an
- * equivalent source it
- * independently trusts, and is responsible for having checked it
- * against that trusted value itself. */
-emulatorPubkey: Uint8Array, params: {
+declare function createOffer(wallet: IWallet, arkServerUrl: string, params: {
     wantAmount: bigint;
     wantAsset?: asset.AssetId;
     offerAsset?: asset.AssetId;
+    /** Co-signer key override (33-byte compressed hex); see
+     * {@link resolveEmulatorPubkey}. */
+    emulatorPubkey?: string;
 }): Promise<{
     /** The encoded offer, hex. **Persist this** — it is the only input
      * `cancelOffer` needs to rebuild the covenant, and the restore scan reads

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { asset, IWallet, arkade, RestIndexerProvider, Transaction, IContractManager, RestArkProvider, VHTLC, Identity } from '@arkade-os/sdk';
-import { A as AssetSwapRepository, a as AssetSwap, M as MarketsCacheEntry, R as RfqStatus, b as RfqTransport, O as OnchainHtlc, C as ChainSource, c as ChainUtxo, d as OnchainHtlcPhase } from './rfq-CRgIOQ_y.js';
-export { e as ARKADE_ASSET, f as ARKADE_BTC, g as AddressMismatch, h as AssetSwapFallbackSecrets, i as AssetSwapStatus, B as BTC_ASSET_ID, D as DerivedSwapSecrets, j as DeterministicSigner, H as HtlcUtxo, I as InMemoryAssetSwapRepository, k as InvoiceFacts, L as LIGHTNING_BTC, l as LIGHTNING_RECEIVE_PAIR, m as LIGHTNING_SEND_PAIR, n as MAX_MIN_CONFIRMATIONS, o as MIN_CLAIM_WINDOW_SECONDS, p as MIN_HEADROOM_SECONDS, q as ONCHAIN_BTC, r as ONCHAIN_CLAIM_MARGIN_SECONDS, s as ONCHAIN_DUST_SATS, t as ONCHAIN_ORDER_MARGIN_SECONDS, u as ONCHAIN_RECEIVE_PAIR, v as ONCHAIN_SECONDS_PER_BLOCK, w as ONCHAIN_SEND_PAIR, x as OnchainHtlcParams, y as OnchainNetwork, z as RFQ_PREIMAGE_TAG, E as RFQ_TERMINAL_STATES, F as RefundBlockedReason, G as RefundNotLocallyPossibleError, J as RelaySocket, K as RfqQuote, N as RfqRefusalReason, S as StoredSwapSecrets, P as SwapRefusal, Q as SwapSecrets, T as addAssetSwap, U as adoptSwapDescriptor, V as arkadeSwapRequest, W as assertFundable, X as assertReceivable, Y as awaitOnchainFill, Z as buildHtlcClaim, _ as buildHtlcRefund, $ as buildPreimageMessage, a0 as claimOnchainFill, a1 as classifyOnchainHtlc, a2 as deriveLightningReceive, a3 as deriveOnchainReceive, a4 as deriveOnchainSend, a5 as derivePreimage, a6 as deriveSwapSecrets, a7 as extractPreimage, a8 as getAssetSwaps, a9 as getAssetSwapsOrThrow, aa as httpTransport, ab as isDeterministicSigner, ac as lightningReceiveRequest, ad as lightningSendRequest, ae as lightningSendVtxoScript, af as newPreimage, ag as newRfqId, ah as offerTermsFromQuote, ai as onchainHtlcScript, aj as onchainReceiveRequest, ak as onchainSendRequest, al as paymentHashOf, am as preimageForRfqSecrets, an as randomSwapSecrets, ao as receiveVtxoScript, ap as relayTransport, aq as requestLightningReceive, ar as requestLightningSend, as as requestOnchainReceive, at as requestOnchainSend, au as rfqPair, av as rfqSecretsOfRecord, aw as rfqSecretsToRecord, ax as senderIdentityForRfqSecrets, ay as senderIdentityForSwapRecord, az as senderPubkeyForRfqSecrets, aA as unilateralClaimDelay, aB as unilateralRefundDelay, aC as unilateralRefundWithoutReceiverDelay, aD as updateAssetSwap, aE as updateAssetSwapBestEffort, aF as verifyLockupAddress, aG as verifyReceiveInvoice } from './rfq-CRgIOQ_y.js';
+import { A as AssetSwapRepository, a as AssetSwap, M as MarketsCacheEntry, R as RfqStatus, b as RfqTransport, O as OnchainHtlc, C as ChainSource, c as ChainUtxo, d as OnchainHtlcPhase } from './rfq-CCAFoFtR.js';
+export { e as ARKADE_ASSET, f as ARKADE_BTC, g as AddressMismatch, h as AssetSwapFallbackSecrets, i as AssetSwapStatus, B as BTC_ASSET_ID, D as DerivedSwapSecrets, j as DeterministicSigner, H as HtlcUtxo, I as InMemoryAssetSwapRepository, k as InvoiceFacts, L as LIGHTNING_BTC, l as LIGHTNING_RECEIVE_PAIR, m as LIGHTNING_SEND_PAIR, n as MAX_MIN_CONFIRMATIONS, o as MIN_CLAIM_WINDOW_SECONDS, p as MIN_HEADROOM_SECONDS, q as ONCHAIN_BTC, r as ONCHAIN_CLAIM_MARGIN_SECONDS, s as ONCHAIN_DUST_SATS, t as ONCHAIN_ORDER_MARGIN_SECONDS, u as ONCHAIN_RECEIVE_PAIR, v as ONCHAIN_SECONDS_PER_BLOCK, w as ONCHAIN_SEND_PAIR, x as OnchainHtlcParams, y as OnchainNetwork, z as RFQ_PREIMAGE_TAG, E as RFQ_TERMINAL_STATES, F as RefundBlockedReason, G as RefundNotLocallyPossibleError, J as RelaySocket, K as RfqQuote, N as RfqRefusalReason, S as StoredSwapSecrets, P as SwapRefusal, Q as SwapSecrets, T as addAssetSwap, U as adoptSwapDescriptor, V as arkadeSwapRequest, W as assertFundable, X as assertReceivable, Y as awaitOnchainFill, Z as buildHtlcClaim, _ as buildHtlcRefund, $ as buildPreimageMessage, a0 as claimOnchainFill, a1 as classifyOnchainHtlc, a2 as deriveLightningReceive, a3 as deriveOnchainReceive, a4 as deriveOnchainSend, a5 as derivePreimage, a6 as deriveSwapSecrets, a7 as extractPreimage, a8 as getAssetSwaps, a9 as getAssetSwapsOrThrow, aa as httpTransport, ab as isDeterministicSigner, ac as lightningReceiveRequest, ad as lightningSendRequest, ae as lightningSendVtxoScript, af as newPreimage, ag as newRfqId, ah as offerTermsFromQuote, ai as onchainHtlcScript, aj as onchainReceiveRequest, ak as onchainSendRequest, al as paymentHashOf, am as preimageForRfqSecrets, an as randomSwapSecrets, ao as receiveVtxoScript, ap as relayTransport, aq as requestLightningReceive, ar as requestLightningSend, as as requestOnchainReceive, at as requestOnchainSend, au as rfqPair, av as rfqSecretsOfRecord, aw as rfqSecretsToRecord, ax as senderIdentityForRfqSecrets, ay as senderIdentityForSwapRecord, az as senderPubkeyForRfqSecrets, aA as unilateralClaimDelay, aB as unilateralRefundDelay, aC as unilateralRefundWithoutReceiverDelay, aD as updateAssetSwap, aE as updateAssetSwapBestEffort, aF as verifyLockupAddress, aG as verifyReceiveInvoice } from './rfq-CCAFoFtR.js';
 import { Network, LocalCardInput, DiscoveredMarket, Side, OfferPlan } from '@arkade-os/solver-discovery';
 
 /** The contracts — pure data, shared verbatim with any other implementation. */
@@ -38,11 +38,11 @@ declare function decodeOffer(data: Uint8Array): Offer;
  * you deposit, embedding the returned extension, and the solver does the rest:
  *
  *   // BTC -> asset
- *   const o = await createOffer(wallet, ARK, EMULATOR_PUBKEY, { wantAmount: 1000n, wantAsset })
+ *   const o = await createOffer(wallet, ARK, { wantAmount: 1000n, wantAsset })
  *   await wallet.send({ address: o.address, amount: 1000, extensions: [o.extension] })
  *
  *   // asset -> BTC (the sats are the VTXO carrier for the asset)
- *   const o = await createOffer(wallet, ARK, EMULATOR_PUBKEY, { wantAmount: 1000n, offerAsset })
+ *   const o = await createOffer(wallet, ARK, { wantAmount: 1000n, offerAsset })
  *   await wallet.send({ address: o.address, amount: 500,
  *                       assets: [{ assetId, amount: 1000n }],
  *                       extensions: [o.extension] })
@@ -55,20 +55,13 @@ declare function decodeOffer(data: Uint8Array): Offer;
  * and be retried, where the same failure after `wallet.send` would leave a
  * funded deposit unwatched with no way to notice.
  */
-declare function createOffer(wallet: IWallet, arkServerUrl: string, 
-/** Covenant co-signer (emulator) x-only key — the SOLVER's deployment,
- * not the user's. This library does NOT fetch or verify it: clients
- * have no network path to the emulator, only the solver and covclaimd
- * do. The caller must obtain this out-of-band, before calling this
- * function, from the solver's signed registry/corridor card (its
- * `emulator_pubkey`, added in arkade-os/solver-registry#18) or an
- * equivalent source it
- * independently trusts, and is responsible for having checked it
- * against that trusted value itself. */
-emulatorPubkey: Uint8Array, params: {
+declare function createOffer(wallet: IWallet, arkServerUrl: string, params: {
     wantAmount: bigint;
     wantAsset?: asset.AssetId;
     offerAsset?: asset.AssetId;
+    /** Co-signer key override (33-byte compressed hex); see
+     * {@link resolveEmulatorPubkey}. */
+    emulatorPubkey?: string;
 }): Promise<{
     /** The encoded offer, hex. **Persist this** — it is the only input
      * `cancelOffer` needs to rebuild the covenant, and the restore scan reads

package/dist/index.js

@@ -72,7 +72,7 @@ import {
   unilateralRefundWithoutReceiverDelay,
   verifyLockupAddress,
   verifyReceiveInvoice
-} from "./chunk-C5P7R7JT.js";
+} from "./chunk-HLMMA3LJ.js";
 
 // src/offer.ts
 import { hex } from "@scure/base";
@@ -83,7 +83,9 @@ import {
   RestIndexerProvider,
   arkade,
   asset,
-  getNetwork
+  getNetwork,
+  resolveEmulatorPubkey,
+  toXOnlySignerHex
 } from "@arkade-os/sdk";
 
 // src/swap-want-asset.program.json
@@ -311,14 +313,6 @@ var FIELDS = {
   offerAsset: { tag: 11, width: void 0 }
 };
 var NAMES = Object.fromEntries(Object.entries(FIELDS).map(([k, f]) => [f.tag, k]));
-var XONLY_LEN = 32;
-var xOnly = (key, label) => {
-  if (key.length === XONLY_LEN) return key;
-  if (key.length !== 33 || key[0] !== 2 && key[0] !== 3) {
-    throw new Error(`${label} is not a compressed or x-only public key`);
-  }
-  return key.slice(1);
-};
 function tlv(type, value) {
   if (value.length > 65535) throw new Error("TLV value exceeds the u16 length field");
   return concatBytes(Uint8Array.of(type, value.length >> 8 & 255, value.length & 255), value);
@@ -420,7 +414,7 @@ async function registerOfferContract(wallet, arkServerUrl, network, binding, ser
   });
   await promoteOfferContract(contractManager, hex.encode(expectedPkScript));
 }
-async function createOffer(wallet, arkServerUrl, emulatorPubkey, params) {
+async function createOffer(wallet, arkServerUrl, params) {
   if (Boolean(params.wantAsset) === Boolean(params.offerAsset)) {
     throw new Error("set exactly one of wantAsset (BTC->asset) or offerAsset (asset->BTC)");
   }
@@ -429,8 +423,11 @@ async function createOffer(wallet, arkServerUrl, emulatorPubkey, params) {
     wallet.getAddress(),
     wallet.identity.xOnlyPublicKey()
   ]);
-  const serverPubKey = xOnly(hex.decode(info.signerPubkey), "ark signer key");
-  const emuKey = xOnly(emulatorPubkey, "emulator pubkey");
+  const serverPubKey = hex.decode(toXOnlySignerHex(info.signerPubkey));
+  const network = getNetwork(info.network);
+  const emuKey = hex.decode(
+    toXOnlySignerHex(resolveEmulatorPubkey(network, params.emulatorPubkey))
+  );
   const binding = {
     wantAmount: params.wantAmount,
     wantAsset: params.wantAsset,
@@ -455,7 +452,7 @@ async function createOffer(wallet, arkServerUrl, emulatorPubkey, params) {
     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(getNetwork(info.network).hrp, serverPubKey).encode(),
+    address: script.address(network.hrp, serverPubKey).encode(),
     swapPkScript: script.pkScript
   };
 }

package/dist/nostr.d.cts

@@ -1,4 +1,4 @@
-import { b as RfqTransport } from './rfq-CRgIOQ_y.cjs';
+import { b as RfqTransport } from './rfq-CCAFoFtR.cjs';
 import { SimplePool } from 'nostr-tools';
 import '@arkade-os/sdk';
 import '@arkade-os/solver-discovery';

package/dist/nostr.d.ts

@@ -1,4 +1,4 @@
-import { b as RfqTransport } from './rfq-CRgIOQ_y.js';
+import { b as RfqTransport } from './rfq-CCAFoFtR.js';
 import { SimplePool } from 'nostr-tools';
 import '@arkade-os/sdk';
 import '@arkade-os/solver-discovery';

package/dist/nostr.js

@@ -1,6 +1,6 @@
 import {
   SwapRefusal
-} from "./chunk-C5P7R7JT.js";
+} from "./chunk-HLMMA3LJ.js";
 
 // src/nostr.ts
 import {

package/dist/{rfq-CRgIOQ_y.d.cts → rfq-CCAFoFtR.d.cts}

@@ -706,10 +706,7 @@ declare function lightningSendVtxoScript(params: {
      * {@link unilateralRefundDelay} and {@link unilateralRefundWithoutReceiverDelay}
      * derive from this same value — one rounding, shared across all three tiers. */
     claimDelay: number;
-    /** Emulator x-only key — the SOLVER's deployment, not the trader's own.
-     * Not fetched here or anywhere in this package; see {@link
-     * requestLightningSend}'s `emulatorPubkey` parameter for where it comes
-     * from and why. */
+    /** Emulator x-only key (32 bytes). */
     emulatorPubkey: Uint8Array;
     /** Where a refund must pay: the trader's P2TR pkScript (34 bytes). Also
      * `nonInteractiveRefund`'s covenant destination. */
@@ -765,21 +762,12 @@ interface InvoiceFacts {
  * cooperation, not just infrastructure uptime, so losing the key with an
  * unwilling solver is a total loss.
  */
-declare function requestLightningSend(wallet: IWallet, arkServerUrl: string, 
-/** Covenant co-signer (emulator) x-only key — the SOLVER's deployment,
- * not the trader's. This library does NOT fetch or verify it: clients
- * have no network path to the emulator, only the solver and covclaimd
- * do. The caller must obtain this out-of-band, before calling this
- * function, from the solver's signed registry/corridor card (its
- * `emulator_pubkey`, added in arkade-os/solver-registry#18) or an
- * equivalent source it
- * independently trusts, and is responsible for having checked it against
- * that trusted value itself — the same never-trust-only-compare rule as
- * {@link verifyLockupAddress}, just applied by the caller instead of
- * here, because there is nothing in this module to derive it against. */
-emulatorPubkey: Uint8Array, transport: RfqTransport, params: {
+declare function requestLightningSend(wallet: IWallet, arkServerUrl: string, transport: RfqTransport, params: {
     invoice: InvoiceFacts;
     rfqId?: string;
+    /** Co-signer key override (33-byte compressed hex); see
+     * {@link resolveEmulatorPubkey}. */
+    emulatorPubkey?: string;
 }): Promise<{
     rfqId: string;
     quote: RfqQuote;
@@ -925,10 +913,7 @@ declare function deriveOnchainSend(input: {
  *   `claimOnchainFill`) before `htlc.refundLocktime`. Missing that window
  *   forfeits the fill and falls back to the Arkade covenant refund.
  */
-declare function requestOnchainSend(wallet: IWallet, arkServerUrl: string, 
-/** Covenant co-signer (emulator) x-only key — same parameter, same
- * caller obligation, as {@link requestLightningSend}'s. */
-emulatorPubkey: Uint8Array, transport: RfqTransport, params: {
+declare function requestOnchainSend(wallet: IWallet, arkServerUrl: string, transport: RfqTransport, params: {
     amount: number;
     amountSide: "from" | "to";
     /** User's x-only L1 key that will claim the HTLC. */
@@ -936,6 +921,9 @@ emulatorPubkey: Uint8Array, transport: RfqTransport, params: {
     /** Optional caller-owned P. Persist it with the returned secrets before funding. */
     preimage?: Uint8Array;
     rfqId?: string;
+    /** Co-signer key override (33-byte compressed hex); see
+     * {@link resolveEmulatorPubkey}. */
+    emulatorPubkey?: string;
 }): Promise<{
     rfqId: string;
     quote: RfqQuote;
@@ -1101,12 +1089,12 @@ declare function deriveLightningReceive(input: {
  * Pay before `invoiceExpiresAt`: the hold-invoice window is minutes, not the
  * quote's `valid_until`.
  */
-declare function requestLightningReceive(wallet: IWallet, arkServerUrl: string, 
-/** Covenant co-signer (emulator) x-only key — same parameter, same
- * caller obligation, as {@link requestLightningSend}'s. */
-emulatorPubkey: Uint8Array, transport: RfqTransport, params: {
+declare function requestLightningReceive(wallet: IWallet, arkServerUrl: string, transport: RfqTransport, params: {
     amount: number;
     amountSide: "from" | "to";
+    /** Co-signer key override (33-byte compressed hex); see
+     * {@link resolveEmulatorPubkey}. */
+    emulatorPubkey?: string;
     /** covclaimd's 33-byte compressed pubkey (from its own info endpoint)
      * — the claim packet seals to it and only it can ever read `P` early. */
     covclaimdPubkey: Uint8Array;
@@ -1186,12 +1174,12 @@ declare function deriveOnchainReceive(input: {
  * `refundPubkey`) opens at `htlc.refundLocktime` — `buildHtlcRefund` takes it
  * back from there.
  */
-declare function requestOnchainReceive(wallet: IWallet, arkServerUrl: string, 
-/** Covenant co-signer (emulator) x-only key — same parameter, same
- * caller obligation, as {@link requestLightningSend}'s. */
-emulatorPubkey: Uint8Array, transport: RfqTransport, params: {
+declare function requestOnchainReceive(wallet: IWallet, arkServerUrl: string, transport: RfqTransport, params: {
     amount: number;
     amountSide: "from" | "to";
+    /** Co-signer key override (33-byte compressed hex); see
+     * {@link resolveEmulatorPubkey}. */
+    emulatorPubkey?: string;
     /** Trader's x-only L1 key for the HTLC's refund leaf. */
     refundPubkey: Uint8Array;
     /** covclaimd's 33-byte compressed pubkey — see {@link requestLightningReceive}. */

package/dist/{rfq-CRgIOQ_y.d.ts → rfq-CCAFoFtR.d.ts}

@@ -706,10 +706,7 @@ declare function lightningSendVtxoScript(params: {
      * {@link unilateralRefundDelay} and {@link unilateralRefundWithoutReceiverDelay}
      * derive from this same value — one rounding, shared across all three tiers. */
     claimDelay: number;
-    /** Emulator x-only key — the SOLVER's deployment, not the trader's own.
-     * Not fetched here or anywhere in this package; see {@link
-     * requestLightningSend}'s `emulatorPubkey` parameter for where it comes
-     * from and why. */
+    /** Emulator x-only key (32 bytes). */
     emulatorPubkey: Uint8Array;
     /** Where a refund must pay: the trader's P2TR pkScript (34 bytes). Also
      * `nonInteractiveRefund`'s covenant destination. */
@@ -765,21 +762,12 @@ interface InvoiceFacts {
  * cooperation, not just infrastructure uptime, so losing the key with an
  * unwilling solver is a total loss.
  */
-declare function requestLightningSend(wallet: IWallet, arkServerUrl: string, 
-/** Covenant co-signer (emulator) x-only key — the SOLVER's deployment,
- * not the trader's. This library does NOT fetch or verify it: clients
- * have no network path to the emulator, only the solver and covclaimd
- * do. The caller must obtain this out-of-band, before calling this
- * function, from the solver's signed registry/corridor card (its
- * `emulator_pubkey`, added in arkade-os/solver-registry#18) or an
- * equivalent source it
- * independently trusts, and is responsible for having checked it against
- * that trusted value itself — the same never-trust-only-compare rule as
- * {@link verifyLockupAddress}, just applied by the caller instead of
- * here, because there is nothing in this module to derive it against. */
-emulatorPubkey: Uint8Array, transport: RfqTransport, params: {
+declare function requestLightningSend(wallet: IWallet, arkServerUrl: string, transport: RfqTransport, params: {
     invoice: InvoiceFacts;
     rfqId?: string;
+    /** Co-signer key override (33-byte compressed hex); see
+     * {@link resolveEmulatorPubkey}. */
+    emulatorPubkey?: string;
 }): Promise<{
     rfqId: string;
     quote: RfqQuote;
@@ -925,10 +913,7 @@ declare function deriveOnchainSend(input: {
  *   `claimOnchainFill`) before `htlc.refundLocktime`. Missing that window
  *   forfeits the fill and falls back to the Arkade covenant refund.
  */
-declare function requestOnchainSend(wallet: IWallet, arkServerUrl: string, 
-/** Covenant co-signer (emulator) x-only key — same parameter, same
- * caller obligation, as {@link requestLightningSend}'s. */
-emulatorPubkey: Uint8Array, transport: RfqTransport, params: {
+declare function requestOnchainSend(wallet: IWallet, arkServerUrl: string, transport: RfqTransport, params: {
     amount: number;
     amountSide: "from" | "to";
     /** User's x-only L1 key that will claim the HTLC. */
@@ -936,6 +921,9 @@ emulatorPubkey: Uint8Array, transport: RfqTransport, params: {
     /** Optional caller-owned P. Persist it with the returned secrets before funding. */
     preimage?: Uint8Array;
     rfqId?: string;
+    /** Co-signer key override (33-byte compressed hex); see
+     * {@link resolveEmulatorPubkey}. */
+    emulatorPubkey?: string;
 }): Promise<{
     rfqId: string;
     quote: RfqQuote;
@@ -1101,12 +1089,12 @@ declare function deriveLightningReceive(input: {
  * Pay before `invoiceExpiresAt`: the hold-invoice window is minutes, not the
  * quote's `valid_until`.
  */
-declare function requestLightningReceive(wallet: IWallet, arkServerUrl: string, 
-/** Covenant co-signer (emulator) x-only key — same parameter, same
- * caller obligation, as {@link requestLightningSend}'s. */
-emulatorPubkey: Uint8Array, transport: RfqTransport, params: {
+declare function requestLightningReceive(wallet: IWallet, arkServerUrl: string, transport: RfqTransport, params: {
     amount: number;
     amountSide: "from" | "to";
+    /** Co-signer key override (33-byte compressed hex); see
+     * {@link resolveEmulatorPubkey}. */
+    emulatorPubkey?: string;
     /** covclaimd's 33-byte compressed pubkey (from its own info endpoint)
      * — the claim packet seals to it and only it can ever read `P` early. */
     covclaimdPubkey: Uint8Array;
@@ -1186,12 +1174,12 @@ declare function deriveOnchainReceive(input: {
  * `refundPubkey`) opens at `htlc.refundLocktime` — `buildHtlcRefund` takes it
  * back from there.
  */
-declare function requestOnchainReceive(wallet: IWallet, arkServerUrl: string, 
-/** Covenant co-signer (emulator) x-only key — same parameter, same
- * caller obligation, as {@link requestLightningSend}'s. */
-emulatorPubkey: Uint8Array, transport: RfqTransport, params: {
+declare function requestOnchainReceive(wallet: IWallet, arkServerUrl: string, transport: RfqTransport, params: {
     amount: number;
     amountSide: "from" | "to";
+    /** Co-signer key override (33-byte compressed hex); see
+     * {@link resolveEmulatorPubkey}. */
+    emulatorPubkey?: string;
     /** Trader's x-only L1 key for the HTLC's refund leaf. */
     refundPubkey: Uint8Array;
     /** covclaimd's 33-byte compressed pubkey — see {@link requestLightningReceive}. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkade-os/swap",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "type": "module",
   "description": "Client-side Arkade Intents asset swaps: discover markets, quote, create/track/cancel offers, restore from chain.",
   "repository": {