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

package/README.md

@@ -144,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 subpath adds a dependency: they take the SDK's structural `SQLExecutor` / `RealmLike`
-handles, so you pass the database you already opened.
+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
+```
+
+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
@@ -210,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
 

package/dist/{chunk-AM3NNUMR.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));
@@ -17,6 +18,7 @@ var L1_NETWORKS = {
   testnet: btc.TEST_NETWORK,
   regtest: { ...btc.TEST_NETWORK, bech32: "bcrt" }
 };
+var l1ScriptForAddress = (address, network) => btc.OutScript.encode(btc.Address(L1_NETWORKS[network]).decode(address));
 function onchainHtlcScript(params, network) {
   if (params.claimKey.length !== 32 || params.refundKey.length !== 32) {
     throw new Error("claimKey and refundKey must be 32-byte x-only keys");
@@ -199,7 +201,11 @@ async function classifyOnchainHtlc(chain, input) {
   const best = utxos.sort((a, b) => b.amount > a.amount ? 1 : -1)[0];
   if (!best) {
     if (!input.funding) return { phase: "unfunded" };
-    const spend = await chain.getSpendingTx(input.funding.txid, input.funding.vout);
+    const spend = await chain.getSpendingTx(
+      input.funding.txid,
+      input.funding.vout,
+      input.htlc.pkScript
+    );
     if (!spend) return { phase: "unfunded" };
     const preimage = extractPreimage(spend.txHex, input.htlc.paymentHash);
     const txid = btc.Transaction.fromRaw(hex.decode(spend.txHex), {
@@ -445,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");
   }
@@ -453,6 +463,43 @@ var assertFundable = (input) => {
   if (input.quote.refund_locktime !== void 0 && input.quote.refund_locktime - input.now < MIN_HEADROOM_SECONDS) {
     fail("insufficient_headroom", "refund deadline headroom below 90 minutes");
   }
+  if (input.maxFee) {
+    const { bps, sats, referenceRate } = input.maxFee;
+    if (bps === void 0 && sats === void 0) {
+      fail("max_fee_unbounded", "maxFee names neither bps nor sats");
+    }
+    if (bps !== void 0 && (!Number.isInteger(bps) || bps < 0 || bps > 1e4)) {
+      fail("max_fee_out_of_range", `maxFee.bps must be an integer in 0..10000, got ${bps}`);
+    }
+    if (sats !== void 0 && (!Number.isInteger(sats) || sats < 0)) {
+      fail("max_fee_out_of_range", `maxFee.sats must be a non-negative integer, got ${sats}`);
+    }
+    const legs = input.quote.pair.split("->");
+    const assetOf = (leg) => leg.slice(leg.indexOf(":") + 1);
+    const sameAsset = legs.length === 2 && assetOf(legs[0]) === assetOf(legs[1]);
+    if (!sameAsset && referenceRate === void 0) {
+      fail(
+        "fee_gate_unavailable",
+        `maxFee cannot gate ${input.quote.pair}: its legs name different assets, so from_amount - to_amount is not a fee. Supply maxFee.referenceRate (to-units per from-unit) from a source of your OWN \u2014 reading it off the solver's published feed would check the solver against its own number`
+      );
+    }
+    if (!sameAsset && (!Number.isFinite(referenceRate) || referenceRate <= 0)) {
+      fail(
+        "max_fee_out_of_range",
+        `maxFee.referenceRate must be a positive finite number, got ${referenceRate}`
+      );
+    }
+    const fee = sameAsset ? input.quote.from_amount - input.quote.to_amount : Math.ceil(
+      (input.quote.from_amount * referenceRate - input.quote.to_amount) / referenceRate
+    );
+    const allowed = Math.max(
+      sats ?? 0,
+      Math.floor(input.quote.from_amount * (bps ?? 0) / 1e4)
+    );
+    if (fee > allowed) {
+      fail("fee_too_high", `fee ${fee} exceeds the ${allowed} this client allows`);
+    }
+  }
   if (input.onchain) {
     const { htlcLocktime, minConfirmations, direction } = input.onchain;
     if (!Number.isInteger(minConfirmations) || minConfirmations < 1 || minConfirmations > MAX_MIN_CONFIRMATIONS) {
@@ -649,6 +696,43 @@ function lightningSendContract(params) {
     }
   });
 }
+function deriveLightningSend(input) {
+  const { quote } = input;
+  if (quote.refund_locktime === void 0) {
+    throw new Error("lightning-send quote is missing refund_locktime");
+  }
+  const receiverPkScriptHex = quote.profile?.receiver_pk_script;
+  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);
@@ -658,13 +742,6 @@ async function requestLightningSend(wallet, transport, params) {
   const quote = await transport.requestQuote(
     lightningSendRequest({ rfqId, invoice: params.invoice.raw, refundAddress, senderPubkey })
   );
-  if (quote.refund_locktime === void 0) {
-    throw new Error("lightning-send quote is missing refund_locktime");
-  }
-  const receiverPkScriptHex = quote.profile?.receiver_pk_script;
-  if (receiverPkScriptHex === void 0) {
-    throw new Error("lightning-send quote is missing profile.receiver_pk_script");
-  }
   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}`
@@ -677,32 +754,20 @@ async function requestLightningSend(wallet, transport, params) {
   }
   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,
-    operatorPubkey,
+  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,
-    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 }
-  };
+    claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
+    hrp: network.hrp
+  });
+  const { address, script, contractParams } = derived;
   assertFundable({
     quote,
     invoiceExpiresAt: params.invoice.expiresAt,
@@ -716,12 +781,12 @@ async function requestLightningSend(wallet, 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,
-    contractParams: matchedContractParams
+    contractParams
   };
 }
 var offerTermsFromQuote = (quote, assets) => {
@@ -848,6 +913,7 @@ async function requestOnchainSend(wallet, transport, params) {
       amountSide: params.amountSide
     })
   );
+  assertQuotedAmount(quote, params.amountSide, params.amount);
   const network = networkFromArkadeInfo(info);
   const derived = deriveOnchainSend({
     quote,
@@ -1234,8 +1300,11 @@ export {
   LOCKTIME_THRESHOLD,
   ONCHAIN_SECONDS_PER_BLOCK,
   ONCHAIN_DUST_SATS,
+  ONCHAIN_CLAIM_VSIZE,
   newPreimage,
   paymentHashOf,
+  L1_NETWORKS,
+  l1ScriptForAddress,
   onchainHtlcScript,
   buildHtlcClaim,
   buildHtlcRefund,
@@ -1281,6 +1350,7 @@ export {
   lightningSendContract,
   requestLightningSend,
   offerTermsFromQuote,
+  l1NetworkFromArk,
   onchainSendRequest,
   lightningReceiveRequest,
   onchainReceiveRequest,

package/dist/{chunk-6ZUS47GA.js → chunk-U7VWWTL6.js}

@@ -1,8 +1,9 @@
 // src/repository.ts
 var marketsCacheKey = (network, registry) => `arkade-intents-markets-${network}-${registry}`;
 var InMemoryAssetSwapRepository = class {
-  version = 4;
+  version = 5;
   swaps = /* @__PURE__ */ new Map();
+  records = /* @__PURE__ */ new Map();
   rfqSwaps = /* @__PURE__ */ new Map();
   scanned = /* @__PURE__ */ new Set();
   markets = /* @__PURE__ */ new Map();
@@ -24,6 +25,18 @@ var InMemoryAssetSwapRepository = class {
   async removeRfqSwap(rfqId) {
     this.rfqSwaps.delete(rfqId);
   }
+  async saveSwapRecord(record) {
+    this.records.set(record.id, record);
+  }
+  async getSwapRecord(id) {
+    return this.records.get(id);
+  }
+  async getAllSwapRecords() {
+    return [...this.records.values()];
+  }
+  async removeSwapRecord(id) {
+    this.records.delete(id);
+  }
   async getScannedTxids() {
     return new Set(this.scanned);
   }
@@ -39,6 +52,7 @@ var InMemoryAssetSwapRepository = class {
   async clear() {
     this.swaps.clear();
     this.rfqSwaps.clear();
+    this.records.clear();
     this.scanned.clear();
     this.markets.clear();
   }