@arkade-os/swap 0.0.4 → 0.0.6

package/dist/index.js

@@ -17,6 +17,7 @@ import {
   ONCHAIN_SECONDS_PER_BLOCK,
   ONCHAIN_SEND_PAIR,
   RFQ_TERMINAL_STATES,
+  SOLO_REFUND_HEADROOM_SECONDS,
   SWAP_LOCKUP_CONTRACT_KIND,
   SWAP_LOCKUP_CONTRACT_LABEL,
   SWAP_LOCKUP_CONTRACT_TYPE,
@@ -58,7 +59,11 @@ import {
   unilateralRefundWithoutReceiverDelay,
   verifyLockupAddress,
   verifyReceiveInvoice
-} from "./chunk-DLM6BVTB.js";
+} from "./chunk-Q4FAYBXS.js";
+import {
+  InMemoryAssetSwapRepository,
+  marketsCacheKey
+} from "./chunk-WGRU2DBF.js";
 
 // src/offer.ts
 import { hex as hex2 } from "@scure/base";
@@ -203,6 +208,8 @@ async function retireSettledOfferContracts(manager, swaps) {
 
 // src/store.ts
 import { hex } from "@scure/base";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { contractPreimage } from "@arkade-os/sdk";
 var BTC_ASSET_ID = "btc";
 var byNewest = (a, b) => b.createdAt - a.createdAt;
 var getAssetSwapsOrThrow = async (repository) => {
@@ -257,8 +264,61 @@ var updateAssetSwapBestEffort = async (repository, id, changes) => {
 };
 var swapSecretsToRecord = (secrets) => ({
   signingDescriptor: secrets.descriptor,
-  ..."mustPersistPreimage" in secrets && secrets.mustPersistPreimage ? { preimageHex: hex.encode(secrets.preimage) } : {}
+  ..."mustPersistPreimage" in secrets && secrets.mustPersistPreimage ? { preimageHex: hex.encode(secrets.preimage) } : {},
+  ..."preimageSalt" in secrets && secrets.preimageSalt ? { preimageSaltHex: hex.encode(secrets.preimageSalt) } : {}
 });
+var decodeHex32 = (value, field) => {
+  const bytes = hex.decode(value);
+  if (bytes.length !== 32) {
+    throw new Error(`${field} must be 32 bytes, got ${bytes.length}`);
+  }
+  return bytes;
+};
+var PreimageNotRecoverableError = class extends Error {
+  constructor(reason, message, options) {
+    super(message, options);
+    this.reason = reason;
+  }
+  reason;
+  name = "PreimageNotRecoverableError";
+};
+var preimageForSwapRecord = async (wallet, record) => {
+  if (!record.signingDescriptor) {
+    throw new PreimageNotRecoverableError(
+      "no-secrets",
+      "this swap record carries no signing descriptor"
+    );
+  }
+  let stored;
+  let salt;
+  try {
+    stored = record.preimageHex ? decodeHex32(record.preimageHex, "preimageHex") : void 0;
+    salt = record.preimageSaltHex ? decodeHex32(record.preimageSaltHex, "preimageSaltHex") : void 0;
+  } catch (cause) {
+    throw new PreimageNotRecoverableError(
+      "malformed-record",
+      `this swap record's secrets projection is unreadable: ${String(cause)}`,
+      { cause }
+    );
+  }
+  let preimage;
+  try {
+    preimage = await contractPreimage(wallet, record.signingDescriptor, { stored, salt });
+  } catch (cause) {
+    throw new PreimageNotRecoverableError(
+      "not-derivable",
+      `this wallet cannot produce the preimage for ${record.signingDescriptor}`,
+      { cause }
+    );
+  }
+  if (record.paymentHash && hex.encode(sha256(preimage)) !== record.paymentHash.toLowerCase()) {
+    throw new PreimageNotRecoverableError(
+      "hash-mismatch",
+      "the derived preimage does not match this swap's payment hash: wrong wallet, or a tampered salt"
+    );
+  }
+  return preimage;
+};
 
 // src/offer.ts
 var swapPrograms = {
@@ -634,40 +694,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 = 1;
-  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";
@@ -699,7 +725,7 @@ var IndexedDbAssetSwapRepository = class {
     this.dbName = dbName;
   }
   dbName;
-  version = 1;
+  version = 2;
   // the promise, not the resolved database: openDatabase bumps a refcount on
   // every call including cache hits, while dispose closes once, so two
   // concurrent first calls would strand the refcount above zero and leak the
@@ -1025,7 +1051,7 @@ async function watchOfferSwaps({
 // src/claim.ts
 import { hex as hex6 } from "@scure/base";
 import { ripemd160 } from "@noble/hashes/legacy.js";
-import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+import { sha256 as sha2563 } from "@noble/hashes/sha2.js";
 import {
   CSVMultisigTapscript as CSVMultisigTapscript2,
   claimWithPreimageIdentity,
@@ -1034,7 +1060,7 @@ import {
 
 // src/refund.ts
 import { base64 as base643, hex as hex5 } from "@scure/base";
-import { sha256 } from "@noble/hashes/sha2.js";
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
 import {
   CSVMultisigTapscript,
   ConditionWitness,
@@ -1115,7 +1141,7 @@ async function findLockupVtxos(indexer, swapPkScript) {
   }
   return out;
 }
-var hashesTo = (candidate, paymentHash) => hex5.encode(sha256(candidate)) === paymentHash;
+var hashesTo = (candidate, paymentHash) => hex5.encode(sha2562(candidate)) === paymentHash;
 var candidateWitnessItems = (tx, inputIndex) => [
   ...getArkPsbtFields(tx, inputIndex, ConditionWitness).flat(),
   ...tx.getInput(inputIndex).finalScriptWitness ?? []
@@ -1284,7 +1310,7 @@ async function pushClaim(ark, input) {
     }
   }
   const committed = input.script.options.preimageHash;
-  if (hex6.encode(ripemd160(sha2562(input.preimage))) !== hex6.encode(committed)) {
+  if (hex6.encode(ripemd160(sha2563(input.preimage))) !== hex6.encode(committed)) {
     throw new Error("preimage does not match the covenant's payment hash");
   }
   const info = await ark.getInfo();
@@ -2151,6 +2177,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,
@@ -2175,6 +2255,7 @@ export {
   ONCHAIN_RECEIVE_PAIR,
   ONCHAIN_SECONDS_PER_BLOCK,
   ONCHAIN_SEND_PAIR,
+  PreimageNotRecoverableError,
   QUOTE_OPTIONS,
   REFUND_MTP_LAG_SECONDS,
   RFQ_RESOLVED_STATES,
@@ -2182,6 +2263,7 @@ export {
   RFQ_TERMINAL_STATES,
   RefundNotLocallyPossibleError,
   RfqSwapManager,
+  SOLO_REFUND_HEADROOM_SECONDS,
   SWAP_LOCKUP_CONTRACT_KIND,
   SWAP_LOCKUP_CONTRACT_LABEL,
   SWAP_LOCKUP_CONTRACT_TYPE,
@@ -2229,6 +2311,7 @@ export {
   onchainReceiveRequest,
   onchainSendRequest,
   paymentHashOf,
+  preimageForSwapRecord,
   pushClaim,
   pushRefundWithoutReceiver,
   readLockupFate,
@@ -2247,6 +2330,7 @@ export {
   senderIdentityForSwapRecord,
   spendTxidsOf,
   spendUpdate,
+  swapActivityResolver,
   swapPrograms,
   swapSecretsToRecord,
   unilateralClaimDelay,

package/dist/nostr.cjs

@@ -33,6 +33,7 @@ __export(nostr_exports, {
   RFQ_AD_KIND: () => RFQ_AD_KIND,
   RFQ_DIRECTED_KIND: () => RFQ_DIRECTED_KIND,
   RelayUnavailable: () => RelayUnavailable,
+  TransportClosed: () => TransportClosed,
   nostrRfqTransport: () => nostrRfqTransport
 });
 module.exports = __toCommonJS(nostr_exports);
@@ -90,6 +91,8 @@ var SwapRefusal = class extends Error {
   }
 };
 var MIN_HEADROOM_SECONDS = 90 * 60;
+var SEQUENCE_GRANULARITY_SECONDS = 512;
+var SOLO_REFUND_HEADROOM_SECONDS = 8 * SEQUENCE_GRANULARITY_SECONDS;
 var MIN_CLAIM_WINDOW_SECONDS = 30 * 60;
 
 // src/nostr.ts
@@ -105,6 +108,12 @@ var RelayUnavailable = class extends Error {
     this.reasons = reasons;
   }
 };
+var TransportClosed = class extends Error {
+  constructor() {
+    super("transport closed before the solver replied");
+    this.name = "TransportClosed";
+  }
+};
 var closeReasons = (raw) => raw.map((entry) => {
   if (typeof entry === "string") return entry;
   const { url, reason } = entry ?? {};
@@ -204,6 +213,7 @@ var nostrRfqTransport = (options) => {
     },
     async close() {
       closed = true;
+      for (const waiter of waiters.values()) waiter.reject(new TransportClosed());
       waiters.clear();
       if (ownsPool) pool.close(relays);
       else subscription.close();
@@ -215,5 +225,6 @@ var nostrRfqTransport = (options) => {
   RFQ_AD_KIND,
   RFQ_DIRECTED_KIND,
   RelayUnavailable,
+  TransportClosed,
   nostrRfqTransport
 });

package/dist/nostr.d.cts

@@ -1,10 +1,11 @@
-import { a as RfqTransport } from './rfq-DjZlesr4.cjs';
+import { a as RfqTransport } from './rfq-3jWha5xA.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
@@ -70,6 +71,18 @@ declare class RelayUnavailable extends Error {
     readonly reasons: string[];
     constructor(reasons: string[]);
 }
+/**
+ * `close()` was called while a negotiation was still waiting on a reply.
+ *
+ * Distinct from both a timeout and {@link RelayUnavailable}, which describe the
+ * wire; this describes a decision on our own side of it. A caller that closed
+ * deliberately — a user leaving the screen, a flow abandoning its request — can
+ * match on this and stay quiet, rather than reporting a solver failure that
+ * never happened.
+ */
+declare class TransportClosed extends Error {
+    constructor();
+}
 interface NostrRfqOptions {
     /** Relay URLs from the solver's card. The rendezvous, not solver endpoints. */
     relays: string[];
@@ -95,4 +108,4 @@ interface NostrRfqOptions {
  */
 declare const nostrRfqTransport: (options: NostrRfqOptions) => RfqTransport;
 
-export { type NostrRfqOptions, RFQ_AD_KIND, RFQ_DIRECTED_KIND, RelayUnavailable, nostrRfqTransport };
+export { type NostrRfqOptions, RFQ_AD_KIND, RFQ_DIRECTED_KIND, RelayUnavailable, TransportClosed, nostrRfqTransport };

package/dist/nostr.d.ts

@@ -1,10 +1,11 @@
-import { a as RfqTransport } from './rfq-DjZlesr4.js';
+import { a as RfqTransport } from './rfq-3jWha5xA.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
@@ -70,6 +71,18 @@ declare class RelayUnavailable extends Error {
     readonly reasons: string[];
     constructor(reasons: string[]);
 }
+/**
+ * `close()` was called while a negotiation was still waiting on a reply.
+ *
+ * Distinct from both a timeout and {@link RelayUnavailable}, which describe the
+ * wire; this describes a decision on our own side of it. A caller that closed
+ * deliberately — a user leaving the screen, a flow abandoning its request — can
+ * match on this and stay quiet, rather than reporting a solver failure that
+ * never happened.
+ */
+declare class TransportClosed extends Error {
+    constructor();
+}
 interface NostrRfqOptions {
     /** Relay URLs from the solver's card. The rendezvous, not solver endpoints. */
     relays: string[];
@@ -95,4 +108,4 @@ interface NostrRfqOptions {
  */
 declare const nostrRfqTransport: (options: NostrRfqOptions) => RfqTransport;
 
-export { type NostrRfqOptions, RFQ_AD_KIND, RFQ_DIRECTED_KIND, RelayUnavailable, nostrRfqTransport };
+export { type NostrRfqOptions, RFQ_AD_KIND, RFQ_DIRECTED_KIND, RelayUnavailable, TransportClosed, nostrRfqTransport };

package/dist/nostr.js

@@ -1,6 +1,6 @@
 import {
   SwapRefusal
-} from "./chunk-DLM6BVTB.js";
+} from "./chunk-Q4FAYBXS.js";
 
 // src/nostr.ts
 import {
@@ -21,6 +21,12 @@ var RelayUnavailable = class extends Error {
     this.reasons = reasons;
   }
 };
+var TransportClosed = class extends Error {
+  constructor() {
+    super("transport closed before the solver replied");
+    this.name = "TransportClosed";
+  }
+};
 var closeReasons = (raw) => raw.map((entry) => {
   if (typeof entry === "string") return entry;
   const { url, reason } = entry ?? {};
@@ -120,6 +126,7 @@ var nostrRfqTransport = (options) => {
     },
     async close() {
       closed = true;
+      for (const waiter of waiters.values()) waiter.reject(new TransportClosed());
       waiters.clear();
       if (ownsPool) pool.close(relays);
       else subscription.close();
@@ -130,5 +137,6 @@ export {
   RFQ_AD_KIND,
   RFQ_DIRECTED_KIND,
   RelayUnavailable,
+  TransportClosed,
   nostrRfqTransport
 };

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 };