@arkade-os/swap 0.0.12 → 0.1.0-rc.1

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
@@ -117,9 +144,25 @@ uncached discovery.
 | `IndexedDbAssetSwapRepository` | `@arkade-os/swap`                     | the browser (or a polyfilled IndexedDB)         |
 | `SQLiteAssetSwapRepository`    | `@arkade-os/swap/repositories/sqlite` | React Native, over your SQLite driver           |
 | `RealmAssetSwapRepository`     | `@arkade-os/swap/repositories/realm`  | React Native, over your Realm instance          |
+| `nodeSwapRepository()`         | `@arkade-os/swap/node`                | Node — file-backed SQLite, opened for you       |
+
+Neither React Native subpath adds a dependency: they take the SDK's structural `SQLExecutor` /
+`RealmLike` handles, so you pass the database you already opened.
+
+`@arkade-os/swap/node` is the exception, and the only entry point that imports `node:` builtins —
+which is why it is a separate subpath rather than something the main entry falls back to. It opens
+the database itself, under the platform config directory (XDG / `~/Library/Application Support` /
+`%APPDATA%`) at `arkade/swaps/swaps-<network>.sqlite`, and it is the one backend whose disposal
+closes a connection:
+
+```ts
+import { nodeSwapRepository } from "@arkade-os/swap/node";
+
+await using swaps = nodeSwapRepository({ network: "mainnet" }); // or { path } to choose the file
+```
 
-Neither subpath adds a dependency: they take the SDK's structural `SQLExecutor` / `RealmLike`
-handles, so you pass the database you already opened.
+Every other backend's `[Symbol.asyncDispose]` is a no-op, because you opened the handle and it is
+yours to close. This one opened it, so it closes it.
 
 All four carry both record types: asset swaps and the monitored RFQ swaps
 (`saveRfqSwap` / `getRfqSwap` / `getAllRfqSwaps` / `removeRfqSwap`). Each keeps them in a store of their own — a
@@ -128,8 +171,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
@@ -183,15 +226,17 @@ const realm = await Realm.open({
 const swaps = new RealmAssetSwapRepository(realm);
 ```
 
-Four classes land in your Realm namespace: `ArkadeAssetSwap`, `ArkadeRfqSwap`,
+Five classes land in your Realm namespace: `ArkadeAssetSwap`, `ArkadeRfqSwap`, `ArkadeSwapRecord`,
 `ArkadeAssetSwapScannedTxid`, `ArkadeAssetSwapMarketsCache`. Unlike SQLite there is no prefix option
 — a Realm schema name is baked into the schema objects you register — so reconcile against your own
 models by name.
 
-`ArkadeRfqSwap` arrived after the other three. **If you already shipped them, add it and bump
-`schemaVersion` again**: Realm creates schemas at open, so a config still listing three fails on the
-first RFQ read rather than at open. SQLite needs nothing — its DDL runs `CREATE TABLE IF NOT EXISTS`
-on every init, so the table appears on the next operation.
+`ArkadeRfqSwap` and `ArkadeSwapRecord` arrived after the first three. **If you already shipped an
+earlier set, add the new ones and bump `schemaVersion` again**: Realm creates schemas at open, so a
+config listing fewer fails on the first read of the missing one rather than at open. Spreading
+`AssetSwapRealmSchemas` rather than listing names by hand is what keeps that from happening again.
+SQLite needs nothing — its DDL runs `CREATE TABLE IF NOT EXISTS` on every init, so a new table
+appears on the next operation.
 
 ## Creating an offer
 
@@ -200,11 +245,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 +283,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 +305,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 +367,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 +440,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 +874,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 +946,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 +989,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 +1059,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 +1070,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-XXWOODUE.js → chunk-OEKSNYJW.js}

@@ -9,6 +9,7 @@ var MAX_MIN_CONFIRMATIONS = 6;
 var LOCKTIME_THRESHOLD = 5e8;
 var ONCHAIN_SECONDS_PER_BLOCK = 600;
 var ONCHAIN_DUST_SATS = BigInt(330);
+var ONCHAIN_CLAIM_VSIZE = 152;
 var newPreimage = () => crypto.getRandomValues(new Uint8Array(32));
 var paymentHashOf = (preimage) => hex.encode(sha256(preimage));
 var h160FromPaymentHash = (paymentHash) => ripemd160(hex.decode(paymentHash));
@@ -314,9 +315,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";
@@ -343,11 +343,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;
   }
@@ -448,6 +451,10 @@ var assertFundable = (input) => {
   const fail = (reason, message) => {
     throw gateError(reason, message);
   };
+  if (input.quote.valid_until === void 0) {
+    fail("quote_malformed", "quote carries no valid_until");
+  }
+  assertFinite(input.quote.valid_until, "quote_malformed", "quote valid_until");
   if (input.invoiceExpiresAt !== void 0 && input.now >= input.invoiceExpiresAt) {
     fail("invoice_expired", "invoice expired");
   }
@@ -650,22 +657,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)
@@ -673,7 +680,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),
@@ -689,15 +696,8 @@ function lightningSendVtxoScript(params) {
     }
   });
 }
-async function requestLightningSend(wallet, arkServerUrl, 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 quote = await transport.requestQuote(
-    lightningSendRequest({ rfqId, invoice: params.invoice.raw, refundAddress, senderPubkey })
-  );
+function deriveLightningSend(input) {
+  const { quote } = input;
   if (quote.refund_locktime === void 0) {
     throw new Error("lightning-send quote is missing refund_locktime");
   }
@@ -705,6 +705,43 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
   if (receiverPkScriptHex === void 0) {
     throw new Error("lightning-send quote is missing profile.receiver_pk_script");
   }
+  const contractParams = {
+    solverPubkey: toXOnly(hex3.decode(quote.solver_pubkey), "solver key"),
+    refundLocktime: quote.refund_locktime,
+    operatorPubkey: input.operatorPubkey,
+    paymentHash: input.paymentHash,
+    claimDelay: input.claimDelay,
+    emulatorPubkey: input.emulatorPubkey,
+    senderPubkey: input.senderPubkey,
+    receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
+    refundPkScript: input.refundPkScript
+  };
+  const matched = matchQuotedLockup(
+    quote,
+    input.hrp,
+    input.operatorPubkey,
+    (legacy) => lightningSendContract({ ...contractParams, ...legacy !== void 0 && { legacy } })
+  );
+  return {
+    address: matched.address,
+    swapPkScript: matched.script.pkScript,
+    script: matched.script,
+    contractParams: {
+      ...contractParams,
+      ...matched.legacy !== void 0 && { legacy: matched.legacy }
+    },
+    refundLocktime: quote.refund_locktime
+  };
+}
+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 wallet.getArkadeInfo({ requireLive: true });
+  const quote = await transport.requestQuote(
+    lightningSendRequest({ rfqId, invoice: params.invoice.raw, refundAddress, senderPubkey })
+  );
   if (quote.to_amount !== params.invoice.amountSats) {
     throw new Error(
       `quote to_amount ${quote.to_amount} does not match the invoice's ${params.invoice.amountSats}`
@@ -715,34 +752,22 @@ 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 = {
-    solverPubkey: toXOnly(hex3.decode(quote.solver_pubkey), "solver key"),
-    refundLocktime: quote.refund_locktime,
-    serverPubkey,
+  const operatorPubkey = toXOnly(hex3.decode(info.signerPubkey), "ark signer key");
+  const network = networkFromArkadeInfo(info);
+  const derived = deriveLightningSend({
+    quote,
     paymentHash: params.invoice.paymentHash,
-    claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
+    senderPubkey,
+    refundPkScript: secrets.pkScript,
+    operatorPubkey,
     emulatorPubkey: toXOnly(
       hex3.decode(resolveEmulatorPubkey(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
-    senderPubkey,
-    receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
-    refundPkScript: secrets.pkScript
-  };
-  const matched = matchQuotedLockup(
-    quote,
-    network.hrp,
-    serverPubkey,
-    (legacy) => lightningSendVtxoScript({ ...treeParams, ...legacy !== void 0 && { legacy } })
-  );
-  const script = matched.script;
-  const address = matched.address;
-  const matchedTreeParams = {
-    ...treeParams,
-    ...matched.legacy !== void 0 && { legacy: matched.legacy }
-  };
+    claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
+    hrp: network.hrp
+  });
+  const { address, script, contractParams } = derived;
   assertFundable({
     quote,
     invoiceExpiresAt: params.invoice.expiresAt,
@@ -756,12 +781,12 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
     // What the lockup must carry: the quote's `from_amount` — the invoice
     // PLUS the corridor's fee, never the bare invoice amount.
     fundAmount: quote.from_amount,
-    swapPkScript: script.pkScript,
+    swapPkScript: derived.swapPkScript,
     script,
     refundAddress,
     senderPubkey,
     secrets,
-    treeParams: matchedTreeParams
+    contractParams
   };
 }
 var offerTermsFromQuote = (quote, assets) => {
@@ -826,10 +851,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,
@@ -840,8 +865,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,
@@ -863,7 +888,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) {
@@ -874,7 +899,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(
@@ -889,12 +914,12 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
-  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"
@@ -931,6 +956,7 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
     htlcParams: derived.htlcParams,
     l1Network: derived.l1Network,
     minConfirmations: derived.minConfirmations,
+    refundLocktime: derived.refundLocktime,
     senderPubkey,
     secrets
   };
@@ -1002,7 +1028,7 @@ var assertReceivable = (input) => {
     );
   }
 };
-function receiveVtxoScript(params) {
+function lightningReceiveContract(params) {
   const seconds = (value) => ({
     type: "seconds",
     value: BigInt(value)
@@ -1010,7 +1036,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),
@@ -1035,10 +1061,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,
@@ -1049,8 +1075,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,
@@ -1058,13 +1084,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) {
@@ -1076,7 +1102,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({
@@ -1095,13 +1121,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"
@@ -1135,7 +1161,7 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
     payoutAddress,
     payoutPubkey,
     secrets,
-    treeParams: derived.treeParams
+    contractParams: derived.contractParams
   };
 }
 function deriveOnchainReceive(input) {
@@ -1150,10 +1176,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,
@@ -1164,8 +1190,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(
     {
@@ -1187,7 +1216,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) {
@@ -1199,7 +1228,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({
@@ -1219,14 +1248,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"
@@ -1271,6 +1300,7 @@ export {
   LOCKTIME_THRESHOLD,
   ONCHAIN_SECONDS_PER_BLOCK,
   ONCHAIN_DUST_SATS,
+  ONCHAIN_CLAIM_VSIZE,
   newPreimage,
   paymentHashOf,
   L1_NETWORKS,
@@ -1317,9 +1347,10 @@ export {
   unilateralClaimDelay,
   unilateralRefundDelay,
   unilateralRefundWithoutReceiverDelay,
-  lightningSendVtxoScript,
+  lightningSendContract,
   requestLightningSend,
   offerTermsFromQuote,
+  l1NetworkFromArk,
   onchainSendRequest,
   lightningReceiveRequest,
   onchainReceiveRequest,
@@ -1328,7 +1359,7 @@ export {
   MIN_CLAIM_WINDOW_SECONDS,
   verifyReceiveInvoice,
   assertReceivable,
-  receiveVtxoScript,
+  lightningReceiveContract,
   deriveLightningReceive,
   requestLightningReceive,
   deriveOnchainReceive,