@arkade-os/swap 0.0.5 → 0.0.6

package/README.md

@@ -2,10 +2,10 @@
 
 Client-side [Arkade Intents](https://arkade.money) asset swaps: discover markets, quote and
 validate, create offers, track them, cancel them, and rebuild the whole record set from chain after
-a wallet restore. Framework-free TypeScript over `@arkade-os/sdk`: the core API and
-`InMemoryAssetSwapRepository` use no DOM and no Node-specific APIs, so they run in Node, the
-browser, and React Native alike. `IndexedDbAssetSwapRepository` is the one exception — it needs a
-platform-provided or polyfilled IndexedDB.
+a wallet restore. Framework-free TypeScript over `@arkade-os/sdk`: the core API uses no DOM and no
+Node-specific APIs, so it runs in Node, the browser, and React Native alike. Four storage backends
+ship — in-memory (anywhere, nothing outlives the process), IndexedDB (browser), SQLite and Realm
+(React Native, on subpath entry points) — see "Storage backends" below.
 
 ## Roles
 
@@ -100,11 +100,78 @@ arkade:BTC|asset` (quote, then take by funding an offer from layer 1).
 
 Everything the package persists — swap records, the restore-scan cursor, and the markets cache —
 goes through a single `AssetSwapRepository`, following the Arkade repository convention
-(versioned interface, `AsyncDisposable`, one backend per platform). Two backends ship here:
-`InMemoryAssetSwapRepository` and `IndexedDbAssetSwapRepository` (built on the SDK's shared
-IndexedDB manager, like the Boltz plugin's repositories). Construct one and pass it wherever the
-package asks for a repository; `discoverMarkets` also accepts none, for a one-shot uncached
-discovery.
+(versioned interface, `AsyncDisposable`, one backend per platform). Construct one and pass it
+wherever the package asks for a repository; `discoverMarkets` also accepts none, for a one-shot
+uncached discovery.
+
+## Storage backends
+
+| Backend                        | Import from                           | For                                             |
+| ------------------------------ | ------------------------------------- | ----------------------------------------------- |
+| `InMemoryAssetSwapRepository`  | `@arkade-os/swap`                     | tests, one-shot scripts — nothing survives exit |
+| `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          |
+
+Neither subpath adds a dependency: they take the SDK's structural `SQLExecutor` / `RealmLike`
+handles, so you pass the database you already opened.
+
+**Records are stored whole.** The SQLite and Realm backends serialize each record to **JSON** in a
+`data` column, with only `status` / `createdAt` 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. JSON is
+the boundary, though, and it is narrower than IndexedDB's structured clone: a `Date` in a
+consumer-added field comes back an ISO **string**, a `Set` or `Map` comes back empty, and a `bigint`
+makes `saveSwap` **throw**. `AssetSwap` itself is JSON-safe by design (amounts are strings); keep
+your own added fields that way too.
+
+### SQLite
+
+```ts
+import { SQLiteAssetSwapRepository } from "@arkade-os/swap/repositories/sqlite";
+import { SQLiteWalletRepository, type SQLExecutor } from "@arkade-os/sdk/repositories/sqlite";
+
+const db = await SQLite.openDatabaseAsync("wallet.db"); // expo-sqlite
+// Build the executor ONCE and hand this same instance to every repository on
+// the database: the SDK serializes transactions in a chain keyed by this
+// object, so a per-repository literal splits the chain and two BEGIN
+// IMMEDIATEs can interleave.
+const executor: SQLExecutor = {
+    run: (sql, params) => db.runAsync(sql, params ?? []),
+    get: (sql, params) => db.getFirstAsync(sql, params ?? []),
+    all: (sql, params) => db.getAllAsync(sql, params ?? []),
+};
+
+const swaps = new SQLiteAssetSwapRepository(executor);
+const wallet = new SQLiteWalletRepository(executor); // same instance
+```
+
+Sharing the executor is **necessary** for that serialization, not sufficient for atomicity across
+all wallet storage: it disciplines the repositories that enter the chain — this one,
+`SQLiteIntentRepository`, `SQLiteVirtualTxRepository`, and the wallet repository's migration path —
+and nothing else. `SQLiteWalletRepository` and `SQLiteContractRepository` still write raw, so their
+writes can land inside whatever transaction happens to be open.
+
+Three tables land in your database, prefixed `arkade_`: `arkade_asset_swaps`,
+`arkade_asset_swap_scanned_txids`, `arkade_asset_swap_markets`. Pass `{ prefix: "myapp_" }` if your
+app already owns those names.
+
+### Realm
+
+```ts
+import Realm from "realm";
+import { AssetSwapRealmSchemas, RealmAssetSwapRepository } from "@arkade-os/swap/repositories/realm";
+import { ArkRealmSchemas } from "@arkade-os/sdk/repositories/realm";
+
+const realm = await Realm.open({
+    schema: [...ArkRealmSchemas, ...AssetSwapRealmSchemas, ...yourOwnSchemas],
+    schemaVersion: YOUR_VERSION, // these schemas are new: bump yours when adding them
+});
+const swaps = new RealmAssetSwapRepository(realm);
+```
+
+Three classes land in your Realm namespace: `ArkadeAssetSwap`, `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.
 
 ## Creating an offer
 

package/dist/chunk-WGRU2DBF.js

@@ -0,0 +1,38 @@
+// 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]() {
+  }
+};
+
+export {
+  marketsCacheKey,
+  InMemoryAssetSwapRepository
+};

package/dist/index.cjs

@@ -128,6 +128,7 @@ __export(index_exports, {
   senderIdentityForSwapRecord: () => senderIdentityForSwapRecord,
   spendTxidsOf: () => spendTxidsOf,
   spendUpdate: () => spendUpdate,
+  swapActivityResolver: () => swapActivityResolver,
   swapPrograms: () => swapPrograms,
   swapSecretsToRecord: () => swapSecretsToRecord,
   unilateralClaimDelay: () => unilateralClaimDelay,
@@ -3376,6 +3377,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 }
+        }
+      ];
+    }
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ARKADE_ASSET,
@@ -3476,6 +3531,7 @@ var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
   senderIdentityForSwapRecord,
   spendTxidsOf,
   spendUpdate,
+  swapActivityResolver,
   swapPrograms,
   swapSecretsToRecord,
   unilateralClaimDelay,

package/dist/index.d.cts

@@ -1,233 +1,9 @@
-import { IWallet, ProvisionedKey, ProvisionedClaimSecret, asset, arkade, RestIndexerProvider, Transaction, IContractManager, RestArkProvider, VHTLC, Identity } from '@arkade-os/sdk';
-import { DiscoveredMarket, Network, LocalCardInput, Side, OfferPlan } from '@arkade-os/solver-discovery';
-import { R as RfqStatus, a as RfqTransport, O as OnchainHtlc, C as ChainSource, b as ChainUtxo, c as OnchainHtlcPhase } from './rfq-BH2yvo3O.cjs';
-export { A as ARKADE_ASSET, d as ARKADE_BTC, e as AddressMismatch, H as HtlcUtxo, I as InvoiceFacts, L as LIGHTNING_BTC, f as LIGHTNING_RECEIVE_PAIR, g as LIGHTNING_SEND_PAIR, M as MAX_MIN_CONFIRMATIONS, h as MIN_CLAIM_WINDOW_SECONDS, i as MIN_HEADROOM_SECONDS, j as ONCHAIN_BTC, k as ONCHAIN_CLAIM_MARGIN_SECONDS, l as ONCHAIN_DUST_SATS, m as ONCHAIN_ORDER_MARGIN_SECONDS, n as ONCHAIN_RECEIVE_PAIR, o as ONCHAIN_SECONDS_PER_BLOCK, p as ONCHAIN_SEND_PAIR, q as OnchainHtlcParams, r as OnchainNetwork, s as RFQ_TERMINAL_STATES, t as RelaySocket, u as RfqQuote, v as RfqRefusalReason, S as SOLO_REFUND_HEADROOM_SECONDS, w as SwapRefusal, x as arkadeSwapRequest, y as assertFundable, z as assertReceivable, B as awaitOnchainFill, D as buildHtlcClaim, E as buildHtlcRefund, F as claimOnchainFill, G as classifyOnchainHtlc, J as deriveLightningReceive, K as deriveOnchainReceive, N as deriveOnchainSend, P as extractPreimage, Q as httpTransport, T as lightningReceiveRequest, U as lightningSendRequest, V as lightningSendVtxoScript, W as newPreimage, X as newRfqId, Y as offerTermsFromQuote, Z as onchainHtlcScript, _ as onchainReceiveRequest, $ as onchainSendRequest, a0 as paymentHashOf, a1 as receiveVtxoScript, a2 as relayTransport, a3 as requestLightningReceive, a4 as requestLightningSend, a5 as requestOnchainReceive, a6 as requestOnchainSend, a7 as rfqPair, a8 as unilateralClaimDelay, a9 as unilateralRefundDelay, aa as unilateralRefundWithoutReceiverDelay, ab as verifyLockupAddress, ac as verifyReceiveInvoice } from './rfq-BH2yvo3O.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.
- * Lives here with the {@link AssetSwap} fields it describes so the market and
- * restore layers share one spelling instead of re-typing the literal. */
-declare const BTC_ASSET_ID = "btc";
-/**
- * The record fields a wallet-provisioned secret becomes — what
- * {@link swapSecretsToRecord} emits, and what every record type carrying swap
- * secrets embeds.
- *
- * A named type rather than four fields restated per record: the mapper and the
- * records it feeds must agree exactly, and a record that silently omits one of
- * these round-trips a swap whose preimage cannot be re-derived. Embedding makes
- * the omission a compile error instead.
- *
- * **Only `preimageHex` is secret.** `signingDescriptor` and `preimageSaltHex`
- * are public derivation inputs — they must survive a field-mapped backend, but
- * they leak nothing without the seed.
- */
-interface SwapSecretsProjection {
-    /**
-     * The wallet descriptor this swap's sender key comes from — a fresh HD
-     * child, or a static wallet's `tr(pubkey)`. Public — the signer
-     * re-derives from the wallet, so the record carries no key material.
-     */
-    signingDescriptor?: string;
-    /** P, hex, when it cannot be re-derived from the seed at all: the user
-     * supplied it, or the signer cannot sign deterministically. The swap's only
-     * claim secret when present. */
-    preimageHex?: string;
-    /**
-     * The salt P derives from, hex, on the salted arm — what a static wallet
-     * gets instead of storing P. **Public**, and unlike every other field here
-     * it is minted per swap: it is what stops one repeating key from handing
-     * every swap the same preimage.
-     */
-    preimageSaltHex?: string;
-}
-interface AssetSwap extends SwapSecretsProjection {
-    /** Funding txid — the swap's identity. */
-    id: string;
-    /** 'btc' or a 68-hex asset id. */
-    fromAsset: string;
-    toAsset: string;
-    /** Atomic amounts as strings (bigint is not JSON-safe). */
-    fromAmount: string;
-    /** The covenant wantAmount — a floor, the fill pays >= this. */
-    toAmount: string;
-    swapAddress: string;
-    /** Hex pkScript of the swap contract — the indexer monitoring key. */
-    swapPkScript: string;
-    /** TLV offer — needed to rebuild the contract for cancel. */
-    offerHex: string;
-    fundingTxid: string;
-    spentTxid?: string;
-    status: AssetSwapStatus;
-    createdAt: number;
-    completedAt?: number;
-    /** RFQ pair string, e.g. `arkade:BTC->onchain:BTC`. */
-    pair?: string;
-    /** `sha256(P)`, hex. Public, and how a restore confirms a candidate
-     * derivation is the right one. */
-    paymentHash?: string;
-    /** The L1 HTLC's pkScript, hex — the chain-watch key. */
-    htlcPkScriptHex?: string;
-    htlcLocktime?: number;
-    /** The L1 funding txid, once observed. */
-    l1Txid?: string;
-}
-/** All swaps, newest-first. Insertion order is not chronological — the restore
- * scan rebuilds records in tx-scan order — so sort at read to keep
- * newest-first canonical for every consumer. */
-declare const getAssetSwapsOrThrow: (repository: AssetSwapRepository) => Promise<AssetSwap[]>;
-/** The consumer read: a broken backend reads as no swaps rather than crashing
- * a history view. Mutations must use {@link getAssetSwapsOrThrow} instead —
- * swallowing the read there would let "the backend is gone" masquerade as "no
- * such swap" and skip the write silently. */
-declare const getAssetSwaps: (repository: AssetSwapRepository) => Promise<AssetSwap[]>;
-/** Add a swap; no-op if the id is already stored. Returns the updated list.
- * THROWS on a failed write — nothing irreversible may happen until this record
- * is durable, so the caller must not fund on a failure. */
-declare const addAssetSwap: (repository: AssetSwapRepository, swap: AssetSwap) => Promise<AssetSwap[]>;
-/** Merge changes into a swap by id. Returns the updated list.
- * THROWS on a failed read or write, like {@link addAssetSwap} — use this for a
- * write that gates something irreversible. Transitions written *after* the
- * irreversible act belong on {@link updateAssetSwapBestEffort}. */
-declare const updateAssetSwap: (repository: AssetSwapRepository, id: string, changes: Partial<Omit<AssetSwap, "id">>) => Promise<AssetSwap[]>;
-/**
- * {@link updateAssetSwap} for transitions that follow an irreversible action (a
- * broadcast claim, a spent lockup): failing the caller there would report as
- * failed a swap whose funds already moved, and a stale status is recoverable —
- * crash recovery re-derives the true state from the chain
- * (`classifyOnchainHtlc`).
- *
- * `persisted` is the part that must not be hidden: a caller that notifies on a
- * change, or treats one as terminal, has to know the store did not agree.
- */
-declare const updateAssetSwapBestEffort: (repository: AssetSwapRepository, id: string, changes: Partial<Omit<AssetSwap, "id">>) => Promise<{
-    swaps: AssetSwap[];
-    persisted: boolean;
-}>;
-/**
- * The record fields a wallet-provisioned secret becomes.
- *
- * `signingDescriptor` is public and always stored — it is what recovers the
- * signer. Then at most one of: `preimageHex`, when the wallet says it cannot
- * re-derive P and it becomes the swap's only claim secret; or
- * `preimageSaltHex`, the public input a derivable-but-repeating key needs.
- */
-declare const swapSecretsToRecord: (secrets: ProvisionedKey | ProvisionedClaimSecret) => SwapSecretsProjection & {
-    signingDescriptor: string;
-};
-/** Why a wallet cannot produce a swap's preimage. */
-type PreimageBlockedReason = 
-/** The record carries no `signingDescriptor`. */
-"no-secrets"
-/** `preimageHex` or `preimageSaltHex` is present but not 32 bytes of hex. */
- | "malformed-record"
-/**
- * Nothing to derive from: a descriptor that repeats across swaps, with
- * neither a stored preimage nor a salt — or one this wallet holds no key
- * for. Merged deliberately: `contractSigner` reports a key it does not
- * hold as a plain `Error` for static wallets and a `ForeignDescriptorError`
- * for HD ones, so splitting the two here would mean matching on message
- * text, which is the thing this type exists to avoid. The `cause` carries
- * whichever it was.
- */
- | "not-derivable"
-/** Derived, but it does not hash to the record's `paymentHash`. */
- | "hash-mismatch";
-/**
- * The wallet cannot produce this swap's preimage, and which of the four ways
- * is `reason`.
- *
- * Deliberately **not** {@link RefundNotLocallyPossibleError}: that one means
- * "no local refund is possible", and `RfqSwapManager` acts on it by reporting
- * `needs_counterparty`. A claim-path read failure is a different verdict, and
- * borrowing the refund error would have the manager announce one for the
- * other.
- */
-declare class PreimageNotRecoverableError extends Error {
-    readonly reason: PreimageBlockedReason;
-    readonly name = "PreimageNotRecoverableError";
-    constructor(reason: PreimageBlockedReason, message: string, options?: {
-        cause?: unknown;
-    });
-}
-/**
- * The preimage a swap record claims with — stored, or re-derived from the
- * wallet.
- *
- * The record-shaped inverse of {@link swapSecretsToRecord}, and the one place
- * that knows which of a record's fields `contractPreimage` needs. Wire claim
- * paths here rather than composing it by hand: a caller that forgets to pass
- * `preimageSaltHex` gets a *wrong* preimage from a wallet that can derive,
- * not an error.
- *
- * Verifies the result against `paymentHash` when the record carries one. The
- * salted arm has two inputs that can be wrong — the key and the salt — where
- * the HD arm had one, and a wrong P otherwise surfaces as an opaque script
- * failure at claim time, long after the mistake.
- *
- * Every refusal is a {@link PreimageNotRecoverableError} carrying a `reason`,
- * so a caller can tell "this record predates the descriptor" from "the salt is
- * corrupt" without reading message text.
- */
-declare const preimageForSwapRecord: (wallet: IWallet, record: SwapSecretsProjection & {
-    paymentHash?: string;
-}) => Promise<Uint8Array>;
-
-/** A registry discovery result held for reuse. Refetchable — unlike a swap
- * record, losing it costs one network round trip — but it must survive a cold
- * boot: serving it stale is what keeps quoting alive while a registry is down. */
-interface MarketsCacheEntry {
-    markets: DiscoveredMarket[];
-    fetchedAt: number;
-}
-/**
- * Everything the package persists, following the monorepo repository
- * convention (versioned interface, AsyncDisposable, one backend per
- * platform — see the Boltz plugin's SwapRepository). Consumers construct
- * exactly one of these; there is no second storage seam.
- *
- * Durable records (swaps) and rebuildable state (the restore scan's txid
- * cursor, the markets cache) live side by side because they share a
- * lifetime: all three belong to one wallet on one device, and a consumer
- * that wipes one wants all three gone.
- *
- * ponytail: no query filters — every consumer reads all swaps and filters
- * in memory; mirror the Boltz plugin's GetSwapsFilter when a consumer needs
- * subset queries.
- */
-interface AssetSwapRepository extends AsyncDisposable {
-    readonly version: 2;
-    /** Insert or replace a swap by id. Store the record whole: `preimageHex`
-     * and `preimageSaltHex` both leave the swap unclaimable if a field-mapped
-     * backend drops them — the first is the only claim secret of a swap whose
-     * signer cannot derive, the second the public input every other static
-     * wallet's preimage derives from. */
-    saveSwap(swap: AssetSwap): Promise<void>;
-    /** All stored swaps, in no particular order — `getAssetSwaps` is the
-     * canonical newest-first read. */
-    getAllSwaps(): Promise<AssetSwap[]>;
-    /** Sent txids already checked for offer packets (see restore.ts). */
-    getScannedTxids(): Promise<Set<string>>;
-    markTxidsScanned(txids: Iterable<string>): Promise<void>;
-    /** Cached registry markets, or undefined on a miss. */
-    getCachedMarkets(network: string, registry: string): Promise<MarketsCacheEntry | undefined>;
-    saveCachedMarkets(network: string, registry: string, entry: MarketsCacheEntry): Promise<void>;
-    clear(): Promise<void>;
-}
-declare class InMemoryAssetSwapRepository implements AssetSwapRepository {
-    readonly version: 2;
-    private readonly swaps;
-    private readonly scanned;
-    private readonly markets;
-    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>;
-    clear(): Promise<void>;
-    [Symbol.asyncDispose](): Promise<void>;
-}
+import { asset, IWallet, arkade, RestIndexerProvider, Transaction, IContractManager, RestArkProvider, VHTLC, Identity, ActivityResolver } from '@arkade-os/sdk';
+import { A as AssetSwapRepository, a as AssetSwap, M as MarketsCacheEntry } from './repository-BwnZ8N62.cjs';
+export { b as AssetSwapStatus, B as BTC_ASSET_ID, I as InMemoryAssetSwapRepository, P as PreimageBlockedReason, c as PreimageNotRecoverableError, S as SwapSecretsProjection, d as addAssetSwap, g as getAssetSwaps, e as getAssetSwapsOrThrow, p as preimageForSwapRecord, s as swapSecretsToRecord, u as updateAssetSwap, f as updateAssetSwapBestEffort } from './repository-BwnZ8N62.cjs';
+import { Network, LocalCardInput, DiscoveredMarket, Side, OfferPlan } from '@arkade-os/solver-discovery';
+import { R as RfqStatus, a as RfqTransport, O as OnchainHtlc, C as ChainSource, b as ChainUtxo, c as OnchainHtlcPhase } from './rfq-3jWha5xA.cjs';
+export { A as ARKADE_ASSET, d as ARKADE_BTC, e as AddressMismatch, H as HtlcUtxo, I as InvoiceFacts, L as LIGHTNING_BTC, f as LIGHTNING_RECEIVE_PAIR, g as LIGHTNING_SEND_PAIR, M as MAX_MIN_CONFIRMATIONS, h as MIN_CLAIM_WINDOW_SECONDS, i as MIN_HEADROOM_SECONDS, j as ONCHAIN_BTC, k as ONCHAIN_CLAIM_MARGIN_SECONDS, l as ONCHAIN_DUST_SATS, m as ONCHAIN_ORDER_MARGIN_SECONDS, n as ONCHAIN_RECEIVE_PAIR, o as ONCHAIN_SECONDS_PER_BLOCK, p as ONCHAIN_SEND_PAIR, q as OnchainHtlcParams, r as OnchainNetwork, s as RFQ_TERMINAL_STATES, t as RelaySocket, u as RfqQuote, v as RfqRefusalReason, S as SOLO_REFUND_HEADROOM_SECONDS, w as SwapRefusal, x as arkadeSwapRequest, y as assertFundable, z as assertReceivable, B as awaitOnchainFill, D as buildHtlcClaim, E as buildHtlcRefund, F as claimOnchainFill, G as classifyOnchainHtlc, J as deriveLightningReceive, K as deriveOnchainReceive, N as deriveOnchainSend, P as extractPreimage, Q as httpTransport, T as lightningReceiveRequest, U as lightningSendRequest, V as lightningSendVtxoScript, W as newPreimage, X as newRfqId, Y as offerTermsFromQuote, Z as onchainHtlcScript, _ as onchainReceiveRequest, $ as onchainSendRequest, a0 as paymentHashOf, a1 as receiveVtxoScript, a2 as relayTransport, a3 as requestLightningReceive, a4 as requestLightningSend, a5 as requestOnchainReceive, a6 as requestOnchainSend, a7 as rfqPair, a8 as unilateralClaimDelay, a9 as unilateralRefundDelay, aa as unilateralRefundWithoutReceiverDelay, ab as verifyLockupAddress, ac as verifyReceiveInvoice } from './rfq-3jWha5xA.cjs';
 
 /** The contracts — pure data, shared verbatim with any other implementation. */
 declare const swapPrograms: Record<"wantAsset" | "wantBtc", ReturnType<typeof arkade.parseArtifact>>;
@@ -2010,4 +1786,43 @@ interface RfqSwapOutcome {
     txid?: string;
 }
 
-export { type ArkadeRefundResult, type AssetSwap, type AssetSwapRepository, type AssetSwapStatus, BTC_ASSET_ID, ChainSource, ChainUtxo, type ClaimArkProvider, type ClaimPacketInput, type DiscoverMarketsOptions, InMemoryAssetSwapRepository, IndexedDbAssetSwapRepository, type LightningReceiveSwap, type LightningSendSwap, LockupAmountMismatchError, type LockupContractWriter, type LockupFate, LockupNeedsRecoveryError, LockupRegistrationFailed, type LockupSpendIndexer, type LockupVtxo, type MarketsCacheEntry, OFFER_PACKET_TYPE, type Offer, type OfferContractRetirer, type OfferSwapWatcher, OnchainHtlc, OnchainHtlcPhase, type OnchainSendAction, type OnchainSendSwap, type PlanError, type PreimageBlockedReason, PreimageNotRecoverableError, QUOTE_OPTIONS, REFUND_MTP_LAG_SECONDS, RFQ_RESOLVED_STATES, RFQ_SWAP_TERMINAL_STATES, type RefundArkProvider, type RefundBlockedReason, type RefundIndexer, RefundNotLocallyPossibleError, type RefundOutcome, type RestoreIndexer, RfqStatus, type RfqSwap, type RfqSwapActionName, type RfqSwapLockup, RfqSwapManager, type RfqSwapManagerCallbacks, type RfqSwapManagerConfig, type RfqSwapManagerDeps, type RfqSwapManagerEvents, type RfqSwapOutcome, type RfqSwapState, RfqTransport, SWAP_LOCKUP_CONTRACT_KIND, SWAP_LOCKUP_CONTRACT_LABEL, SWAP_LOCKUP_CONTRACT_TYPE, type SealedClaimPacket, type SpendKind, type SwapContractRegistry, type SwapSecretsProjection, type Tx, type WatchOfferSwapsParams, addAssetSwap, awaitLockupFunding, awaitRfqResolution, cancelOffer, claimReceiveLockup, classifyDepositSpend, classifySpend, createOffer, decodeOffer, discoverMarkets, encodeOffer, findLockupVtxos, findMarket, getAssetSwaps, getAssetSwapsOrThrow, isRfqSwapTerminal, isRfqTerminal, makeCachedFeedFetch, nextOnchainAction, offerVtxoScript, preimageForSwapRecord, pushClaim, pushRefundWithoutReceiver, readLockupFate, refundIfUnresolved, registerLockupContract, restoreAssetSwaps, retireSettledOfferContracts, sealClaimPacket, senderIdentityForSwapRecord, spendTxidsOf, spendUpdate, swapPrograms, swapSecretsToRecord, updateAssetSwap, updateAssetSwapBestEffort, validatePlan, watchOfferSwaps };
+/**
+ * One swap, flattened to what grouping needs: an identity, a corridor, an
+ * outcome, and every Arkade transaction that belongs to it.
+ *
+ * Deliberately not a stored swap record itself — resolution should stay
+ * testable with plain data rather than a repository. A correlation helper
+ * that derives these from the record store and the funding lockup's VTXOs
+ * lands separately.
+ */
+interface SwapActivityInput {
+    rfqId: string;
+    /**
+     * Literal union rather than `RfqSwapRecord["kind"]` — `RfqSwapRecord` lives
+     * only on the unmerged rfq-persistence branch, not on master. Reconcile
+     * with `RfqSwapRecord["kind"]` once that branch lands.
+     */
+    kind: "lightning_send" | "lightning_receive" | "onchain_send";
+    state: RfqSwapState;
+    /** Funding, claim and refund txids, in whatever order. */
+    txids: readonly string[];
+}
+/**
+ * Group each RFQ swap's transactions into one activity carrying its outcome.
+ *
+ * Without this a failed swap renders as two unrelated rows: the send that
+ * funded the lockup, and the receive when the covenant refunds. Grouping by
+ * `rfqId` collapses them into one activity, and the amount comes out correct
+ * by netting, not by `buildActivities`'s same-key change exclusion — that
+ * rule only fires when one txid is both sent and received, and funding and
+ * refund are different txids. Summing the signed amounts
+ * (`-funding + refund ≈ -fees`) is what does the work here.
+ *
+ * `prepare` loads once and `resolve` stays pure and synchronous, as the SDK's
+ * `ActivityResolver` contract requires.
+ */
+declare function swapActivityResolver(deps: {
+    listSwaps(): Promise<readonly SwapActivityInput[]>;
+}): ActivityResolver;
+
+export { type ArkadeRefundResult, AssetSwap, AssetSwapRepository, ChainSource, ChainUtxo, type ClaimArkProvider, type ClaimPacketInput, type DiscoverMarketsOptions, IndexedDbAssetSwapRepository, type LightningReceiveSwap, type LightningSendSwap, LockupAmountMismatchError, type LockupContractWriter, type LockupFate, LockupNeedsRecoveryError, LockupRegistrationFailed, type LockupSpendIndexer, type LockupVtxo, MarketsCacheEntry, OFFER_PACKET_TYPE, type Offer, type OfferContractRetirer, type OfferSwapWatcher, OnchainHtlc, OnchainHtlcPhase, type OnchainSendAction, type OnchainSendSwap, type PlanError, QUOTE_OPTIONS, REFUND_MTP_LAG_SECONDS, RFQ_RESOLVED_STATES, RFQ_SWAP_TERMINAL_STATES, type RefundArkProvider, type RefundBlockedReason, type RefundIndexer, RefundNotLocallyPossibleError, type RefundOutcome, type RestoreIndexer, RfqStatus, type RfqSwap, type RfqSwapActionName, type RfqSwapLockup, RfqSwapManager, type RfqSwapManagerCallbacks, type RfqSwapManagerConfig, type RfqSwapManagerDeps, type RfqSwapManagerEvents, type RfqSwapOutcome, type RfqSwapState, RfqTransport, SWAP_LOCKUP_CONTRACT_KIND, SWAP_LOCKUP_CONTRACT_LABEL, SWAP_LOCKUP_CONTRACT_TYPE, type SealedClaimPacket, type SpendKind, type SwapActivityInput, type SwapContractRegistry, type Tx, type WatchOfferSwapsParams, awaitLockupFunding, awaitRfqResolution, cancelOffer, claimReceiveLockup, classifyDepositSpend, classifySpend, createOffer, decodeOffer, discoverMarkets, encodeOffer, findLockupVtxos, findMarket, isRfqSwapTerminal, isRfqTerminal, makeCachedFeedFetch, nextOnchainAction, offerVtxoScript, pushClaim, pushRefundWithoutReceiver, readLockupFate, refundIfUnresolved, registerLockupContract, restoreAssetSwaps, retireSettledOfferContracts, sealClaimPacket, senderIdentityForSwapRecord, spendTxidsOf, spendUpdate, swapActivityResolver, swapPrograms, validatePlan, watchOfferSwaps };