@arkade-os/swap 0.0.10 → 0.1.0-rc.0

package/README.md

@@ -12,6 +12,33 @@ React Native does not, so install `react-native-get-random-values` (or `expo-cry
 it before this package. `crypto.subtle` is not used. `EventSource` and `WebSocket` are needed only
 by the watch and relay transports, both of which take an injected implementation.
 
+The v2 swap client API is tracked in [V2_API.md](./V2_API.md). That document is
+the package-level developer UX note for the new client surface as it lands; the
+current README still documents the existing package exports and protocol
+building blocks.
+
+**The covenant-deriving entry points need a wallet and nothing else.** `createOffer`,
+`requestLightningSend`, `requestLightningReceive`, `requestOnchainSend` and
+`requestOnchainReceive` take their server facts from `wallet.getArkadeInfo()`: the network and
+signer key, plus the unilateral-exit delay for the four `request*` calls. The wallet is the single
+place that knows which server it speaks to, so there is no URL to thread through and no second
+`/v1/info` round-trip *per call*. Each entrypoint still performs its own live read (deliberately —
+covenant derivation requires live info and fails closed offline); a session creating many offers
+pays one read per offer until the SDK grows a `CachingClientTransport`-style memo (the NArk
+reference's answer), noted as follow-up on `ArkadeInfo`.
+
+No offer entrypoint here takes a server URL. `cancelOffer` and `watchOfferSwaps` need more than
+server info — cancel broadcasts the refund and falls back to the indexer for a deposit made
+before contract registration existed, and the watcher reads spending transactions — so they
+ask the wallet for those too: `wallet.getArkadeReader()` for chain reads and
+`wallet.getArkadeBroadcaster()` for `submitTx`/`finalizeTx`. On a service-worker wallet both
+are proxied to the worker, so these reads stay on the wallet's own connection.
+The RFQ restore/refund/claim helpers still take provider instances. An `ArkadeReader`
+satisfies their *indexer* parameter structurally — `restoreAssetSwaps` can be fed
+`await wallet.getArkadeReader()` today — while `arkadeRefunder` and `claim`/`refund` also
+want an ark provider (`getInfo` plus the broadcast pair), buildable from
+`wallet.getArkadeInfo()` and `wallet.getArkadeBroadcaster()`.
+
 ## Roles
 
 Arkade Intents names two participants:
@@ -76,7 +103,7 @@ funds an offer should keep cancelling within reach.
 
 1. **`offer`** — the swap covenant itself. Two program JSONs (want-BTC / want-asset), the
    `Offer` type, the TLV wire codec (`encodeOffer`/`decodeOffer`, `OFFER_PACKET_TYPE`), address
-   derivation (`offerVtxoScript`), and the user-side operations `createOffer`/`cancelOffer`. Identical
+   derivation (`offerContract`), and the user-side operations `createOffer`/`cancelOffer`. Identical
    offers always derive identical swap addresses — the program JSONs are hashed into the address,
    so their bytes are frozen (guarded by a golden test).
 2. **`markets`** — solver discovery and pricing guardrails: `discoverMarkets` (1-hour cached
@@ -128,8 +155,8 @@ Realm — since the two record types have different keys and no consumer wants t
 
 **Records are stored whole.** The SQLite and Realm backends serialize each record to **JSON** in a
 `data` column, with only `status` / `createdAt` (and an RFQ record's `state` / `updatedAt`) mapped
-out for querying — so a field they do not know about survives, which is what the `quote`-shaped
-extension in `MIGRATION.md` relies on. It is also what keeps an RFQ record's corridor `profile`
+out for querying — so a field they do not know about survives, which is what a consumer's
+cast-extended record relies on. It is also what keeps an RFQ record's corridor `profile`
 intact: `profile.hashlock` is a nested object holding the payment hash and any preimage material, and
 a field-mapped backend is exactly what would lose it. JSON is
 the boundary, though, and it is narrower than IndexedDB's structured clone: a `Date` in a
@@ -200,11 +227,11 @@ the rest:
 
 ```ts
 // BTC -> asset
-const o = await createOffer(wallet, ARK, { wantAmount: 1000n, wantAsset });
+const o = await createOffer(wallet, { 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, { wantAmount: 1000n, offerAsset });
+const o = await createOffer(wallet, { wantAmount: 1000n, offerAsset });
 await wallet.send({
     address: o.address,
     amount: 500,
@@ -238,7 +265,7 @@ offer bytes themselves are recoverable from the funding tx if the record is lost
 ## Live status
 
 ```ts
-const watcher = await watchOfferSwaps({ wallet, arkServerUrl: ARK, repository, onUpdate: render });
+const watcher = await watchOfferSwaps({ wallet, repository, onUpdate: render });
 // later
 watcher.stop();
 ```
@@ -260,7 +287,7 @@ repository.
 ## Cancelling: the refund path
 
 ```ts
-const txid = await cancelOffer(wallet, ARK, swap.offerHex, {
+const txid = await cancelOffer(wallet, swap.offerHex, {
     repository,
     fundingTxid: swap.fundingTxid,
     swapAddress: swap.swapAddress,
@@ -322,7 +349,7 @@ 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, httpTransport(solverUrl), {
+const swap = await requestLightningSend(wallet, httpTransport(solverUrl), {
     invoice: { raw: bolt11, paymentHash, amountSats, expiresAt },
 });
 // quote verified against the LOCAL derivation and gated; now fund and go offline:
@@ -395,7 +422,7 @@ import {
     swapSecretsToRecord,
 } from "@arkade-os/swap";
 
-const swap = await requestOnchainSend(wallet, arkServerUrl, httpTransport(solverUrl), {
+const swap = await requestOnchainSend(wallet, httpTransport(solverUrl), {
     amount: 100_000,
     amountSide: "to",
     payoutPubkey,
@@ -759,6 +786,23 @@ through their stored `preimageHex` or their HD descriptor, and `DB_VERSION` is u
 
 Notes from before 0.0.1, kept for consumers who tracked the branch.
 
+- **`refundIfUnresolved` reports an exited lockup, and its input gained `paymentHash`.**
+  `RefundOutcome` has a new `{ outcome: "exited"; outpoints; status }` variant: a lockup whose
+  outputs were unilaterally exited lives onchain under the VHTLC script, where no offchain refund
+  reaches it. It used to come back as `nothing_to_refund`, which reads as "already resolved" over
+  money still sitting at the script — the swept case gets `needs_recovery` for the same reason, and
+  this is deliberately **not** that variant: recovery into a fresh batch is a spend no batch can
+  make for an onchain output. Complete the unroll and spend the outputs onchain instead.
+
+  Two required changes for direct callers. The input gains **`paymentHash`** (`sha256(P)` hex — the
+  quote's `payment_hash`, which callers already hold): the exit is read through `readLockupFate`,
+  and the VHTLC script cannot supply it, since its `preimageHash` is a `hash160` of the same secret.
+  And the `indexer` parameter widened from `RefundIndexer` to **`LockupSpendIndexer`**, so it must
+  now carry `getVirtualTxs` as well as `getVtxos` — a real `RestIndexerProvider` already does.
+
+  A lockup funded in two sends of which only one exited reports `exited` for the whole thing and
+  leaves the live half unrefunded. That matches `RfqSwapManager`, which reports the same lockup
+  `exited` on the same any-output rule; the two must not disagree.
 - **`RfqSwapManager` can own its own persistence.** New optional
   `RfqSwapManagerDeps.repository`, new `restoreFromRepository()` and `pruneRetiredSwaps()`, and
   `addSwap(swap, origin?)` gains an optional second argument. Nothing narrows and nothing is
@@ -812,7 +856,7 @@ Notes from before 0.0.1, kept for consumers who tracked the branch.
   silently overwritten.
 - **`readLockupFate` names the spends it observed.** `claimed` and `returned` now carry
   `spends: readonly LockupSpend[]`, one per spent lockup output, with the `checkpointTxid` that
-  `spentBy` names and the `arkTxid` that rode it. History correlation wants `arkTxid`; the
+  `spentBy` names and the `txid` that rode it. History correlation wants `txid`; the
   checkpoint txid is the wrong value to correlate on alone. `unknown` and `open` claim no spend.
 
 - **Every derived address changed again, in both corridors — the unilateral ladder was re-spaced.**
@@ -884,8 +928,8 @@ stored?)`. The returned `ProvisionedKey` / `ProvisionedClaimSecret` replace `Swa
   quote at `verifyLockupAddress`. Upgrade both sides before expecting fills.
 - **`cancelOffer` and `restoreAssetSwaps` take an options object.** `cancelOffer(wallet, url,
 offerHex, { repository, fundingTxid?, swapAddress? })` — the repository is required because the
-  call now records its own outcome. `restoreAssetSwaps(indexer, txs, existingIds, { serverPubkey,
-scanned? })` — the server key is required because a spend is classified by rebuilding the
+  call now records its own outcome. `restoreAssetSwaps(indexer, txs, existingIds, { operatorPubkey,
+scanned? })` — the operator key is required because a spend is classified by rebuilding the
   covenant and matching the leaf it took.
 - **`isCancelSpend` is gone**, replaced by `classifySpend`, and `Tx.assets` with it. The old test
   read what a transaction moved, which a wallet reports as a _net_ delta: once the deposit is a
@@ -927,7 +971,7 @@ scanned? })` — the server key is required because a spend is classified by reb
             kind: "lightning_receive",
             lockupAddress: result.address,
             profile: {
-                ...rfqSecretsProfile(result.secrets, result.treeParams.paymentHash),
+                ...rfqSecretsProfile(result.secrets, result.contractParams.paymentHash),
                 expectedAmount: result.expectedAmount,
                 payoutAddress: result.payoutAddress,
             },
@@ -997,7 +1041,7 @@ scanned? })` — the server key is required because a spend is classified by reb
   when `persisted` is true — the callback is documented as following a persisted change, and a
   consumer caching from it must not run ahead of the store.
 - **`lightningSendProgram` and `htlcSendProgram` are gone** along with the program-artifact layer
-  they compiled. Derive scripts through `lightningSendVtxoScript` / `onchainHtlcScript`.
+  they compiled. Derive scripts through `lightningSendContract` / `onchainHtlcScript`.
 - **The receive corridors are wired, and the wire shape settled.** `lightningReceiveRequest` is
   new; `onchainReceiveRequest`'s profile now matches the shipped solver schema (`payment_hash`,
   `claim_packet`, `refund_pubkey`, `payout_address`, `payout_pubkey` — the earlier
@@ -1008,7 +1052,7 @@ scanned? })` — the server key is required because a spend is classified by reb
   corridor's fee — and refuses quotes whose `to_amount` reprices the invoice; solvers charge
   per-corridor fees on all four pairs, and funding the bare invoice amount underfunds by exactly
   the fee.
-- **`lightningSendVtxoScript` takes two new required fields**: `senderPubkey` (the trader's VHTLC
+- **`lightningSendContract` takes two new required fields**: `senderPubkey` (the trader's VHTLC
   sender key — generate, persist, see `requestLightningSend`) and `receiverPkScript` (the solver's
   claim destination, from `profile.receiver_pk_script`). Callers that built the lockup directly
   must supply both; callers going through `requestLightningSend` are unaffected.

package/dist/{chunk-5NPYNQ5V.js → chunk-AM3NNUMR.js}

@@ -309,9 +309,8 @@ import { hex as hex3 } from "@scure/base";
 import { ripemd160 as ripemd1602 } from "@noble/hashes/legacy.js";
 import {
   ArkAddress as ArkAddress2,
-  RestArkProvider,
   VHTLC,
-  getNetwork,
+  networkFromArkadeInfo,
   resolveEmulatorPubkey,
   toXOnly
 } from "@arkade-os/sdk";
@@ -338,11 +337,14 @@ 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 {
+  /** Literal-typed so the v2 error taxonomy's union discriminates on `name`
+   * — a `string` here collapses the discriminant for every member. Same value
+   * the constructor has always set, moved to a field initializer. */
+  name = "SwapRefusal";
   reason;
   rfqId;
   constructor(reason, rfqId) {
     super(`solver refused: ${reason}`);
-    this.name = "SwapRefusal";
     this.reason = reason;
     this.rfqId = rfqId;
   }
@@ -422,8 +424,22 @@ var assertPairLength = (pair) => {
 };
 var verifyLockupAddress = (quote, derivedAddress) => {
   const quoted = quote.profile?.lockup_address;
-  if (derivedAddress !== quoted) throw new AddressMismatch(derivedAddress, quoted);
-  return derivedAddress;
+  const candidates = Array.isArray(derivedAddress) ? derivedAddress : [derivedAddress];
+  const matched = candidates.find((address) => address === quoted);
+  if (matched === void 0) throw new AddressMismatch(candidates, quoted);
+  return matched;
+};
+var LOCKUP_SHAPE_VARIANTS = [void 0, "preTimelockedRefund"];
+var matchQuotedLockup = (quote, hrp, serverPubkey, build) => {
+  const candidates = LOCKUP_SHAPE_VARIANTS.map((legacy) => {
+    const script = build(legacy);
+    return { script, address: script.address(hrp, serverPubkey).encode(), legacy };
+  });
+  const matchedAddress = verifyLockupAddress(
+    quote,
+    candidates.map((candidate) => candidate.address)
+  );
+  return candidates.find((candidate) => candidate.address === matchedAddress);
 };
 var assertFundable = (input) => {
   const fail = (reason, message) => {
@@ -594,22 +610,22 @@ var relayTransport = (relayUrl, options) => {
 };
 var SEQUENCE_GRANULARITY_SECONDS = 512;
 var SOLO_REFUND_HEADROOM_SECONDS = 8 * SEQUENCE_GRANULARITY_SECONDS;
-var unilateralClaimDelay = (serverExitDelaySeconds) => {
-  if (!Number.isFinite(serverExitDelaySeconds) || serverExitDelaySeconds < SEQUENCE_GRANULARITY_SECONDS) {
+var unilateralClaimDelay = (operatorExitDelaySeconds) => {
+  if (!Number.isFinite(operatorExitDelaySeconds) || operatorExitDelaySeconds < SEQUENCE_GRANULARITY_SECONDS) {
     throw new Error(
-      `server exit delay must be at least ${SEQUENCE_GRANULARITY_SECONDS}s of seconds, got ${serverExitDelaySeconds}`
+      `operator exit delay must be at least ${SEQUENCE_GRANULARITY_SECONDS}s of seconds, got ${operatorExitDelaySeconds}`
     );
   }
-  if (serverExitDelaySeconds > 65535 * SEQUENCE_GRANULARITY_SECONDS - SOLO_REFUND_HEADROOM_SECONDS) {
+  if (operatorExitDelaySeconds > 65535 * SEQUENCE_GRANULARITY_SECONDS - SOLO_REFUND_HEADROOM_SECONDS) {
     throw new Error(
-      `server exit delay ${serverExitDelaySeconds}s exceeds what BIP68 can encode once the solo refund's headroom is stacked above it`
+      `operator exit delay ${operatorExitDelaySeconds}s exceeds what BIP68 can encode once the solo refund's headroom is stacked above it`
     );
   }
-  return Math.ceil(serverExitDelaySeconds / SEQUENCE_GRANULARITY_SECONDS) * SEQUENCE_GRANULARITY_SECONDS;
+  return Math.ceil(operatorExitDelaySeconds / SEQUENCE_GRANULARITY_SECONDS) * SEQUENCE_GRANULARITY_SECONDS;
 };
 var unilateralRefundDelay = (claimDelay) => claimDelay;
 var unilateralRefundWithoutReceiverDelay = (claimDelay) => claimDelay + SOLO_REFUND_HEADROOM_SECONDS;
-function lightningSendVtxoScript(params) {
+function lightningSendContract(params) {
   const seconds = (value) => ({
     type: "seconds",
     value: BigInt(value)
@@ -617,7 +633,7 @@ function lightningSendVtxoScript(params) {
   return new VHTLC.ScriptV2({
     sender: params.senderPubkey,
     receiver: params.solverPubkey,
-    server: params.serverPubkey,
+    server: params.operatorPubkey,
     preimageHash: ripemd1602(hex3.decode(params.paymentHash)),
     refundLocktime: BigInt(params.refundLocktime),
     unilateralClaimDelay: seconds(params.claimDelay),
@@ -625,22 +641,20 @@ function lightningSendVtxoScript(params) {
     unilateralRefundWithoutReceiverDelay: seconds(
       unilateralRefundWithoutReceiverDelay(params.claimDelay)
     ),
-    nonInteractiveClaim: {
+    nonInteractiveParameters: {
       receiverPkScript: params.receiverPkScript,
-      emulatorPubkey: params.emulatorPubkey
-    },
-    nonInteractiveRefund: {
       senderPkScript: params.refundPkScript,
-      emulatorPubkey: params.emulatorPubkey
+      emulatorPubkey: params.emulatorPubkey,
+      ...params.legacy !== void 0 && { legacy: params.legacy }
     }
   });
 }
-async function requestLightningSend(wallet, arkServerUrl, transport, params) {
+async function requestLightningSend(wallet, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
   const secrets = await provisionRefundKey(wallet);
   const senderPubkey = secrets.pubkey;
   const refundAddress = secrets.address;
-  const info = await new RestArkProvider(arkServerUrl).getInfo();
+  const info = await wallet.getArkadeInfo({ requireLive: true });
   const quote = await transport.requestQuote(
     lightningSendRequest({ rfqId, invoice: params.invoice.raw, refundAddress, senderPubkey })
   );
@@ -661,12 +675,12 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
       `quote from_amount ${quote.from_amount} is below the invoice amount \u2014 a negative spread is not a quote`
     );
   }
-  const serverPubkey = toXOnly(hex3.decode(info.signerPubkey), "ark signer key");
-  const network = getNetwork(info.network);
-  const treeParams = {
+  const operatorPubkey = toXOnly(hex3.decode(info.signerPubkey), "ark signer key");
+  const network = networkFromArkadeInfo(info);
+  const contractParams = {
     solverPubkey: toXOnly(hex3.decode(quote.solver_pubkey), "solver key"),
     refundLocktime: quote.refund_locktime,
-    serverPubkey,
+    operatorPubkey,
     paymentHash: params.invoice.paymentHash,
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
     emulatorPubkey: toXOnly(
@@ -677,9 +691,18 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
     receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
     refundPkScript: secrets.pkScript
   };
-  const script = lightningSendVtxoScript(treeParams);
-  const address = script.address(network.hrp, serverPubkey).encode();
-  verifyLockupAddress(quote, address);
+  const matched = matchQuotedLockup(
+    quote,
+    network.hrp,
+    operatorPubkey,
+    (legacy) => lightningSendContract({ ...contractParams, ...legacy !== void 0 && { legacy } })
+  );
+  const script = matched.script;
+  const address = matched.address;
+  const matchedContractParams = {
+    ...contractParams,
+    ...matched.legacy !== void 0 && { legacy: matched.legacy }
+  };
   assertFundable({
     quote,
     invoiceExpiresAt: params.invoice.expiresAt,
@@ -698,7 +721,7 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
     refundAddress,
     senderPubkey,
     secrets,
-    treeParams
+    contractParams: matchedContractParams
   };
 }
 var offerTermsFromQuote = (quote, assets) => {
@@ -763,19 +786,23 @@ function deriveOnchainSend(input) {
   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({
+  const contractParams = {
     solverPubkey: toXOnly(hex3.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
-    serverPubkey: input.serverPubkey,
+    operatorPubkey: input.operatorPubkey,
     paymentHash: input.paymentHash,
     claimDelay: input.claimDelay,
     emulatorPubkey: input.emulatorPubkey,
     senderPubkey: input.senderPubkey,
     receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
     refundPkScript: ArkAddress2.decode(input.refundAddress).pkScript
-  });
-  const address = script.address(input.hrp, input.serverPubkey).encode();
-  verifyLockupAddress(quote, address);
+  };
+  const { script, address } = matchQuotedLockup(
+    quote,
+    input.hrp,
+    input.operatorPubkey,
+    (legacy) => lightningSendContract({ ...contractParams, ...legacy !== void 0 && { legacy } })
+  );
   const htlcParams = {
     paymentHash: input.paymentHash,
     claimKey: input.payoutPubkey,
@@ -796,7 +823,7 @@ function deriveOnchainSend(input) {
     minConfirmations
   };
 }
-async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
+async function requestOnchainSend(wallet, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
   const secrets = await provisionClaimSecret(wallet, { preimage: params.preimage });
   if (secrets.mustPersistPreimage) {
@@ -807,7 +834,7 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
   const paymentHash = hex3.encode(secrets.paymentHash);
   const senderPubkey = secrets.pubkey;
   const [info, refundAddress] = await Promise.all([
-    new RestArkProvider(arkServerUrl).getInfo(),
+    wallet.getArkadeInfo({ requireLive: true }),
     wallet.getAddress()
   ]);
   const quote = await transport.requestQuote(
@@ -821,12 +848,12 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
       amountSide: params.amountSide
     })
   );
-  const network = getNetwork(info.network);
+  const network = networkFromArkadeInfo(info);
   const derived = deriveOnchainSend({
     quote,
     paymentHash,
     payoutPubkey: params.payoutPubkey,
-    serverPubkey: toXOnly(hex3.decode(info.signerPubkey), "ark signer key"),
+    operatorPubkey: toXOnly(hex3.decode(info.signerPubkey), "ark signer key"),
     emulatorPubkey: toXOnly(
       hex3.decode(resolveEmulatorPubkey(network, params.emulatorPubkey)),
       "emulator signer key"
@@ -863,6 +890,7 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
     htlcParams: derived.htlcParams,
     l1Network: derived.l1Network,
     minConfirmations: derived.minConfirmations,
+    refundLocktime: derived.refundLocktime,
     senderPubkey,
     secrets
   };
@@ -934,7 +962,7 @@ var assertReceivable = (input) => {
     );
   }
 };
-function receiveVtxoScript(params) {
+function lightningReceiveContract(params) {
   const seconds = (value) => ({
     type: "seconds",
     value: BigInt(value)
@@ -942,7 +970,7 @@ function receiveVtxoScript(params) {
   return new VHTLC.ScriptV2({
     sender: params.solverPubkey,
     receiver: params.payoutPubkey,
-    server: params.serverPubkey,
+    server: params.operatorPubkey,
     preimageHash: ripemd1602(hex3.decode(params.paymentHash)),
     refundLocktime: BigInt(params.refundLocktime),
     unilateralClaimDelay: seconds(params.claimDelay),
@@ -950,13 +978,11 @@ function receiveVtxoScript(params) {
     unilateralRefundWithoutReceiverDelay: seconds(
       unilateralRefundWithoutReceiverDelay(params.claimDelay)
     ),
-    nonInteractiveClaim: {
+    nonInteractiveParameters: {
       receiverPkScript: params.payoutPkScript,
-      emulatorPubkey: params.emulatorPubkey
-    },
-    nonInteractiveRefund: {
       senderPkScript: params.solverRefundPkScript,
-      emulatorPubkey: params.emulatorPubkey
+      emulatorPubkey: params.emulatorPubkey,
+      ...params.legacy !== void 0 && { legacy: params.legacy }
     }
   });
 }
@@ -969,10 +995,10 @@ function deriveLightningReceive(input) {
   if (refundLocktime === void 0 || invoice === void 0 || solverRefundPkScriptHex === void 0) {
     throw new Error("lightning-receive quote is missing a binding field");
   }
-  const treeParams = {
+  const contractParams = {
     solverPubkey: toXOnly(hex3.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
-    serverPubkey: input.serverPubkey,
+    operatorPubkey: input.operatorPubkey,
     paymentHash: input.paymentHash,
     claimDelay: input.claimDelay,
     emulatorPubkey: input.emulatorPubkey,
@@ -980,12 +1006,25 @@ function deriveLightningReceive(input) {
     payoutPubkey: input.payoutPubkey,
     payoutPkScript: ArkAddress2.decode(input.payoutAddress).pkScript
   };
-  const script = receiveVtxoScript(treeParams);
-  const address = script.address(input.hrp, input.serverPubkey).encode();
-  verifyLockupAddress(quote, address);
-  return { address, swapPkScript: script.pkScript, script, invoice, refundLocktime, treeParams };
+  const matched = matchQuotedLockup(
+    quote,
+    input.hrp,
+    input.operatorPubkey,
+    (legacy) => lightningReceiveContract({ ...contractParams, ...legacy !== void 0 && { legacy } })
+  );
+  return {
+    address: matched.address,
+    swapPkScript: matched.script.pkScript,
+    script: matched.script,
+    invoice,
+    refundLocktime,
+    contractParams: {
+      ...contractParams,
+      ...matched.legacy !== void 0 && { legacy: matched.legacy }
+    }
+  };
 }
-async function requestLightningReceive(wallet, arkServerUrl, transport, params) {
+async function requestLightningReceive(wallet, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
   const secrets = await provisionClaimSecret(wallet);
   if (secrets.mustPersistPreimage) {
@@ -997,7 +1036,7 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
   const paymentHash = hex3.encode(secrets.paymentHash);
   const payoutPubkey = secrets.pubkey;
   const [info, payoutAddress] = await Promise.all([
-    new RestArkProvider(arkServerUrl).getInfo(),
+    wallet.getArkadeInfo({ requireLive: true }),
     wallet.getAddress()
   ]);
   const claimPacket = await sealClaimPacket({
@@ -1016,13 +1055,13 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
-  const network = getNetwork(info.network);
+  const network = networkFromArkadeInfo(info);
   const derived = deriveLightningReceive({
     quote,
     paymentHash,
     payoutPubkey,
     payoutAddress,
-    serverPubkey: toXOnly(hex3.decode(info.signerPubkey), "ark signer key"),
+    operatorPubkey: toXOnly(hex3.decode(info.signerPubkey), "ark signer key"),
     emulatorPubkey: toXOnly(
       hex3.decode(resolveEmulatorPubkey(network, params.emulatorPubkey)),
       "emulator signer key"
@@ -1056,7 +1095,7 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
     payoutAddress,
     payoutPubkey,
     secrets,
-    treeParams: derived.treeParams
+    contractParams: derived.contractParams
   };
 }
 function deriveOnchainReceive(input) {
@@ -1071,19 +1110,26 @@ function deriveOnchainReceive(input) {
   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({
+  const contractParams = {
     solverPubkey: toXOnly(hex3.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
-    serverPubkey: input.serverPubkey,
+    operatorPubkey: input.operatorPubkey,
     paymentHash: input.paymentHash,
     claimDelay: input.claimDelay,
     emulatorPubkey: input.emulatorPubkey,
     solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
     payoutPubkey: input.payoutPubkey,
     payoutPkScript: ArkAddress2.decode(input.payoutAddress).pkScript
-  });
-  const address = script.address(input.hrp, input.serverPubkey).encode();
-  verifyLockupAddress(quote, address);
+  };
+  const { script, address } = matchQuotedLockup(
+    quote,
+    input.hrp,
+    input.operatorPubkey,
+    (legacy) => lightningReceiveContract({
+      ...contractParams,
+      ...legacy !== void 0 && { legacy }
+    })
+  );
   const htlc = onchainHtlcScript(
     {
       paymentHash: input.paymentHash,
@@ -1104,7 +1150,7 @@ function deriveOnchainReceive(input) {
     minConfirmations
   };
 }
-async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
+async function requestOnchainReceive(wallet, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
   const secrets = await provisionClaimSecret(wallet);
   if (secrets.mustPersistPreimage) {
@@ -1116,7 +1162,7 @@ async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
   const paymentHash = hex3.encode(secrets.paymentHash);
   const payoutPubkey = secrets.pubkey;
   const [info, payoutAddress] = await Promise.all([
-    new RestArkProvider(arkServerUrl).getInfo(),
+    wallet.getArkadeInfo({ requireLive: true }),
     wallet.getAddress()
   ]);
   const claimPacket = await sealClaimPacket({
@@ -1136,14 +1182,14 @@ async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
-  const network = getNetwork(info.network);
+  const network = networkFromArkadeInfo(info);
   const derived = deriveOnchainReceive({
     quote,
     paymentHash,
     payoutPubkey,
     payoutAddress,
     refundPubkey: params.refundPubkey,
-    serverPubkey: toXOnly(hex3.decode(info.signerPubkey), "ark signer key"),
+    operatorPubkey: toXOnly(hex3.decode(info.signerPubkey), "ark signer key"),
     emulatorPubkey: toXOnly(
       hex3.decode(resolveEmulatorPubkey(network, params.emulatorPubkey)),
       "emulator signer key"
@@ -1232,7 +1278,7 @@ export {
   unilateralClaimDelay,
   unilateralRefundDelay,
   unilateralRefundWithoutReceiverDelay,
-  lightningSendVtxoScript,
+  lightningSendContract,
   requestLightningSend,
   offerTermsFromQuote,
   onchainSendRequest,
@@ -1243,7 +1289,7 @@ export {
   MIN_CLAIM_WINDOW_SECONDS,
   verifyReceiveInvoice,
   assertReceivable,
-  receiveVtxoScript,
+  lightningReceiveContract,
   deriveLightningReceive,
   requestLightningReceive,
   deriveOnchainReceive,