@arkade-os/swap 0.0.12 → 0.0.14

package/dist/index.js

@@ -65,7 +65,7 @@ import {
   unilateralRefundWithoutReceiverDelay,
   verifyLockupAddress,
   verifyReceiveInvoice
-} from "./chunk-XXWOODUE.js";
+} from "./chunk-IFZOBTTG.js";
 import {
   InMemoryAssetSwapRepository,
   marketsCacheKey
@@ -1417,6 +1417,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
 import { base64 as base642, hex as hex6 } from "@scure/base";
 import {
   ArkAddress as ArkAddress3,
+  isContractVtxoEvent,
   RestIndexerProvider as RestIndexerProvider3,
   Transaction as Transaction2
 } from "@arkade-os/sdk";
@@ -1487,7 +1488,7 @@ async function watchOfferSwaps({
     }
   };
   const unsubscribe = manager.onContractEvent((event) => {
-    if (event.type !== "vtxo_spent") return;
+    if (!isContractVtxoEvent(event) || event.type !== "vtxo_spent") return;
     enqueue(() => handleSpend(event));
   });
   return {
@@ -1580,7 +1581,14 @@ var solverRendezvous = (markets, payoutCorridor, amountSats, fallbackEmulatorPub
 };
 
 // src/payment/solverOnchain.ts
-import { btcTarget, makeHandle, resolveSendAmount, tryResolveSendAmount } from "@arkade-os/sdk";
+import {
+  assertNoAssets,
+  assetsOf,
+  btcTarget,
+  makeHandle,
+  resolveSendAmount,
+  tryResolveSendAmount
+} from "@arkade-os/sdk";
 var SOLVER_ONCHAIN_RAIL = "solver-onchain";
 var solverOnchainRendezvous = (markets, amountSats, fallbackEmulatorPubkey) => solverRendezvous(markets, "onchain", amountSats, fallbackEmulatorPubkey);
 function solverOnchainRail(deps) {
@@ -1593,6 +1601,7 @@ function solverOnchainRail(deps) {
     id: SOLVER_ONCHAIN_RAIL,
     match: (req) => btcTarget(req.raw) !== void 0,
     available: async (req) => {
+      if (assetsOf(req).length > 0) return false;
       const address = btcTarget(req.raw);
       if (!address) return false;
       try {
@@ -1606,6 +1615,7 @@ function solverOnchainRail(deps) {
     },
     quote: async (req, ctx) => {
       const address = btcTarget(req.raw);
+      assertNoAssets(SOLVER_ONCHAIN_RAIL, req);
       const amount = resolveSendAmount(SOLVER_ONCHAIN_RAIL, req.raw, req.amount);
       const payoutPkScript = l1ScriptForAddress(address, deps.l1Network);
       const rendezvous = await rendezvousFor(amount);
@@ -1682,7 +1692,7 @@ function solverOnchainRail(deps) {
 }
 
 // src/payment/solverLightning.ts
-import { invoiceTarget, makeHandle as makeHandle2 } from "@arkade-os/sdk";
+import { assertNoAssets as assertNoAssets2, assetsOf as assetsOf2, invoiceTarget, makeHandle as makeHandle2 } from "@arkade-os/sdk";
 var SOLVER_LIGHTNING_RAIL = "solver-lightning";
 var factsOf = (raw, decode, now) => {
   const invoice = invoiceTarget(raw);
@@ -1704,12 +1714,14 @@ function solverLightningRail(deps) {
     id: SOLVER_LIGHTNING_RAIL,
     match: (req) => invoiceTarget(req.raw) !== void 0,
     available: async (req) => {
+      if (assetsOf2(req).length > 0) return false;
       const facts = factsOf(req.raw, deps.decodeInvoice, Math.floor(Date.now() / 1e3));
       if (!facts) return false;
       if (req.amount !== void 0 && req.amount !== facts.amountSats) return false;
       return await rendezvousFor(facts.amountSats) !== void 0;
     },
     quote: async (req, ctx) => {
+      assertNoAssets2(SOLVER_LIGHTNING_RAIL, req);
       const facts = factsOf(req.raw, deps.decodeInvoice, Math.floor(Date.now() / 1e3));
       if (!facts) {
         throw new Error(
@@ -1782,10 +1794,260 @@ function solverLightningRail(deps) {
   };
 }
 
-// src/claim.ts
-import { hex as hex10 } from "@scure/base";
+// src/payment/crossAsset.ts
+import {
+  arkTarget,
+  asset as assetExt,
+  assetsOf as assetsOf3,
+  makeHandle as makeHandle3,
+  resolveAssetAmount
+} from "@arkade-os/sdk";
+var CROSS_ASSET_RAIL = "cross-asset";
+var DEFAULT_CARRIER_SATS = 330;
+var parseAssetId = (assetId) => {
+  try {
+    return assetExt.AssetId.fromString(assetId);
+  } catch {
+    return void 0;
+  }
+};
+function crossAssetRail(deps) {
+  const planFor = async (asset2) => {
+    const markets = await deps.discover();
+    const found = findMarket(markets, BTC_ASSET_ID, asset2.assetId);
+    const market = found?.market;
+    if (!market) return void 0;
+    const plan = await deps.quote(market, found.give, asset2.amount);
+    const [balance, dust] = await Promise.all([deps.btcBalance(), deps.dust()]);
+    return { plan, error: validatePlan(plan, balance, dust) };
+  };
+  return {
+    id: CROSS_ASSET_RAIL,
+    match: (req) => arkTarget(req.raw) !== void 0,
+    available: async (req) => {
+      const assets = assetsOf3(req);
+      if (assets.length !== 1) return false;
+      const [asset2] = assets;
+      if (asset2.assetId === BTC_ASSET_ID) return false;
+      if (typeof asset2.amount !== "bigint" || asset2.amount <= 0n) return false;
+      if (!parseAssetId(asset2.assetId)) return false;
+      const planned = await planFor(asset2);
+      return planned !== void 0 && planned.error === void 0;
+    },
+    quote: async (req, ctx) => {
+      const payTo = arkTarget(req.raw);
+      const asset2 = resolveAssetAmount(CROSS_ASSET_RAIL, req);
+      const wantAsset = parseAssetId(asset2.assetId);
+      if (!wantAsset) {
+        throw new Error(
+          `${CROSS_ASSET_RAIL}: ${asset2.assetId} is not an asset id (expected 34 bytes of hex)`
+        );
+      }
+      const planned = await planFor(asset2);
+      if (!planned) {
+        throw new Error(`${CROSS_ASSET_RAIL}: no market swaps BTC into ${asset2.assetId}`);
+      }
+      if (planned.error) {
+        throw new Error(
+          `${CROSS_ASSET_RAIL}: cannot swap into ${asset2.assetId} \u2014 ${planned.error}`
+        );
+      }
+      const { plan } = planned;
+      if (!Number.isSafeInteger(Number(plan.deposit.atomic))) {
+        throw new Error(
+          `${CROSS_ASSET_RAIL}: deposit of ${plan.deposit.atomic} does not fit a JS number`
+        );
+      }
+      const depositSats = Number(plan.deposit.atomic);
+      const carrier = deps.carrierSats ?? DEFAULT_CARRIER_SATS;
+      return {
+        railId: CROSS_ASSET_RAIL,
+        // OPEN QUESTION for review: `total = amount + fee` forces the
+        // purchase price into `fee`, which reads as a service charge.
+        // A third field instead? `assets.spent` labels it correctly.
+        amount: carrier,
+        fee: depositSats,
+        total: depositSats + carrier,
+        assets: {
+          delivered: asset2,
+          spent: { assetId: BTC_ASSET_ID, amount: plan.deposit.atomic }
+        },
+        meta: {
+          market: plan.market.pair,
+          priceDisplay: plan.priceDisplay,
+          give: plan.give
+        },
+        send: async () => makeHandle3(CROSS_ASSET_RAIL, async (emit) => {
+          const offer = await createOffer(ctx.wallet, deps.arkServerUrl, {
+            wantAmount: asset2.amount,
+            wantAsset,
+            ...deps.emulatorPubkey ? { emulatorPubkey: deps.emulatorPubkey } : {}
+          });
+          const swap = {
+            phase: "quoted",
+            offerHex: offer.offerHex,
+            address: offer.address,
+            swapPkScript: offer.swapPkScript,
+            depositSats,
+            asset: asset2,
+            payTo,
+            plan
+          };
+          await deps.persist(swap);
+          await ctx.wallet.send({
+            address: offer.address,
+            amount: depositSats,
+            extensions: [offer.extension]
+          });
+          emit({ status: "sent" });
+          await deps.awaitFill(swap);
+          await deps.persist({ ...swap, phase: "filled" });
+          await deps.persist({ ...swap, phase: "paying" });
+          const txid = await ctx.wallet.send({
+            address: payTo,
+            amount: carrier,
+            assets: [asset2]
+          });
+          await deps.persist({ ...swap, phase: "settled", txid });
+          const result = {
+            railId: CROSS_ASSET_RAIL,
+            txid,
+            swapId: offer.offerHex
+          };
+          emit({ status: "settled", result });
+          return result;
+        })
+      };
+    }
+  };
+}
+
+// src/reveal.ts
+import { base64 as base643, hex as hex9 } from "@scure/base";
 import { ripemd160 } from "@noble/hashes/legacy.js";
-import { sha256 as sha2563 } from "@noble/hashes/sha2.js";
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+import { ArkAddress as ArkAddress4 } from "@arkade-os/sdk";
+var CovclaimdRevealError = class extends Error {
+  name = "CovclaimdRevealError";
+  status;
+  detail;
+  retryable;
+  constructor(what, status, detail) {
+    super(`covclaimd ${what} failed: ${status || "no response"} ${detail}`.trimEnd());
+    this.status = status;
+    this.detail = detail;
+    this.retryable = status === 0 || status === 429 || status >= 500;
+  }
+};
+var decodeKey = (value, field) => {
+  if (typeof value !== "string") throw new Error(`covclaimd info: ${field} is not a string`);
+  let bytes;
+  try {
+    bytes = hex9.decode(value);
+  } catch {
+    throw new Error(`covclaimd info: ${field} is not hex`);
+  }
+  if (bytes.length !== 33) {
+    throw new Error(`covclaimd info: ${field} must be 33-byte compressed, got ${bytes.length}`);
+  }
+  return bytes;
+};
+var LOOPBACK = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+var assertTransportSecure = (baseUrl, allowInsecureHttp) => {
+  const { protocol, hostname } = new URL(baseUrl);
+  if (protocol === "https:" || allowInsecureHttp) return;
+  if (protocol === "http:" && LOOPBACK.has(hostname)) return;
+  throw new Error(
+    `covclaimd URL must be https (got ${protocol}//${hostname}): the key it serves is the one the preimage gets sealed to. Pass allowInsecureHttp to override.`
+  );
+};
+var covclaimdClient = (baseUrl, options = {}) => {
+  assertTransportSecure(baseUrl, options.allowInsecureHttp === true);
+  const url = baseUrl.replace(/\/+$/, "");
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const send = async (what, path, init) => {
+    let response;
+    try {
+      response = await fetchImpl(`${url}${path}`, {
+        ...init,
+        // a redirect would move the key fetch off the vetted origin
+        redirect: "error",
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch (error) {
+      throw new CovclaimdRevealError(what, 0, String(error));
+    }
+    if (!response.ok) {
+      throw new CovclaimdRevealError(what, response.status, await response.text());
+    }
+    return response;
+  };
+  const readJson = async (what, response) => {
+    const body = await response.text();
+    try {
+      return JSON.parse(body);
+    } catch {
+      throw new CovclaimdRevealError(
+        what,
+        response.status,
+        `non-JSON body: ${body.slice(0, 200)}`
+      );
+    }
+  };
+  return {
+    async info() {
+      const response = await send("info", "/v1/preimage/covclaimd-pubkey", {
+        method: "GET"
+      });
+      const body = await readJson("info", response);
+      return {
+        covclaimdPubkey: decodeKey(body?.covclaimd_pub_key, "covclaimd_pub_key"),
+        emulatorPubkey: hex9.encode(decodeKey(body?.emulator_pub_key, "emulator_pub_key"))
+      };
+    },
+    async reveal(params) {
+      await send("reveal", "/v1/reveal", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          swap_address: params.swapAddress,
+          packet: { ciphertext: params.ciphertext, arkade_script: params.arkadeScript },
+          taptree: params.taptree
+        })
+      });
+    }
+  };
+};
+function revealFieldsFromScript(script) {
+  if (!script.nonInteractiveClaimArkadeScript) {
+    throw new Error("this covenant has no non-interactive claim leaf to reveal against");
+  }
+  return {
+    arkadeScript: base643.encode(script.nonInteractiveClaimArkadeScript),
+    taptree: hex9.encode(script.encode())
+  };
+}
+async function revealClaimPacket(client, input) {
+  const fields = revealFieldsFromScript(input.script);
+  if (hex9.encode(ArkAddress4.decode(input.address).pkScript) !== hex9.encode(input.script.pkScript)) {
+    throw new Error("address does not belong to this covenant");
+  }
+  if (hex9.encode(ripemd160(sha2562(input.preimage))) !== hex9.encode(input.script.options.preimageHash)) {
+    throw new Error("preimage does not match the covenant's payment hash");
+  }
+  const { ciphertext } = await sealClaimPacket({
+    preimage: input.preimage,
+    covclaimdPubkey: (await client.info()).covclaimdPubkey
+  });
+  await client.reveal({ swapAddress: input.address, ciphertext, ...fields });
+  return { ciphertext };
+}
+
+// src/claim.ts
+import { hex as hex11 } from "@scure/base";
+import { ripemd160 as ripemd1602 } from "@noble/hashes/legacy.js";
+import { sha256 as sha2564 } from "@noble/hashes/sha2.js";
 import {
   CSVMultisigTapscript as CSVMultisigTapscript2,
   claimWithPreimageIdentity,
@@ -1793,8 +2055,8 @@ import {
 } from "@arkade-os/sdk";
 
 // src/refund.ts
-import { base64 as base643, hex as hex9 } from "@scure/base";
-import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+import { base64 as base644, hex as hex10 } from "@scure/base";
+import { sha256 as sha2563 } from "@noble/hashes/sha2.js";
 import {
   CSVMultisigTapscript,
   ConditionWitness,
@@ -1851,7 +2113,7 @@ var LockupNeedsRecoveryError = class extends Error {
   }
 };
 async function findLockupVtxos(indexer, swapPkScript) {
-  const scripts = [hex9.encode(swapPkScript)];
+  const scripts = [hex10.encode(swapPkScript)];
   const [spendable, recoverable] = await Promise.all([
     indexer.getVtxos({ scripts, spendableOnly: true }),
     indexer.getVtxos({ scripts, recoverableOnly: true })
@@ -1877,13 +2139,13 @@ async function findLockupVtxos(indexer, swapPkScript) {
   }
   return out;
 }
-var hashesTo = (candidate, paymentHash) => hex9.encode(sha2562(candidate)) === paymentHash;
+var hashesTo = (candidate, paymentHash) => hex10.encode(sha2563(candidate)) === paymentHash;
 var candidateWitnessItems = (tx, inputIndex) => [
   ...getArkPsbtFields(tx, inputIndex, ConditionWitness).flat(),
   ...tx.getInput(inputIndex).finalScriptWitness ?? []
 ];
 async function readLockupFate(indexer, input) {
-  const { vtxos } = await indexer.getVtxos({ scripts: [hex9.encode(input.swapPkScript)] });
+  const { vtxos } = await indexer.getVtxos({ scripts: [hex10.encode(input.swapPkScript)] });
   const all = vtxos ?? [];
   if (all.length === 0) return { fate: "unknown" };
   const exited = all.filter((vtxo) => vtxo.isUnrolled && !hasTerminalSpend(vtxo));
@@ -1910,7 +2172,7 @@ async function readLockupFate(indexer, input) {
   for (const raw of txs) {
     let tx;
     try {
-      tx = Transaction3.fromPSBT(base643.decode(raw));
+      tx = Transaction3.fromPSBT(base644.decode(raw));
     } catch {
       continue;
     }
@@ -1918,7 +2180,7 @@ async function readLockupFate(indexer, input) {
     for (let i = 0; i < tx.inputsLength; i++) {
       const spent = tx.getInput(i);
       if (!spent.txid) continue;
-      const txid = hex9.encode(spent.txid);
+      const txid = hex10.encode(spent.txid);
       if (!all.some((vtxo) => vtxo.txid === txid && vtxo.vout === spent.index)) continue;
       for (const candidate of candidateWitnessItems(tx, i)) {
         if (hashesTo(candidate, input.paymentHash)) {
@@ -1947,7 +2209,7 @@ async function pushRefundWithoutReceiver(ark, input) {
   const info = await ark.getInfo();
   let serverUnrollScript;
   try {
-    serverUnrollScript = CSVMultisigTapscript.decode(hex9.decode(info.checkpointTapscript));
+    serverUnrollScript = CSVMultisigTapscript.decode(hex10.decode(info.checkpointTapscript));
   } catch {
     throw new Error("invalid checkpointTapscript from the Arkade server");
   }
@@ -1967,8 +2229,8 @@ async function pushRefundWithoutReceiver(ark, input) {
   );
   const signedArkTx = await input.sender.sign(arkTx);
   const submitted = await ark.submitTx(
-    base643.encode(signedArkTx.toPSBT()),
-    checkpoints.map((c) => base643.encode(c.toPSBT()))
+    base644.encode(signedArkTx.toPSBT()),
+    checkpoints.map((c) => base644.encode(c.toPSBT()))
   );
   assertSubmittedArkTxid(submitted, signedArkTx, "refundWithoutReceiver");
   const matched = matchServerCheckpoints(
@@ -1978,7 +2240,7 @@ async function pushRefundWithoutReceiver(ark, input) {
   );
   const finalCheckpoints = await Promise.all(
     matched.map(
-      async ({ server }) => base643.encode((await input.sender.sign(server, [0])).toPSBT())
+      async ({ server }) => base644.encode((await input.sender.sign(server, [0])).toPSBT())
     )
   );
   await ark.finalizeTx(submitted.arkTxid, finalCheckpoints);
@@ -2073,13 +2335,13 @@ async function pushClaim(ark, input) {
     }
   }
   const committed = input.script.options.preimageHash;
-  if (hex10.encode(ripemd160(sha2563(input.preimage))) !== hex10.encode(committed)) {
+  if (hex11.encode(ripemd1602(sha2564(input.preimage))) !== hex11.encode(committed)) {
     throw new Error("preimage does not match the covenant's payment hash");
   }
   const info = await ark.getInfo();
   let serverUnrollScript;
   try {
-    serverUnrollScript = CSVMultisigTapscript2.decode(hex10.decode(info.checkpointTapscript));
+    serverUnrollScript = CSVMultisigTapscript2.decode(hex11.decode(info.checkpointTapscript));
   } catch {
     throw new Error("invalid checkpointTapscript from the Arkade server");
   }
@@ -2198,7 +2460,10 @@ function arkadeRefunder(deps) {
 }
 
 // src/swapManager.ts
-import { hex as hex11 } from "@scure/base";
+import { hex as hex12 } from "@scure/base";
+import {
+  isContractVtxoEvent as isContractVtxoEvent2
+} from "@arkade-os/sdk";
 function nextOnchainAction(input) {
   switch (input.phase.phase) {
     case "unfunded":
@@ -2646,7 +2911,7 @@ var RfqSwapManager = class {
   // ── internals ────────────────────────────────────────────────────────────
   track(swap) {
     this.monitored.set(swap.rfqId, swap);
-    this.byLockupScript.set(hex11.encode(swap.lockupPkScript), swap);
+    this.byLockupScript.set(hex12.encode(swap.lockupPkScript), swap);
   }
   /** Drops the swap from BOTH indexes. The event index is the one that stops
    * a late event finding a swap that is gone; `pollSwap`'s own
@@ -2655,7 +2920,7 @@ var RfqSwapManager = class {
    * them from silently re-driving a cancelled swap. */
   untrack(rfqId) {
     const swap = this.monitored.get(rfqId);
-    if (swap) this.byLockupScript.delete(hex11.encode(swap.lockupPkScript));
+    if (swap) this.byLockupScript.delete(hex12.encode(swap.lockupPkScript));
     this.monitored.delete(rfqId);
     this.refundRefused.delete(rfqId);
     this.lastClaimError.delete(rfqId);
@@ -2688,6 +2953,7 @@ var RfqSwapManager = class {
         });
         return;
       }
+      if (!isContractVtxoEvent2(event)) return;
       const swap = this.byLockupScript.get(event.contractScript);
       if (!swap) return;
       void this.pollSwap(swap).catch(() => {
@@ -2717,7 +2983,7 @@ var RfqSwapManager = class {
     if (!lockup) {
       try {
         const [existing] = await contracts.getContracts({
-          script: hex11.encode(swap.lockupPkScript)
+          script: hex12.encode(swap.lockupPkScript)
         });
         if (existing) {
           this.registered.set(swap.rfqId, true);
@@ -2736,13 +3002,13 @@ var RfqSwapManager = class {
       );
       return;
     }
-    const script = hex11.encode(lockup.script.pkScript);
-    if (script !== hex11.encode(swap.lockupPkScript)) {
+    const script = hex12.encode(lockup.script.pkScript);
+    if (script !== hex12.encode(swap.lockupPkScript)) {
       this.registered.set(swap.rfqId, false);
       this.emitFailed(
         swap,
         new Error(
-          `swap ${swap.rfqId} lockup script ${script} does not match its lockupPkScript ${hex11.encode(swap.lockupPkScript)}`
+          `swap ${swap.rfqId} lockup script ${script} does not match its lockupPkScript ${hex12.encode(swap.lockupPkScript)}`
         )
       );
       return;
@@ -2761,7 +3027,7 @@ var RfqSwapManager = class {
    * script for its whole life. Best-effort — the swap is over either way. */
   retireContract(swap) {
     if (!this.deps.contracts || !this.registered.get(swap.rfqId)) return;
-    void this.deps.contracts.setContractWatchState(hex11.encode(swap.lockupPkScript), "retained").catch((error) => this.emitFailed(swap, error));
+    void this.deps.contracts.setContractWatchState(hex12.encode(swap.lockupPkScript), "retained").catch((error) => this.emitFailed(swap, error));
   }
   arm() {
     if (!this.running) return;
@@ -3235,9 +3501,9 @@ var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
 
 // src/activity.ts
 import {
-  ArkAddress as ArkAddress4
+  ArkAddress as ArkAddress5
 } from "@arkade-os/sdk";
-import { hex as hex12 } from "@scure/base";
+import { hex as hex13 } from "@scure/base";
 var LABELS = {
   lightning_send: "Lightning send",
   lightning_receive: "Lightning receive",
@@ -3312,7 +3578,7 @@ async function activityInputOf(record, indexer) {
 async function lockupTxids(indexer, record, wantFunding) {
   let script;
   try {
-    script = hex12.encode(ArkAddress4.decode(record.lockupAddress).pkScript);
+    script = hex13.encode(ArkAddress5.decode(record.lockupAddress).pkScript);
   } catch {
     return [];
   }
@@ -3333,6 +3599,8 @@ export {
   ARKADE_BTC,
   AddressMismatch,
   BTC_ASSET_ID,
+  CROSS_ASSET_RAIL,
+  CovclaimdRevealError,
   InMemoryAssetSwapRepository,
   IndexedDbAssetSwapRepository,
   LIGHTNING_BTC,
@@ -3389,8 +3657,10 @@ export {
   classifyDepositSpend,
   classifyOnchainHtlc,
   classifySpend,
+  covclaimdClient,
   createOffer,
   createRfqSwapRecord,
+  crossAssetRail,
   decodeOffer,
   deriveLightningReceive,
   deriveOnchainReceive,
@@ -3436,6 +3706,8 @@ export {
   requestOnchainSend,
   restoreAssetSwaps,
   retireSettledOfferContracts,
+  revealClaimPacket,
+  revealFieldsFromScript,
   rfqClaimSecretOf,
   rfqPair,
   rfqSecretsProfile,

package/dist/nostr.d.cts

@@ -1,4 +1,4 @@
-import { R as RfqTransport } from './rfq-DzsmhXX3.cjs';
+import { R as RfqTransport } from './rfq-CYfKvAPp.cjs';
 import { SimplePool } from 'nostr-tools';
 import '@arkade-os/sdk';
 

package/dist/nostr.d.ts

@@ -1,4 +1,4 @@
-import { R as RfqTransport } from './rfq-DzsmhXX3.js';
+import { R as RfqTransport } from './rfq-CYfKvAPp.js';
 import { SimplePool } from 'nostr-tools';
 import '@arkade-os/sdk';
 

package/dist/nostr.js

@@ -1,7 +1,7 @@
 import {
   expectQuote,
   pairOf
-} from "./chunk-XXWOODUE.js";
+} from "./chunk-IFZOBTTG.js";
 
 // src/nostr.ts
 import {

package/dist/repositories/realm/index.d.cts

@@ -1,8 +1,8 @@
 import { RealmLike } from '@arkade-os/sdk/repositories/realm';
-import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, M as MarketsCacheEntry } from '../../repository-DaK1RzRq.cjs';
+import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, M as MarketsCacheEntry } from '../../repository-Vfx65uF1.cjs';
 import '@arkade-os/solver-discovery';
 import '@arkade-os/sdk';
-import '../../rfq-DzsmhXX3.cjs';
+import '../../rfq-CYfKvAPp.cjs';
 
 /**
  * Realm backend for React Native.

package/dist/repositories/realm/index.d.ts

@@ -1,8 +1,8 @@
 import { RealmLike } from '@arkade-os/sdk/repositories/realm';
-import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, M as MarketsCacheEntry } from '../../repository-DlLvj_y6.js';
+import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, M as MarketsCacheEntry } from '../../repository-D5JoeqwB.js';
 import '@arkade-os/solver-discovery';
 import '@arkade-os/sdk';
-import '../../rfq-DzsmhXX3.js';
+import '../../rfq-CYfKvAPp.js';
 
 /**
  * Realm backend for React Native.

package/dist/repositories/sqlite/index.d.cts

@@ -1,8 +1,8 @@
 import { SQLExecutor } from '@arkade-os/sdk/repositories/sqlite';
-import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, M as MarketsCacheEntry } from '../../repository-DaK1RzRq.cjs';
+import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, M as MarketsCacheEntry } from '../../repository-Vfx65uF1.cjs';
 import '@arkade-os/solver-discovery';
 import '@arkade-os/sdk';
-import '../../rfq-DzsmhXX3.cjs';
+import '../../rfq-CYfKvAPp.cjs';
 
 /**
  * SQLite backend over the SDK's `SQLExecutor`, so any driver plugs in

package/dist/repositories/sqlite/index.d.ts

@@ -1,8 +1,8 @@
 import { SQLExecutor } from '@arkade-os/sdk/repositories/sqlite';
-import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, M as MarketsCacheEntry } from '../../repository-DlLvj_y6.js';
+import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, M as MarketsCacheEntry } from '../../repository-D5JoeqwB.js';
 import '@arkade-os/solver-discovery';
 import '@arkade-os/sdk';
-import '../../rfq-DzsmhXX3.js';
+import '../../rfq-CYfKvAPp.js';
 
 /**
  * SQLite backend over the SDK's `SQLExecutor`, so any driver plugs in

package/dist/{repository-DlLvj_y6.d.ts → repository-D5JoeqwB.d.ts}

@@ -1,6 +1,6 @@
 import { DiscoveredMarket } from '@arkade-os/solver-discovery';
 import { IWallet, ProvisionedKey, ProvisionedClaimSecret, RestArkProvider, RestIndexerProvider, VHTLC, Identity, IContractManager } from '@arkade-os/sdk';
-import { B as RfqStatus, R as RfqTransport, a as OnchainHtlc, f as ChainUtxo, C as ChainSource, v as OnchainHtlcPhase } from './rfq-DzsmhXX3.js';
+import { B as RfqStatus, R as RfqTransport, a as OnchainHtlc, f as ChainUtxo, C as ChainSource, v as OnchainHtlcPhase } from './rfq-CYfKvAPp.js';
 
 type AssetSwapStatus = "pending" | "cancelling" | "fulfilled" | "cancelled" | "recoverable" | "awaiting_fill" | "claimable" | "claimed" | "refunded_l1";
 /** The sentinel asset id for BTC itself, as opposed to a 68-hex asset id.

package/dist/{repository-DaK1RzRq.d.cts → repository-Vfx65uF1.d.cts}

@@ -1,6 +1,6 @@
 import { DiscoveredMarket } from '@arkade-os/solver-discovery';
 import { IWallet, ProvisionedKey, ProvisionedClaimSecret, RestArkProvider, RestIndexerProvider, VHTLC, Identity, IContractManager } from '@arkade-os/sdk';
-import { B as RfqStatus, R as RfqTransport, a as OnchainHtlc, f as ChainUtxo, C as ChainSource, v as OnchainHtlcPhase } from './rfq-DzsmhXX3.cjs';
+import { B as RfqStatus, R as RfqTransport, a as OnchainHtlc, f as ChainUtxo, C as ChainSource, v as OnchainHtlcPhase } from './rfq-CYfKvAPp.cjs';
 
 type AssetSwapStatus = "pending" | "cancelling" | "fulfilled" | "cancelled" | "recoverable" | "awaiting_fill" | "claimable" | "claimed" | "refunded_l1";
 /** The sentinel asset id for BTC itself, as opposed to a 68-hex asset id.