@arkade-os/swap 0.0.5 → 0.0.7

package/dist/index.js

@@ -22,6 +22,7 @@ import {
   SWAP_LOCKUP_CONTRACT_LABEL,
   SWAP_LOCKUP_CONTRACT_TYPE,
   SwapRefusal,
+  arkadeAssetLeg,
   arkadeSwapRequest,
   assertFundable,
   assertReceivable,
@@ -59,7 +60,11 @@ import {
   unilateralRefundWithoutReceiverDelay,
   verifyLockupAddress,
   verifyReceiveInvoice
-} from "./chunk-Q4FAYBXS.js";
+} from "./chunk-ZDTRQZE2.js";
+import {
+  InMemoryAssetSwapRepository,
+  marketsCacheKey
+} from "./chunk-WGRU2DBF.js";
 
 // src/offer.ts
 import { hex as hex2 } from "@scure/base";
@@ -690,40 +695,6 @@ var validatePlan = (plan, giveBalance, dust) => {
   return void 0;
 };
 
-// src/repository.ts
-var marketsCacheKey = (network, registry) => `arkade-intents-markets-${network}-${registry}`;
-var InMemoryAssetSwapRepository = class {
-  version = 2;
-  swaps = /* @__PURE__ */ new Map();
-  scanned = /* @__PURE__ */ new Set();
-  markets = /* @__PURE__ */ new Map();
-  async saveSwap(swap) {
-    this.swaps.set(swap.id, swap);
-  }
-  async getAllSwaps() {
-    return [...this.swaps.values()];
-  }
-  async getScannedTxids() {
-    return new Set(this.scanned);
-  }
-  async markTxidsScanned(txids) {
-    for (const txid of txids) this.scanned.add(txid);
-  }
-  async getCachedMarkets(network, registry) {
-    return this.markets.get(marketsCacheKey(network, registry));
-  }
-  async saveCachedMarkets(network, registry, entry) {
-    this.markets.set(marketsCacheKey(network, registry), entry);
-  }
-  async clear() {
-    this.swaps.clear();
-    this.scanned.clear();
-    this.markets.clear();
-  }
-  async [Symbol.asyncDispose]() {
-  }
-};
-
 // src/indexedDbRepository.ts
 import { closeDatabase, openDatabase } from "@arkade-os/sdk";
 var DEFAULT_DB_NAME = "arkade-intents";
@@ -2207,6 +2178,60 @@ var outcomeOf = (swap) => {
 };
 var errorMessage = (error) => error instanceof Error ? error.message : String(error);
 var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
+
+// src/activity.ts
+var LABELS = {
+  lightning_send: "Lightning send",
+  lightning_receive: "Lightning receive",
+  onchain_send: "Onchain send"
+};
+var OUTCOME = {
+  pending: "pending",
+  // `claimable` and `claimed` are both in-progress states with no
+  // user-visible phase distinct from "pending". `needs_counterparty` is
+  // different in kind — the swap is BLOCKED, not merely in flight, since no
+  // unilateral trader move exists (see `RfqSwapState`). Collapsing it into
+  // `pending` here is a deliberate choice the opaque-token design permits —
+  // apps map tokens themselves — but a future reader weighing a `"blocked"`
+  // or `"stuck"` token should know this was already considered.
+  claimable: "pending",
+  claimed: "pending",
+  needs_counterparty: "pending",
+  settled: "settled",
+  refunded: "refunded",
+  failed: "failed"
+};
+function swapActivityResolver(deps) {
+  let byTxid = /* @__PURE__ */ new Map();
+  return {
+    id: "arkade:swap",
+    async prepare() {
+      const swaps = await deps.listSwaps();
+      const index = /* @__PURE__ */ new Map();
+      for (const swap of swaps) {
+        for (const txid of swap.txids) {
+          if (txid) index.set(txid, swap);
+        }
+      }
+      byTxid = index;
+    },
+    resolve(tx) {
+      const key = tx.key.arkTxid || tx.key.commitmentTxid || tx.key.boardingTxid;
+      const swap = key ? byTxid.get(key) : void 0;
+      if (!swap) return void 0;
+      const lostReceive = swap.kind === "lightning_receive" && swap.state === "refunded";
+      return [
+        {
+          groupId: `swap:${swap.rfqId}`,
+          label: LABELS[swap.kind],
+          kind: "swap",
+          outcome: lostReceive ? "lost" : OUTCOME[swap.state],
+          metadata: { rfqId: swap.rfqId, swapKind: swap.kind }
+        }
+      ];
+    }
+  };
+}
 export {
   ARKADE_ASSET,
   ARKADE_BTC,
@@ -2245,6 +2270,7 @@ export {
   SWAP_LOCKUP_CONTRACT_TYPE,
   SwapRefusal,
   addAssetSwap,
+  arkadeAssetLeg,
   arkadeSwapRequest,
   assertFundable,
   assertReceivable,
@@ -2306,6 +2332,7 @@ export {
   senderIdentityForSwapRecord,
   spendTxidsOf,
   spendUpdate,
+  swapActivityResolver,
   swapPrograms,
   swapSecretsToRecord,
   unilateralClaimDelay,

package/dist/nostr.cjs

@@ -91,6 +91,20 @@ var SwapRefusal = class extends Error {
   }
 };
 var MIN_HEADROOM_SECONDS = 90 * 60;
+var expectQuote = (payload, rfqId, requestedPair) => {
+  const p = payload;
+  if (p?.type === "rfq_refusal") throw new SwapRefusal(p.reason ?? "unknown", p.rfq_id ?? rfqId);
+  if (p?.type !== "rfq_quote" || p.rfq_id !== rfqId) {
+    throw new Error(`unexpected reply: ${p?.type ?? "no payload"}`);
+  }
+  if (requestedPair !== void 0 && p.pair !== requestedPair) {
+    throw new Error(
+      `solver quoted ${JSON.stringify(p.pair)}, not the requested ${requestedPair}`
+    );
+  }
+  return payload;
+};
+var pairOf = (payload) => typeof payload.pair === "string" ? payload.pair : void 0;
 var SEQUENCE_GRANULARITY_SECONDS = 512;
 var SOLO_REFUND_HEADROOM_SECONDS = 8 * SEQUENCE_GRANULARITY_SECONDS;
 var MIN_CLAIM_WINDOW_SECONDS = 30 * 60;
@@ -119,14 +133,6 @@ var closeReasons = (raw) => raw.map((entry) => {
   const { url, reason } = entry ?? {};
   return url ? `${url}: ${reason ?? "closed"}` : reason ?? "closed";
 });
-var asQuote = (payload, rfqId) => {
-  const p = payload;
-  if (p?.type === "rfq_refusal") throw new SwapRefusal(p.reason ?? "unknown", p.rfq_id ?? rfqId);
-  if (p?.type !== "rfq_quote" || p.rfq_id !== rfqId) {
-    throw new Error(`unexpected reply: ${p?.type ?? "no payload"}`);
-  }
-  return payload;
-};
 var nostrRfqTransport = (options) => {
   const relays = options.relays;
   const solverPubkey = options.solverPubkey;
@@ -202,7 +208,7 @@ var nostrRfqTransport = (options) => {
       const rfqId = String(payload.rfq_id);
       const reply = awaitReply(rfqId);
       await send(payload);
-      return asQuote(await reply, rfqId);
+      return expectQuote(await reply, rfqId, pairOf(payload));
     },
     async status(rfqId) {
       const reply = awaitReply(rfqId);

package/dist/nostr.d.cts

@@ -1,10 +1,11 @@
-import { a as RfqTransport } from './rfq-BH2yvo3O.cjs';
+import { a as RfqTransport } from './rfq-DfT9dAss.cjs';
 import { SimplePool } from 'nostr-tools';
 import '@arkade-os/sdk';
 
 /**
- * The Nostr RFQ transport — the PRODUCTION one (docs/rfq-protocol.md § 3.1 in
- * arkade-os/lightning-swap-service).
+ * The Nostr RFQ transport — the PRODUCTION one (the kind, the NIP-44 framing
+ * and the payloads it carries are public at
+ * https://docs.arkadeos.com/intents/reference/rfq).
  *
  * `rfq.ts` ships two other transports: `httpTransport`, and `relayTransport`
  * which speaks the dev broker's `{op:"sub"|"event"}` framing. Neither is what a

package/dist/nostr.d.ts

@@ -1,10 +1,11 @@
-import { a as RfqTransport } from './rfq-BH2yvo3O.js';
+import { a as RfqTransport } from './rfq-DfT9dAss.js';
 import { SimplePool } from 'nostr-tools';
 import '@arkade-os/sdk';
 
 /**
- * The Nostr RFQ transport — the PRODUCTION one (docs/rfq-protocol.md § 3.1 in
- * arkade-os/lightning-swap-service).
+ * The Nostr RFQ transport — the PRODUCTION one (the kind, the NIP-44 framing
+ * and the payloads it carries are public at
+ * https://docs.arkadeos.com/intents/reference/rfq).
  *
  * `rfq.ts` ships two other transports: `httpTransport`, and `relayTransport`
  * which speaks the dev broker's `{op:"sub"|"event"}` framing. Neither is what a

package/dist/nostr.js

@@ -1,6 +1,7 @@
 import {
-  SwapRefusal
-} from "./chunk-Q4FAYBXS.js";
+  expectQuote,
+  pairOf
+} from "./chunk-ZDTRQZE2.js";
 
 // src/nostr.ts
 import {
@@ -32,14 +33,6 @@ var closeReasons = (raw) => raw.map((entry) => {
   const { url, reason } = entry ?? {};
   return url ? `${url}: ${reason ?? "closed"}` : reason ?? "closed";
 });
-var asQuote = (payload, rfqId) => {
-  const p = payload;
-  if (p?.type === "rfq_refusal") throw new SwapRefusal(p.reason ?? "unknown", p.rfq_id ?? rfqId);
-  if (p?.type !== "rfq_quote" || p.rfq_id !== rfqId) {
-    throw new Error(`unexpected reply: ${p?.type ?? "no payload"}`);
-  }
-  return payload;
-};
 var nostrRfqTransport = (options) => {
   const relays = options.relays;
   const solverPubkey = options.solverPubkey;
@@ -115,7 +108,7 @@ var nostrRfqTransport = (options) => {
       const rfqId = String(payload.rfq_id);
       const reply = awaitReply(rfqId);
       await send(payload);
-      return asQuote(await reply, rfqId);
+      return expectQuote(await reply, rfqId, pairOf(payload));
     },
     async status(rfqId) {
       const reply = awaitReply(rfqId);

package/dist/repositories/realm/index.cjs

@@ -0,0 +1,138 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/repositories/realm/index.ts
+var realm_exports = {};
+__export(realm_exports, {
+  ArkadeAssetSwapMarketsCacheSchema: () => ArkadeAssetSwapMarketsCacheSchema,
+  ArkadeAssetSwapScannedTxidSchema: () => ArkadeAssetSwapScannedTxidSchema,
+  ArkadeAssetSwapSchema: () => ArkadeAssetSwapSchema,
+  AssetSwapRealmSchemas: () => AssetSwapRealmSchemas,
+  RealmAssetSwapRepository: () => RealmAssetSwapRepository
+});
+module.exports = __toCommonJS(realm_exports);
+
+// src/repository.ts
+var marketsCacheKey = (network, registry) => `arkade-intents-markets-${network}-${registry}`;
+
+// src/repositories/realm/repository.ts
+var SWAPS = "ArkadeAssetSwap";
+var SCANNED = "ArkadeAssetSwapScannedTxid";
+var MARKETS = "ArkadeAssetSwapMarketsCache";
+var RealmAssetSwapRepository = class {
+  constructor(realm) {
+    this.realm = realm;
+  }
+  realm;
+  version = 2;
+  async saveSwap(swap) {
+    this.realm.write(() => {
+      this.realm.create(
+        SWAPS,
+        {
+          id: swap.id,
+          status: swap.status,
+          createdAt: swap.createdAt,
+          data: JSON.stringify(swap)
+        },
+        "modified"
+      );
+    });
+  }
+  async getAllSwaps() {
+    return [...this.realm.objects(SWAPS)].map(
+      (o) => JSON.parse(o.data)
+    );
+  }
+  async getScannedTxids() {
+    return new Set([...this.realm.objects(SCANNED)].map((o) => o.txid));
+  }
+  async markTxidsScanned(txids) {
+    this.realm.write(() => {
+      for (const txid of txids) this.realm.create(SCANNED, { txid }, "modified");
+    });
+  }
+  async getCachedMarkets(network, registry) {
+    const [row] = [
+      ...this.realm.objects(MARKETS).filtered("key == $0", marketsCacheKey(network, registry))
+    ];
+    return row ? JSON.parse(row.data) : void 0;
+  }
+  async saveCachedMarkets(network, registry, entry) {
+    this.realm.write(() => {
+      this.realm.create(
+        MARKETS,
+        { key: marketsCacheKey(network, registry), data: JSON.stringify(entry) },
+        "modified"
+      );
+    });
+  }
+  /** All three schemas in one write: clearing swaps but keeping scanned txids
+   * would leave the restore scan permanently skipping those funding txs, so
+   * a partial clear must not be observable. */
+  async clear() {
+    this.realm.write(() => {
+      for (const name of [SWAPS, SCANNED, MARKETS]) {
+        this.realm.delete(this.realm.objects(name));
+      }
+    });
+  }
+  async [Symbol.asyncDispose]() {
+  }
+};
+
+// src/repositories/realm/schemas.ts
+var ArkadeAssetSwapSchema = {
+  name: "ArkadeAssetSwap",
+  primaryKey: "id",
+  properties: {
+    id: "string",
+    status: "string",
+    createdAt: "int",
+    data: "string"
+  }
+};
+var ArkadeAssetSwapScannedTxidSchema = {
+  name: "ArkadeAssetSwapScannedTxid",
+  primaryKey: "txid",
+  properties: {
+    txid: "string"
+  }
+};
+var ArkadeAssetSwapMarketsCacheSchema = {
+  name: "ArkadeAssetSwapMarketsCache",
+  primaryKey: "key",
+  properties: {
+    key: "string",
+    data: "string"
+  }
+};
+var AssetSwapRealmSchemas = [
+  ArkadeAssetSwapSchema,
+  ArkadeAssetSwapScannedTxidSchema,
+  ArkadeAssetSwapMarketsCacheSchema
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArkadeAssetSwapMarketsCacheSchema,
+  ArkadeAssetSwapScannedTxidSchema,
+  ArkadeAssetSwapSchema,
+  AssetSwapRealmSchemas,
+  RealmAssetSwapRepository
+});

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

@@ -0,0 +1,103 @@
+import { RealmLike } from '@arkade-os/sdk/repositories/realm';
+import { A as AssetSwapRepository, a as AssetSwap, M as MarketsCacheEntry } from '../../repository-BwnZ8N62.cjs';
+import '@arkade-os/solver-discovery';
+import '@arkade-os/sdk';
+
+/**
+ * Realm backend for React Native.
+ *
+ * `realm` is not a dependency of this package: consumers open Realm with the
+ * schemas from `./schemas.ts` and pass the instance, validated against the
+ * shared `RealmLike` shape from `@arkade-os/sdk`.
+ *
+ * **Records are serialized as JSON**, whole, into a `data` property —
+ * `status` and `createdAt` are mapped out for querying only, so no field of a
+ * record can be dropped. That holds for JSON-safe values: a consumer-added
+ * `Date` comes back a string and a `bigint` throws on save, unlike the
+ * IndexedDB backend's structured clone. `AssetSwap` itself is JSON-safe by
+ * design.
+ *
+ * Realm creates the schemas on open, so there is nothing to initialise. The
+ * consumer owns the Realm lifecycle — `[Symbol.asyncDispose]` is a no-op.
+ */
+declare class RealmAssetSwapRepository implements AssetSwapRepository {
+    private readonly realm;
+    readonly version: 2;
+    constructor(realm: RealmLike);
+    saveSwap(swap: AssetSwap): Promise<void>;
+    getAllSwaps(): Promise<AssetSwap[]>;
+    getScannedTxids(): Promise<Set<string>>;
+    markTxidsScanned(txids: Iterable<string>): Promise<void>;
+    getCachedMarkets(network: string, registry: string): Promise<MarketsCacheEntry | undefined>;
+    saveCachedMarkets(network: string, registry: string, entry: MarketsCacheEntry): Promise<void>;
+    /** All three schemas in one write: clearing swaps but keeping scanned txids
+     * would leave the restore scan permanently skipping those funding txs, so
+     * a partial clear must not be observable. */
+    clear(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+
+/**
+ * Realm object schemas for the asset-swap repository.
+ *
+ * The names land in the **consuming application's** schema namespace, next to
+ * its own models and the SDK's `Ark*` / the Boltz plugin's `Boltz*`, so they
+ * are prefixed with `ArkadeAssetSwap`. Unlike the SQLite backend there is no
+ * prefix option: a Realm schema name is baked into the schema objects the
+ * consumer registers and into every `realm.objects(…)` call here.
+ *
+ * Since `realm` is not a dependency of this package, schemas are plain JS
+ * objects conforming to Realm's ObjectSchema shape. They are new, so a consumer
+ * adds them to its Realm config and bumps its own `schemaVersion`; no migration
+ * helper ships here.
+ */
+declare const ArkadeAssetSwapSchema: {
+    name: string;
+    primaryKey: string;
+    properties: {
+        id: string;
+        status: string;
+        createdAt: string;
+        data: string;
+    };
+};
+declare const ArkadeAssetSwapScannedTxidSchema: {
+    name: string;
+    primaryKey: string;
+    properties: {
+        txid: string;
+    };
+};
+declare const ArkadeAssetSwapMarketsCacheSchema: {
+    name: string;
+    primaryKey: string;
+    properties: {
+        key: string;
+        data: string;
+    };
+};
+declare const AssetSwapRealmSchemas: ({
+    name: string;
+    primaryKey: string;
+    properties: {
+        id: string;
+        status: string;
+        createdAt: string;
+        data: string;
+    };
+} | {
+    name: string;
+    primaryKey: string;
+    properties: {
+        txid: string;
+    };
+} | {
+    name: string;
+    primaryKey: string;
+    properties: {
+        key: string;
+        data: string;
+    };
+})[];
+
+export { ArkadeAssetSwapMarketsCacheSchema, ArkadeAssetSwapScannedTxidSchema, ArkadeAssetSwapSchema, AssetSwapRealmSchemas, RealmAssetSwapRepository };

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

@@ -0,0 +1,103 @@
+import { RealmLike } from '@arkade-os/sdk/repositories/realm';
+import { A as AssetSwapRepository, a as AssetSwap, M as MarketsCacheEntry } from '../../repository-BwnZ8N62.js';
+import '@arkade-os/solver-discovery';
+import '@arkade-os/sdk';
+
+/**
+ * Realm backend for React Native.
+ *
+ * `realm` is not a dependency of this package: consumers open Realm with the
+ * schemas from `./schemas.ts` and pass the instance, validated against the
+ * shared `RealmLike` shape from `@arkade-os/sdk`.
+ *
+ * **Records are serialized as JSON**, whole, into a `data` property —
+ * `status` and `createdAt` are mapped out for querying only, so no field of a
+ * record can be dropped. That holds for JSON-safe values: a consumer-added
+ * `Date` comes back a string and a `bigint` throws on save, unlike the
+ * IndexedDB backend's structured clone. `AssetSwap` itself is JSON-safe by
+ * design.
+ *
+ * Realm creates the schemas on open, so there is nothing to initialise. The
+ * consumer owns the Realm lifecycle — `[Symbol.asyncDispose]` is a no-op.
+ */
+declare class RealmAssetSwapRepository implements AssetSwapRepository {
+    private readonly realm;
+    readonly version: 2;
+    constructor(realm: RealmLike);
+    saveSwap(swap: AssetSwap): Promise<void>;
+    getAllSwaps(): Promise<AssetSwap[]>;
+    getScannedTxids(): Promise<Set<string>>;
+    markTxidsScanned(txids: Iterable<string>): Promise<void>;
+    getCachedMarkets(network: string, registry: string): Promise<MarketsCacheEntry | undefined>;
+    saveCachedMarkets(network: string, registry: string, entry: MarketsCacheEntry): Promise<void>;
+    /** All three schemas in one write: clearing swaps but keeping scanned txids
+     * would leave the restore scan permanently skipping those funding txs, so
+     * a partial clear must not be observable. */
+    clear(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+
+/**
+ * Realm object schemas for the asset-swap repository.
+ *
+ * The names land in the **consuming application's** schema namespace, next to
+ * its own models and the SDK's `Ark*` / the Boltz plugin's `Boltz*`, so they
+ * are prefixed with `ArkadeAssetSwap`. Unlike the SQLite backend there is no
+ * prefix option: a Realm schema name is baked into the schema objects the
+ * consumer registers and into every `realm.objects(…)` call here.
+ *
+ * Since `realm` is not a dependency of this package, schemas are plain JS
+ * objects conforming to Realm's ObjectSchema shape. They are new, so a consumer
+ * adds them to its Realm config and bumps its own `schemaVersion`; no migration
+ * helper ships here.
+ */
+declare const ArkadeAssetSwapSchema: {
+    name: string;
+    primaryKey: string;
+    properties: {
+        id: string;
+        status: string;
+        createdAt: string;
+        data: string;
+    };
+};
+declare const ArkadeAssetSwapScannedTxidSchema: {
+    name: string;
+    primaryKey: string;
+    properties: {
+        txid: string;
+    };
+};
+declare const ArkadeAssetSwapMarketsCacheSchema: {
+    name: string;
+    primaryKey: string;
+    properties: {
+        key: string;
+        data: string;
+    };
+};
+declare const AssetSwapRealmSchemas: ({
+    name: string;
+    primaryKey: string;
+    properties: {
+        id: string;
+        status: string;
+        createdAt: string;
+        data: string;
+    };
+} | {
+    name: string;
+    primaryKey: string;
+    properties: {
+        txid: string;
+    };
+} | {
+    name: string;
+    primaryKey: string;
+    properties: {
+        key: string;
+        data: string;
+    };
+})[];
+
+export { ArkadeAssetSwapMarketsCacheSchema, ArkadeAssetSwapScannedTxidSchema, ArkadeAssetSwapSchema, AssetSwapRealmSchemas, RealmAssetSwapRepository };

package/dist/repositories/realm/index.js

@@ -0,0 +1,108 @@
+import {
+  marketsCacheKey
+} from "../../chunk-WGRU2DBF.js";
+
+// src/repositories/realm/repository.ts
+var SWAPS = "ArkadeAssetSwap";
+var SCANNED = "ArkadeAssetSwapScannedTxid";
+var MARKETS = "ArkadeAssetSwapMarketsCache";
+var RealmAssetSwapRepository = class {
+  constructor(realm) {
+    this.realm = realm;
+  }
+  realm;
+  version = 2;
+  async saveSwap(swap) {
+    this.realm.write(() => {
+      this.realm.create(
+        SWAPS,
+        {
+          id: swap.id,
+          status: swap.status,
+          createdAt: swap.createdAt,
+          data: JSON.stringify(swap)
+        },
+        "modified"
+      );
+    });
+  }
+  async getAllSwaps() {
+    return [...this.realm.objects(SWAPS)].map(
+      (o) => JSON.parse(o.data)
+    );
+  }
+  async getScannedTxids() {
+    return new Set([...this.realm.objects(SCANNED)].map((o) => o.txid));
+  }
+  async markTxidsScanned(txids) {
+    this.realm.write(() => {
+      for (const txid of txids) this.realm.create(SCANNED, { txid }, "modified");
+    });
+  }
+  async getCachedMarkets(network, registry) {
+    const [row] = [
+      ...this.realm.objects(MARKETS).filtered("key == $0", marketsCacheKey(network, registry))
+    ];
+    return row ? JSON.parse(row.data) : void 0;
+  }
+  async saveCachedMarkets(network, registry, entry) {
+    this.realm.write(() => {
+      this.realm.create(
+        MARKETS,
+        { key: marketsCacheKey(network, registry), data: JSON.stringify(entry) },
+        "modified"
+      );
+    });
+  }
+  /** All three schemas in one write: clearing swaps but keeping scanned txids
+   * would leave the restore scan permanently skipping those funding txs, so
+   * a partial clear must not be observable. */
+  async clear() {
+    this.realm.write(() => {
+      for (const name of [SWAPS, SCANNED, MARKETS]) {
+        this.realm.delete(this.realm.objects(name));
+      }
+    });
+  }
+  async [Symbol.asyncDispose]() {
+  }
+};
+
+// src/repositories/realm/schemas.ts
+var ArkadeAssetSwapSchema = {
+  name: "ArkadeAssetSwap",
+  primaryKey: "id",
+  properties: {
+    id: "string",
+    status: "string",
+    createdAt: "int",
+    data: "string"
+  }
+};
+var ArkadeAssetSwapScannedTxidSchema = {
+  name: "ArkadeAssetSwapScannedTxid",
+  primaryKey: "txid",
+  properties: {
+    txid: "string"
+  }
+};
+var ArkadeAssetSwapMarketsCacheSchema = {
+  name: "ArkadeAssetSwapMarketsCache",
+  primaryKey: "key",
+  properties: {
+    key: "string",
+    data: "string"
+  }
+};
+var AssetSwapRealmSchemas = [
+  ArkadeAssetSwapSchema,
+  ArkadeAssetSwapScannedTxidSchema,
+  ArkadeAssetSwapMarketsCacheSchema
+];
+export {
+  ArkadeAssetSwapMarketsCacheSchema,
+  ArkadeAssetSwapScannedTxidSchema,
+  ArkadeAssetSwapSchema,
+  AssetSwapRealmSchemas,
+  RealmAssetSwapRepository
+};