@arkade-os/swap 0.0.11 → 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,
@@ -829,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.**
@@ -901,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
@@ -944,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,
             },
@@ -1014,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
@@ -1025,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-RIC5ZTZK.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;
   }
@@ -608,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)
@@ -631,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),
@@ -647,12 +649,12 @@ function lightningSendVtxoScript(params) {
     }
   });
 }
-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 })
   );
@@ -673,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(
@@ -692,13 +694,13 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
   const matched = matchQuotedLockup(
     quote,
     network.hrp,
-    serverPubkey,
-    (legacy) => lightningSendVtxoScript({ ...treeParams, ...legacy !== void 0 && { legacy } })
+    operatorPubkey,
+    (legacy) => lightningSendContract({ ...contractParams, ...legacy !== void 0 && { legacy } })
   );
   const script = matched.script;
   const address = matched.address;
-  const matchedTreeParams = {
-    ...treeParams,
+  const matchedContractParams = {
+    ...contractParams,
     ...matched.legacy !== void 0 && { legacy: matched.legacy }
   };
   assertFundable({
@@ -719,7 +721,7 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
     refundAddress,
     senderPubkey,
     secrets,
-    treeParams: matchedTreeParams
+    contractParams: matchedContractParams
   };
 }
 var offerTermsFromQuote = (quote, assets) => {
@@ -784,10 +786,10 @@ 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 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,
@@ -798,8 +800,8 @@ function deriveOnchainSend(input) {
   const { script, address } = matchQuotedLockup(
     quote,
     input.hrp,
-    input.serverPubkey,
-    (legacy) => lightningSendVtxoScript({ ...treeParams, ...legacy !== void 0 && { legacy } })
+    input.operatorPubkey,
+    (legacy) => lightningSendContract({ ...contractParams, ...legacy !== void 0 && { legacy } })
   );
   const htlcParams = {
     paymentHash: input.paymentHash,
@@ -821,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) {
@@ -832,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(
@@ -846,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"
@@ -888,6 +890,7 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
     htlcParams: derived.htlcParams,
     l1Network: derived.l1Network,
     minConfirmations: derived.minConfirmations,
+    refundLocktime: derived.refundLocktime,
     senderPubkey,
     secrets
   };
@@ -959,7 +962,7 @@ var assertReceivable = (input) => {
     );
   }
 };
-function receiveVtxoScript(params) {
+function lightningReceiveContract(params) {
   const seconds = (value) => ({
     type: "seconds",
     value: BigInt(value)
@@ -967,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),
@@ -992,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,
@@ -1006,8 +1009,8 @@ function deriveLightningReceive(input) {
   const matched = matchQuotedLockup(
     quote,
     input.hrp,
-    input.serverPubkey,
-    (legacy) => receiveVtxoScript({ ...treeParams, ...legacy !== void 0 && { legacy } })
+    input.operatorPubkey,
+    (legacy) => lightningReceiveContract({ ...contractParams, ...legacy !== void 0 && { legacy } })
   );
   return {
     address: matched.address,
@@ -1015,13 +1018,13 @@ function deriveLightningReceive(input) {
     script: matched.script,
     invoice,
     refundLocktime,
-    treeParams: {
-      ...treeParams,
+    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) {
@@ -1033,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({
@@ -1052,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"
@@ -1092,7 +1095,7 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
     payoutAddress,
     payoutPubkey,
     secrets,
-    treeParams: derived.treeParams
+    contractParams: derived.contractParams
   };
 }
 function deriveOnchainReceive(input) {
@@ -1107,10 +1110,10 @@ 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 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,
@@ -1121,8 +1124,11 @@ function deriveOnchainReceive(input) {
   const { script, address } = matchQuotedLockup(
     quote,
     input.hrp,
-    input.serverPubkey,
-    (legacy) => receiveVtxoScript({ ...treeParams, ...legacy !== void 0 && { legacy } })
+    input.operatorPubkey,
+    (legacy) => lightningReceiveContract({
+      ...contractParams,
+      ...legacy !== void 0 && { legacy }
+    })
   );
   const htlc = onchainHtlcScript(
     {
@@ -1144,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) {
@@ -1156,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({
@@ -1176,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"
@@ -1272,7 +1278,7 @@ export {
   unilateralClaimDelay,
   unilateralRefundDelay,
   unilateralRefundWithoutReceiverDelay,
-  lightningSendVtxoScript,
+  lightningSendContract,
   requestLightningSend,
   offerTermsFromQuote,
   onchainSendRequest,
@@ -1283,7 +1289,7 @@ export {
   MIN_CLAIM_WINDOW_SECONDS,
   verifyReceiveInvoice,
   assertReceivable,
-  receiveVtxoScript,
+  lightningReceiveContract,
   deriveLightningReceive,
   requestLightningReceive,
   deriveOnchainReceive,