@arkade-os/swap 0.0.14 → 0.0.16

package/dist/index.js

@@ -19,6 +19,7 @@ import {
   ONCHAIN_RECEIVE_PAIR,
   ONCHAIN_SECONDS_PER_BLOCK,
   ONCHAIN_SEND_PAIR,
+  RFQ_REFUSAL_ERROR_CODES,
   RFQ_TERMINAL_STATES,
   SOLO_REFUND_HEADROOM_SECONDS,
   SWAP_LOCKUP_CONTRACT_KIND,
@@ -39,6 +40,7 @@ import {
   deriveOnchainSend,
   extractPreimage,
   httpTransport,
+  isRfqRefusalErrorCode,
   l1ScriptForAddress,
   lightningReceiveRequest,
   lightningSendRequest,
@@ -65,7 +67,7 @@ import {
   unilateralRefundWithoutReceiverDelay,
   verifyLockupAddress,
   verifyReceiveInvoice
-} from "./chunk-IFZOBTTG.js";
+} from "./chunk-7N7XO4PY.js";
 import {
   InMemoryAssetSwapRepository,
   marketsCacheKey
@@ -75,8 +77,10 @@ import {
 import { hex as hex2 } from "@scure/base";
 import { concatBytes } from "@scure/btc-signer/utils.js";
 import {
+  ASSET_CARRIER_SATS as SDK_ASSET_CARRIER_SATS,
   ArkAddress,
   RestArkProvider,
+  RestEmulatorProvider,
   RestIndexerProvider,
   arkade,
   asset,
@@ -188,10 +192,10 @@ function addressOutstanding(swaps, script) {
   }
   return true;
 }
-async function promoteOfferContract(manager, script) {
+async function promoteOfferContract(manager, script, issued = Date.now()) {
   await serialize(script, async () => {
     await manager.setContractWatchState(script, "watched");
-    issuedAt.set(script, Date.now());
+    issuedAt.set(script, issued);
   });
 }
 async function retireOfferContract(manager, swaps, script) {
@@ -397,7 +401,7 @@ function u64(name, value) {
   if (value < BigInt(0) || value >> BigInt(64) > BigInt(0)) {
     throw new Error(`${name} does not fit the offer wire format (u64)`);
   }
-  const out = new Uint8Array(FIELDS.wantAmount.width);
+  const out = new Uint8Array(8);
   new DataView(out.buffer).setBigUint64(0, value, false);
   return out;
 }
@@ -532,10 +536,9 @@ function decodeExitDelay(value) {
 }
 var OFFER_CONTRACT_LABEL = "Arkade swap offer";
 var OFFER_CONTRACT_KIND = "asset-swap-offer";
-async function registerOfferContract(wallet, arkServerUrl, network, binding, serverPubkey, expectedPkScript) {
-  const { program, args, keys } = swapProgramBinding(binding, serverPubkey);
-  const contractManager = await wallet.getContractManager();
-  const client = await arkade.Arkade.connect({
+async function registerOfferContract(wallet, arkServerUrl, network, binding, serverPubkey, expectedPkScript, opts = {}) {
+  const contractManager = opts.contractManager ?? await wallet.getContractManager();
+  const client = opts.client ?? await arkade.Arkade.connect({
     arkade: new RestArkProvider(arkServerUrl),
     indexer: new RestIndexerProvider(arkServerUrl),
     identity: wallet.identity,
@@ -545,15 +548,66 @@ async function registerOfferContract(wallet, arkServerUrl, network, binding, ser
     network: getNetwork(network),
     contractManager
   });
+  await contractManager.createContract(
+    offerContractParams(client, binding, serverPubkey, expectedPkScript)
+  );
+  await promoteOfferContract(contractManager, hex2.encode(expectedPkScript), opts.issued);
+}
+function offerContractParams(client, binding, serverPubkey, expectedPkScript) {
+  const { program, args, keys } = swapProgramBinding(binding, serverPubkey);
   const contract = new arkade.ArkadeContract(client, program, args, keys);
   if (hex2.encode(contract.pkScript) !== hex2.encode(expectedPkScript)) {
     throw new Error("derived covenant does not match the offer's swapPkScript");
   }
-  await contract.register({
+  return {
+    ...contract.toContractParams(),
     label: OFFER_CONTRACT_LABEL,
     metadata: { genericallySpendable: false, kind: OFFER_CONTRACT_KIND }
+  };
+}
+async function restoreOfferCoverage(wallet, arkServerUrl, swaps) {
+  const live = swaps.filter((s) => !RETIRABLE.includes(s.status));
+  if (live.length === 0) return;
+  const arkProvider = new RestArkProvider(arkServerUrl);
+  const info = await arkProvider.getInfo();
+  const serverPubKey = hex2.decode(toXOnlySignerHex(info.signerPubkey));
+  const contractManager = await wallet.getContractManager();
+  const client = await arkade.Arkade.connect({
+    arkade: arkProvider,
+    indexer: new RestIndexerProvider(arkServerUrl),
+    identity: wallet.identity,
+    network: getNetwork(info.network),
+    contractManager
   });
-  await promoteOfferContract(contractManager, hex2.encode(expectedPkScript));
+  const done = /* @__PURE__ */ new Set();
+  const covenants = [];
+  for (const swap of live) {
+    if (done.has(swap.swapPkScript)) continue;
+    done.add(swap.swapPkScript);
+    try {
+      const { swapPkScript: _, ...binding } = decodeOffer(hex2.decode(swap.offerHex));
+      covenants.push({
+        script: swap.swapPkScript,
+        issued: swap.createdAt,
+        params: offerContractParams(
+          client,
+          binding,
+          serverPubKey,
+          hex2.decode(swap.swapPkScript)
+        )
+      });
+    } catch (err) {
+      console.warn(`[swap] could not restore coverage for ${swap.swapPkScript}`, err);
+    }
+  }
+  if (covenants.length === 0) return;
+  const paramsList = covenants.map((c) => c.params);
+  if (contractManager.createContracts) {
+    await contractManager.createContracts(paramsList);
+  } else {
+    for (const params of paramsList) await contractManager.createContract(params);
+  }
+  for (const c of covenants) await promoteOfferContract(contractManager, c.script, c.issued);
 }
 function serverExitDelay(delay) {
   if (typeof delay !== "bigint" || delay <= BigInt(0)) {
@@ -666,6 +720,127 @@ async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
   }
   return txid;
 }
+var ASSET_CARRIER_SATS = BigInt(SDK_ASSET_CARRIER_SATS);
+async function fillOffer(wallet, arkServerUrl, offerHex, opts) {
+  const {
+    fund,
+    payoutScript,
+    fundingTxid,
+    swapAddress,
+    assetCarrierSats = ASSET_CARRIER_SATS,
+    emulator,
+    emulatorPubkey
+  } = opts;
+  const offer = decodeOffer(hex2.decode(offerHex));
+  const wantedAssetId = offer.wantAsset?.toString();
+  if (fund.length === 0) {
+    throw new Error("fillOffer needs coins to pay wantAmount with \u2014 `fund` is empty");
+  }
+  if (wantedAssetId !== void 0) {
+    const supplied = fund.reduce(
+      (sum, coin) => sum + amountOfAsset(coin.assets, wantedAssetId),
+      BigInt(0)
+    );
+    if (supplied < offer.wantAmount) {
+      throw new Error(
+        `fillOffer needs ${offer.wantAmount} of ${wantedAssetId} to pay the maker, but \`fund\` declares ${supplied} \u2014 pass coins carrying it, and declare their assets`
+      );
+    }
+  }
+  const contractManager = await wallet.getContractManager();
+  const client = await arkade.Arkade.connect({
+    arkade: new RestArkProvider(arkServerUrl),
+    indexer: new RestIndexerProvider(arkServerUrl),
+    identity: wallet.identity,
+    contractManager,
+    // `fulfill` is a covenant path, so the emulator executes the arkade
+    // script and finalizes with arkd. Without it the spend is built and then
+    // refused at submission — there is no default to fall back on.
+    emulator: typeof emulator === "string" ? new RestEmulatorProvider(emulator) : emulator,
+    // Only reached for the client's own emulatorKey, which this fill never
+    // derives against — the offer's own key is bound below. It still has to
+    // resolve, and on a network with no pinned key it throws without this.
+    ...emulatorPubkey ? { emulatorPubkey } : {}
+  });
+  const serverKey = swapAddress ? ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
+  const { program, args, keys } = swapProgramBinding(offer, serverKey);
+  const rebuilt = new arkade.ArkadeProgramScript(program, args, keys);
+  if (hex2.encode(rebuilt.pkScript) !== hex2.encode(offer.swapPkScript)) {
+    throw new Error(
+      "rebuilt covenant does not match the offer's swapPkScript \u2014 the server signing key has likely rotated since funding; pass swapAddress (the funded address) to pin the original key"
+    );
+  }
+  const contract = new arkade.ArkadeContract(client, program, args, keys);
+  const [vtxos, takerAddress] = await Promise.all([contract.getUtxos(), wallet.getAddress()]);
+  if (!fundingTxid && vtxos.length > 1) {
+    throw new Error(
+      "multiple spendable deposits at the swap address \u2014 pass fundingTxid to select one"
+    );
+  }
+  const vtxo = fundingTxid ? vtxos.find((v) => v.txid === fundingTxid) : vtxos[0];
+  if (!vtxo) throw new Error("no spendable VTXO at the swap address");
+  if (offer.offerAsset) {
+    const offered = offer.offerAsset.toString();
+    const deposited = amountOfAsset(vtxo.assets, offered);
+    if (deposited <= BigInt(0)) {
+      throw new Error(
+        `the deposit at the swap address carries no ${offered}, which this offer sells \u2014 filling it would pay wantAmount for nothing. The indexer may be behind, or the offer may not be backed by what it advertises`
+      );
+    }
+  }
+  const payout = payoutScript ?? ArkAddress.decode(takerAddress).pkScript;
+  const makerSats = wantedAssetId === void 0 ? offer.wantAmount : assetCarrierSats;
+  const fill = contract.functions.fulfill().from({ txid: vtxo.txid, vout: vtxo.vout, value: vtxo.value }).fund(fund).to(offer.makerPkScript, makerSats).change(payout);
+  const held = /* @__PURE__ */ new Map();
+  const hold = (vin, assets) => {
+    for (const a of assets ?? []) {
+      const amount = BigInt(a.amount);
+      if (amount <= BigInt(0)) continue;
+      held.set(a.assetId, [...held.get(a.assetId) ?? [], { vin, amount }]);
+    }
+  };
+  hold(0, vtxo.assets);
+  fund.forEach((coin, i) => hold(i + 1, coin.assets));
+  const outputsSum = makerSats;
+  const inputsSum = fund.reduce((s, c) => s + BigInt(c.value), BigInt(vtxo.value));
+  const hasPayoutOutput = inputsSum > outputsSum;
+  const emitWanted = () => {
+    if (wantedAssetId === void 0) return;
+    const supplying = held.get(wantedAssetId) ?? [];
+    const supplied = supplying.reduce((s, i) => s + i.amount, BigInt(0));
+    const outputs = [{ vout: 0, amount: offer.wantAmount }];
+    const surplus = supplied - offer.wantAmount;
+    if (surplus > BigInt(0)) {
+      if (!hasPayoutOutput) {
+        throw new Error(
+          `fillOffer has ${surplus} of ${wantedAssetId} to return but no payout output \u2014 fund with more sats than the maker's output takes`
+        );
+      }
+      outputs.push({ vout: 1, amount: surplus });
+    }
+    fill.withAsset({ assetId: wantedAssetId, inputs: supplying, outputs });
+    held.delete(wantedAssetId);
+  };
+  emitWanted();
+  for (const [assetId, inputs] of held) {
+    const amount = inputs.reduce((s, i) => s + i.amount, BigInt(0));
+    if (!hasPayoutOutput) {
+      throw new Error(
+        `fillOffer has ${amount} of ${assetId} to return but no payout output \u2014 fund with more sats than the maker's output takes`
+      );
+    }
+    fill.withAsset({ assetId, inputs, outputs: [{ vout: 1, amount }] });
+  }
+  const { txid } = await fill.send();
+  return txid;
+}
+var amountOfAsset = (assets, assetId) => {
+  let total = BigInt(0);
+  for (const a of assets ?? []) {
+    if (a.assetId === assetId) total += BigInt(a.amount);
+  }
+  return total;
+};
 
 // src/markets.ts
 import {
@@ -675,6 +850,45 @@ import {
   sideLimits
 } from "@arkade-os/solver-discovery";
 import { isSubdust } from "@arkade-os/sdk";
+
+// src/marketShape.ts
+var MARKET_CORRIDORS = ["arkade", "bolt11", "bitcoin", "eip155"];
+var LEGACY_CORRIDORS = {
+  arkade: "arkade",
+  lightning: "bolt11",
+  onchain: "bitcoin",
+  eip155: "eip155"
+};
+var assetOf = (market, side) => side === "base" ? market.base_asset : market.quote_asset;
+var marketAssetId = (market, side) => {
+  const asset2 = assetOf(market, side);
+  if (typeof asset2?.caip19_id === "string") return asset2.caip19_id;
+  return typeof asset2?.id === "string" ? asset2.id : void 0;
+};
+var chainNamespaceOf = (id) => {
+  if (id === void 0) return void 0;
+  const slash = id.indexOf("/");
+  const colon = id.indexOf(":");
+  return slash === -1 || colon === -1 || colon > slash ? void 0 : id.slice(0, colon);
+};
+var marketCorridor = (market, side) => {
+  const namespace = chainNamespaceOf(marketAssetId(market, side));
+  if (namespace !== void 0) {
+    return MARKET_CORRIDORS.includes(namespace) ? namespace : "arkade";
+  }
+  const legacy = side === "base" ? market.base_corridor : market.quote_corridor;
+  return typeof legacy === "string" ? LEGACY_CORRIDORS[legacy] ?? "arkade" : "arkade";
+};
+var isRfqMarket = (market) => marketCorridor(market, "base") !== "arkade" || marketCorridor(market, "quote") !== "arkade";
+var sideLabel = (market, side) => {
+  const ticker = assetOf(market, side)?.ticker;
+  const label = typeof ticker === "string" && ticker.length > 0 ? ticker : "?";
+  const corridor = marketCorridor(market, side);
+  return corridor === "arkade" ? label : `${corridor}:${label}`;
+};
+var marketPairLabel = (market) => `${sideLabel(market, "base")}/${sideLabel(market, "quote")}`;
+
+// src/markets.ts
 var QUOTE_OPTIONS = { safetyBps: 0 };
 var makeCachedFeedFetch = (ttlMs = 3e4, fetchImpl = fetch) => {
   const cache = /* @__PURE__ */ new Map();
@@ -723,14 +937,17 @@ var makeCachedFeedFetch = (ttlMs = 3e4, fetchImpl = fetch) => {
 var MARKETS_CACHE_TTL_MS = 60 * 60 * 1e3;
 var isMarketShaped = (m) => {
   const market = m;
-  return typeof market?.pair === "string" && typeof market.base_asset?.id === "string" && typeof market.quote_asset?.id === "string" && typeof market.quote_asset.decimals === "number";
+  if (!market) return false;
+  return typeof market.base_asset?.id === "string" && typeof market.quote_asset?.id === "string" && typeof market.quote_asset.decimals === "number";
 };
 var readMarketsCache = async (repository, network, registry) => {
   try {
     const entry = await repository.getCachedMarkets(network, registry);
     if (!Array.isArray(entry?.markets) || typeof entry?.fetchedAt !== "number")
       return void 0;
-    return entry.markets.every(isMarketShaped) ? entry : void 0;
+    const markets = entry.markets.filter(isMarketShaped);
+    if (entry.markets.length > 0 && markets.length === 0) return void 0;
+    return { ...entry, markets };
   } catch {
     return void 0;
   }
@@ -771,10 +988,33 @@ var discoverMarkets = async (options) => {
 };
 var findMarket = (markets, fromId, toId) => {
   if (fromId === toId) return void 0;
-  const givingBase = bestMarket(markets, { baseId: fromId, quoteId: toId, wantSide: "quote" });
+  const resolveMarketId = (id) => {
+    for (const market of markets) {
+      for (const side of ["base", "quote"]) {
+        const asset2 = side === "base" ? market.base_asset : market.quote_asset;
+        if (asset2.id === id) return id;
+        const canonical = marketAssetId(market, side) ?? "";
+        const matchesBtc = id === BTC_ASSET_ID && /^arkade:[^/]+\/slip44:(?:0|1)$/.test(canonical);
+        const matchesAsset = /^[0-9a-f]{68}$/.test(id) && canonical.endsWith(`/asset:${id}`);
+        if ((matchesBtc || matchesAsset) && typeof asset2.id === "string") return asset2.id;
+      }
+    }
+    return id;
+  };
+  const resolvedFrom = resolveMarketId(fromId);
+  const resolvedTo = resolveMarketId(toId);
+  const givingBase = bestMarket(markets, {
+    baseId: resolvedFrom,
+    quoteId: resolvedTo,
+    wantSide: "quote"
+  });
   if (givingBase) return { market: givingBase, give: "base" };
   return {
-    market: bestMarket(markets, { baseId: toId, quoteId: fromId, wantSide: "base" }),
+    market: bestMarket(markets, {
+      baseId: resolvedTo,
+      quoteId: resolvedFrom,
+      wantSide: "base"
+    }),
     give: "quote"
   };
 };
@@ -901,8 +1141,320 @@ var IndexedDbAssetSwapRepository = class {
   }
 };
 
+// src/restore.ts
+import { base64, hex as hex3 } from "@scure/base";
+import {
+  Extension,
+  Transaction,
+  scriptFromTapLeafScript
+} from "@arkade-os/sdk";
+var TXS_PER_REQUEST = 50;
+async function fetchParsedTxs(indexer, txids) {
+  const parsedByTxid = /* @__PURE__ */ new Map();
+  if (txids.length === 0) return parsedByTxid;
+  const chunks = [];
+  for (let i = 0; i < txids.length; i += TXS_PER_REQUEST) {
+    chunks.push(txids.slice(i, i + TXS_PER_REQUEST));
+  }
+  const chunkResults = await Promise.allSettled(
+    chunks.map(async (ids) => (await indexer.getVirtualTxs(ids)).txs)
+  );
+  for (const result of chunkResults) {
+    if (result.status !== "fulfilled") continue;
+    for (const psbt of result.value) {
+      try {
+        const parsed = Transaction.fromPSBT(base64.decode(psbt));
+        parsedByTxid.set(parsed.id, parsed);
+      } catch {
+      }
+    }
+  }
+  return parsedByTxid;
+}
+var unscannedSwapCandidates = (txs, existingIds, scanned) => txs.filter(
+  (tx) => tx.type === "sent" && tx.redeemTxid && !existingIds.has(tx.redeemTxid) && !scanned.has(tx.redeemTxid)
+);
+function classifySpend(offer, serverPubkey, spendTx, deposit) {
+  let leaves;
+  try {
+    const script = offerVtxoScript(offer, serverPubkey);
+    if (hex3.encode(script.pkScript) !== hex3.encode(offer.swapPkScript)) return "indeterminate";
+    leaves = {
+      // both routes that hand the deposit back; `exit` is absent on an
+      // offer that carries no exit closure, and drops out here
+      returned: ["cancel", "exit"].map((name) => script.functionByName(name)?.leafScript).filter((leaf) => leaf !== void 0),
+      fulfill: script.functionByName("fulfill")?.leafScript
+    };
+  } catch {
+    return "indeterminate";
+  }
+  for (let i = 0; i < spendTx.inputsLength; i++) {
+    const input = spendTx.getInput(i);
+    if (!input.txid || input.index !== deposit.vout) continue;
+    if (hex3.encode(input.txid) !== deposit.txid) continue;
+    for (const leaf of input.tapLeafScript ?? []) {
+      const spent = hex3.encode(scriptFromTapLeafScript(leaf));
+      if (leaves.returned.some((back) => spent === hex3.encode(back))) return "cancelled";
+      if (leaves.fulfill && spent === hex3.encode(leaves.fulfill)) return "fulfilled";
+    }
+  }
+  return "indeterminate";
+}
+var spendTxidsOf = (vtxo) => [vtxo.spentBy, vtxo.arkTxId].filter((id) => Boolean(id));
+function classifyDepositSpend(offer, serverPubkey, spendTxs, deposit) {
+  for (const tx of spendTxs) {
+    const kind = classifySpend(offer, serverPubkey, tx, deposit);
+    if (kind !== "indeterminate") return kind;
+  }
+  return "indeterminate";
+}
+async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
+  const { serverPubkey, scanned = /* @__PURE__ */ new Set(), reopen = [] } = opts;
+  const reopened = [];
+  for (const swap of reopen) {
+    try {
+      reopened.push({
+        fundingTx: { type: "sent", redeemTxid: swap.fundingTxid },
+        offer: decodeOffer(hex3.decode(swap.offerHex)),
+        offerHex: swap.offerHex,
+        existing: swap
+      });
+    } catch {
+    }
+  }
+  const reopenedTxids = new Set(reopened.map((f) => f.fundingTx.redeemTxid));
+  const candidates = unscannedSwapCandidates(txs, existingIds, scanned).filter(
+    (tx) => !reopenedTxids.has(tx.redeemTxid)
+  );
+  if (candidates.length === 0 && reopened.length === 0) {
+    return { restored: [], scannedTxids: [] };
+  }
+  const byTxid = new Map(candidates.map((tx) => [tx.redeemTxid, tx]));
+  const parsedByTxid = await fetchParsedTxs(
+    indexer,
+    candidates.map((tx) => tx.redeemTxid)
+  );
+  const fetchedTxids = [];
+  const found = [...reopened];
+  for (const [txid, parsed] of parsedByTxid) {
+    const fundingTx = byTxid.get(txid);
+    if (!fundingTx) continue;
+    fetchedTxids.push(txid);
+    try {
+      const packet = Extension.fromTx(parsed).getPacketByType(OFFER_PACKET_TYPE);
+      if (!packet) continue;
+      const payload = packet.serialize();
+      found.push({
+        fundingTx,
+        offer: decodeOffer(payload),
+        offerHex: hex3.encode(payload)
+      });
+    } catch {
+    }
+  }
+  if (found.length === 0) return { restored: [], scannedTxids: fetchedTxids };
+  const scripts = [...new Set(found.map((f) => hex3.encode(f.offer.swapPkScript)))];
+  const { vtxos } = await indexer.getVtxos({ scripts });
+  const vtxoByScriptAndTxid = new Map(vtxos.map((v) => [`${v.script}:${v.txid}`, v]));
+  const txByAnyId = /* @__PURE__ */ new Map();
+  for (const tx of txs) {
+    for (const id of [tx.boardingTxid, tx.redeemTxid, tx.roundTxid]) {
+      if (id) txByAnyId.set(id, tx);
+    }
+  }
+  const spendTxids = /* @__PURE__ */ new Set();
+  for (const { fundingTx, offer } of found) {
+    const vtxo = vtxoByScriptAndTxid.get(
+      `${hex3.encode(offer.swapPkScript)}:${fundingTx.redeemTxid}`
+    );
+    if (vtxo?.virtualStatus.state !== "spent") continue;
+    for (const txid of spendTxidsOf(vtxo)) spendTxids.add(txid);
+  }
+  const spendTxByTxid = await fetchParsedTxs(indexer, [...spendTxids]);
+  const restored = [];
+  const unresolved = /* @__PURE__ */ new Set();
+  for (const { fundingTx, offer, offerHex, existing } of found) {
+    const swapPkScript = hex3.encode(offer.swapPkScript);
+    const vtxo = vtxoByScriptAndTxid.get(`${swapPkScript}:${fundingTx.redeemTxid}`);
+    if (!vtxo) {
+      unresolved.add(fundingTx.redeemTxid);
+      continue;
+    }
+    const depositRider = vtxo.assets?.length === 1 && vtxo.assets[0].amount > BigInt(0) ? vtxo.assets[0] : void 0;
+    const fromAsset = offer.offerAsset?.toString() ?? depositRider?.assetId ?? BTC_ASSET_ID;
+    const toAsset = offer.wantAsset?.toString() ?? BTC_ASSET_ID;
+    const depositAmount = fromAsset === BTC_ASSET_ID ? BigInt(vtxo.value) : vtxo.assets?.find((a) => a.assetId === fromAsset)?.amount;
+    if (depositAmount === void 0) {
+      unresolved.add(fundingTx.redeemTxid);
+      continue;
+    }
+    const fromAmount = depositAmount.toString();
+    const state = vtxo.virtualStatus.state;
+    const spentTxid = state === "spent" ? vtxo.arkTxId || vtxo.spentBy : void 0;
+    let status = "pending";
+    if (state === "swept") status = "recoverable";
+    else if (state === "spent") {
+      const spendTxs = spendTxidsOf(vtxo).map((id) => spendTxByTxid.get(id)).filter((tx) => tx !== void 0);
+      const kind = classifyDepositSpend(offer, serverPubkey, spendTxs, {
+        txid: vtxo.txid,
+        vout: vtxo.vout
+      });
+      if (kind === "indeterminate") {
+        unresolved.add(fundingTx.redeemTxid);
+        continue;
+      }
+      status = kind;
+    }
+    const completion = status === "fulfilled" && spentTxid && txByAnyId.get(spentTxid)?.createdAt ? { completedAt: txByAnyId.get(spentTxid).createdAt * 1e3 } : {};
+    if (existing) {
+      if (status === "pending") continue;
+      restored.push({ ...existing, status, spentTxid, ...completion });
+      continue;
+    }
+    restored.push({
+      id: fundingTx.redeemTxid,
+      fromAsset,
+      toAsset,
+      fromAmount,
+      toAmount: offer.wantAmount.toString(),
+      // ponytail(arkade-os/ts-sdk#680): empty address makes cancel fall back
+      // to the current server key; store the funded address if server-key
+      // rotations become real (cancelOffer now at least diagnoses the
+      // mismatch instead of reporting a missing VTXO)
+      swapAddress: "",
+      swapPkScript,
+      offerHex,
+      fundingTxid: fundingTx.redeemTxid,
+      spentTxid,
+      status,
+      createdAt: fundingTx.createdAt ? fundingTx.createdAt * 1e3 : vtxo.createdAt.getTime(),
+      ...completion
+    });
+  }
+  return { restored, scannedTxids: fetchedTxids.filter((id) => !unresolved.has(id)) };
+}
+
+// src/restoreRepository.ts
+var isOpen = (swap) => swap.status === "pending" || swap.status === "cancelling";
+var isOfferSwap = (swap) => typeof swap.offerHex === "string";
+var restoreCoverage = async (wallet, arkServerUrl, swaps) => {
+  const offers = swaps.filter(isOfferSwap);
+  if (offers.length > 0) await restoreOfferCoverage(wallet, arkServerUrl, offers);
+};
+var aborted = (swaps) => ({
+  swaps,
+  changes: [],
+  scannedTxids: [],
+  aborted: true
+});
+async function restoreAssetSwapRepository(opts) {
+  const { wallet, arkServerUrl, indexer, repository, txs, serverPubkey, prepareNew, signal } = opts;
+  const [existing, scanned] = await Promise.all([
+    getAssetSwapsOrThrow(repository),
+    repository.getScannedTxids()
+  ]);
+  if (signal?.aborted) return aborted(existing);
+  let scan;
+  try {
+    scan = await restoreAssetSwaps(indexer, txs, new Set(existing.map((swap) => swap.id)), {
+      serverPubkey,
+      scanned,
+      reopen: existing.filter((swap) => isOpen(swap) && isOfferSwap(swap))
+    });
+  } catch (scanError) {
+    if (!signal?.aborted) {
+      try {
+        await restoreCoverage(wallet, arkServerUrl, existing);
+      } catch (coverageError2) {
+        throw new AggregateError(
+          [scanError, coverageError2],
+          "asset-swap scan and covenant coverage restore both failed"
+        );
+      }
+    }
+    throw scanError;
+  }
+  if (signal?.aborted) return aborted(existing);
+  const before = new Map(existing.map((swap) => [swap.id, swap]));
+  const changes = [];
+  const cancelledAfterCommit = async (scannedTxids = []) => ({
+    swaps: await getAssetSwapsOrThrow(repository),
+    changes,
+    scannedTxids,
+    aborted: true
+  });
+  for (const restored of scan.restored) {
+    if (signal?.aborted) return cancelledAfterCommit();
+    const previous = before.get(restored.id);
+    const current = previous !== void 0 || !prepareNew ? restored : await prepareNew(restored);
+    if (current.id !== restored.id) {
+      throw new Error("prepareNew must not change an asset swap id");
+    }
+    if (signal?.aborted) return cancelledAfterCommit();
+    await repository.saveSwap(current);
+    changes.push(previous ? { previous, current } : { current });
+    if (signal?.aborted) return cancelledAfterCommit();
+  }
+  if (signal?.aborted) return cancelledAfterCommit();
+  if (scan.scannedTxids.length > 0) {
+    await repository.markTxidsScanned(scan.scannedTxids);
+  }
+  const swaps = await getAssetSwapsOrThrow(repository);
+  if (signal?.aborted) return cancelledAfterCommit(scan.scannedTxids);
+  let coverageError;
+  try {
+    await restoreCoverage(wallet, arkServerUrl, swaps);
+  } catch (error) {
+    coverageError = error;
+  }
+  return {
+    swaps,
+    changes,
+    scannedTxids: scan.scannedTxids,
+    aborted: false,
+    ...coverageError === void 0 ? {} : { coverageError }
+  };
+}
+
+// src/registerRestore.ts
+import { registerWalletRestoreHook } from "@arkade-os/sdk";
+var toRestoreTx = (tx) => ({
+  type: tx.type.toLowerCase(),
+  redeemTxid: tx.key.arkTxid,
+  boardingTxid: tx.key.boardingTxid,
+  roundTxid: tx.key.commitmentTxid,
+  createdAt: Math.floor(tx.createdAt / 1e3)
+});
+function registerAssetSwapRestore(wallet, options) {
+  return registerWalletRestoreHook(wallet, {
+    id: "arkade-os:asset-swap",
+    restore: async (restoredWallet) => {
+      const dependencies = restoredWallet;
+      const indexer = options.indexer ?? dependencies.indexerProvider;
+      const serverPubkey = options.serverPubkey ?? dependencies.arkServerPublicKey;
+      if (!indexer) {
+        throw new Error("asset-swap restore requires an indexer");
+      }
+      if (!serverPubkey) {
+        throw new Error("asset-swap restore requires an Ark server public key");
+      }
+      const history = await restoredWallet.getTransactionHistory();
+      const result = await restoreAssetSwapRepository({
+        wallet: restoredWallet,
+        arkServerUrl: options.arkServerUrl,
+        indexer,
+        repository: options.repository,
+        txs: history.map(toRestoreTx),
+        serverPubkey,
+        prepareNew: options.prepareNew
+      });
+      await options.onResult?.(result);
+    }
+  });
+}
+
 // src/rfqCorridors.ts
-import { hex as hex3 } from "@scure/base";
+import { hex as hex4 } from "@scure/base";
 
 // src/rfqCorridor.ts
 var RfqCorridorRegistry = class {
@@ -1058,13 +1610,13 @@ var LightningReceiveCorridor = {
 };
 function onchainSendProfile(result) {
   return {
-    claimKey: hex3.encode(result.htlcParams.claimKey),
-    refundKey: hex3.encode(result.htlcParams.refundKey),
+    claimKey: hex4.encode(result.htlcParams.claimKey),
+    refundKey: hex4.encode(result.htlcParams.refundKey),
     htlcLocktime: result.htlcParams.refundLocktime,
     network: result.l1Network,
     htlcAddress: result.htlc.address,
     minConfirmations: result.minConfirmations,
-    payoutPkScript: hex3.encode(result.payoutPkScript)
+    payoutPkScript: hex4.encode(result.payoutPkScript)
   };
 }
 var OnchainSendCorridor = {
@@ -1098,8 +1650,8 @@ var OnchainSendCorridor = {
         // unlocks both legs, but only one of the two hashes of it
         // is recoverable here.
         paymentHash,
-        claimKey: hex3.decode(profile.claimKey),
-        refundKey: hex3.decode(profile.refundKey),
+        claimKey: hex4.decode(profile.claimKey),
+        refundKey: hex4.decode(profile.refundKey),
         refundLocktime: profile.htlcLocktime
       },
       profile.network
@@ -1115,7 +1667,7 @@ var OnchainSendCorridor = {
       minConfirmations: profile.minConfirmations,
       // Optional here, required at the write: throwing on an older
       // record would strand the refund it is still owed.
-      ...profile.payoutPkScript ? { payoutPkScript: hex3.decode(profile.payoutPkScript) } : {},
+      ...profile.payoutPkScript ? { payoutPkScript: hex4.decode(profile.payoutPkScript) } : {},
       ...profile.funding ? { funding: profile.funding } : {},
       ...profile.claimTxid ? { claimTxid: profile.claimTxid } : {}
     };
@@ -1134,7 +1686,7 @@ rfqCorridorHandlers.register(OnchainSendCorridor);
 
 // src/rfqRecord.ts
 import { ArkAddress as ArkAddress2, VHTLCV2ContractHandler } from "@arkade-os/sdk";
-import { hex as hex4 } from "@scure/base";
+import { hex as hex5 } from "@scure/base";
 
 // src/rfqSwapState.ts
 var RFQ_SWAP_TERMINAL_STATES = ["settled", "refunded", "failed"];
@@ -1158,8 +1710,8 @@ function assertSameSwap(origin, swap) {
       `rfq swap record is a ${origin.kind} origin paired with a ${swap.kind} swap`
     );
   }
-  const funded = hex4.encode(ArkAddress2.decode(origin.lockupAddress).pkScript);
-  const watched = hex4.encode(swap.lockupPkScript);
+  const funded = hex5.encode(ArkAddress2.decode(origin.lockupAddress).pkScript);
+  const watched = hex5.encode(swap.lockupPkScript);
   if (funded !== watched) {
     throw new Error(
       `rfq swap record's lockup address holds ${funded}, but the swap watches ${watched} \u2014 these are not the same swap`
@@ -1205,9 +1757,9 @@ function rfqSwapOriginOf(record) {
 function lockupScript(params, lockupAddress) {
   const script = VHTLCV2ContractHandler.createScript(params);
   const funded = ArkAddress2.decode(lockupAddress).pkScript;
-  if (hex4.encode(funded) !== hex4.encode(script.pkScript)) {
+  if (hex5.encode(funded) !== hex5.encode(script.pkScript)) {
     throw new Error(
-      `rfq swap covenant params derive ${hex4.encode(script.pkScript)}, but the record's lockup address holds ${hex4.encode(funded)} \u2014 these params are not this swap's`
+      `rfq swap covenant params derive ${hex5.encode(script.pkScript)}, but the record's lockup address holds ${hex5.encode(funded)} \u2014 these params are not this swap's`
     );
   }
   return script;
@@ -1241,178 +1793,6 @@ function shouldRetainRfqSwap(record, now) {
   return now - record.updatedAt < RFQ_SWAP_RETENTION_SECONDS;
 }
 
-// src/restore.ts
-import { base64, hex as hex5 } from "@scure/base";
-import {
-  Extension,
-  Transaction,
-  scriptFromTapLeafScript
-} from "@arkade-os/sdk";
-var TXS_PER_REQUEST = 50;
-async function fetchParsedTxs(indexer, txids) {
-  const parsedByTxid = /* @__PURE__ */ new Map();
-  if (txids.length === 0) return parsedByTxid;
-  const chunks = [];
-  for (let i = 0; i < txids.length; i += TXS_PER_REQUEST) {
-    chunks.push(txids.slice(i, i + TXS_PER_REQUEST));
-  }
-  const chunkResults = await Promise.allSettled(
-    chunks.map(async (ids) => (await indexer.getVirtualTxs(ids)).txs)
-  );
-  for (const result of chunkResults) {
-    if (result.status !== "fulfilled") continue;
-    for (const psbt of result.value) {
-      try {
-        const parsed = Transaction.fromPSBT(base64.decode(psbt));
-        parsedByTxid.set(parsed.id, parsed);
-      } catch {
-      }
-    }
-  }
-  return parsedByTxid;
-}
-var unscannedSwapCandidates = (txs, existingIds, scanned) => txs.filter(
-  (tx) => tx.type === "sent" && tx.redeemTxid && !existingIds.has(tx.redeemTxid) && !scanned.has(tx.redeemTxid)
-);
-function classifySpend(offer, serverPubkey, spendTx, deposit) {
-  let leaves;
-  try {
-    const script = offerVtxoScript(offer, serverPubkey);
-    if (hex5.encode(script.pkScript) !== hex5.encode(offer.swapPkScript)) return "indeterminate";
-    leaves = {
-      // both routes that hand the deposit back; `exit` is absent on an
-      // offer that carries no exit closure, and drops out here
-      returned: ["cancel", "exit"].map((name) => script.functionByName(name)?.leafScript).filter((leaf) => leaf !== void 0),
-      fulfill: script.functionByName("fulfill")?.leafScript
-    };
-  } catch {
-    return "indeterminate";
-  }
-  for (let i = 0; i < spendTx.inputsLength; i++) {
-    const input = spendTx.getInput(i);
-    if (!input.txid || input.index !== deposit.vout) continue;
-    if (hex5.encode(input.txid) !== deposit.txid) continue;
-    for (const leaf of input.tapLeafScript ?? []) {
-      const spent = hex5.encode(scriptFromTapLeafScript(leaf));
-      if (leaves.returned.some((back) => spent === hex5.encode(back))) return "cancelled";
-      if (leaves.fulfill && spent === hex5.encode(leaves.fulfill)) return "fulfilled";
-    }
-  }
-  return "indeterminate";
-}
-var spendTxidsOf = (vtxo) => [vtxo.spentBy, vtxo.arkTxId].filter((id) => Boolean(id));
-function classifyDepositSpend(offer, serverPubkey, spendTxs, deposit) {
-  for (const tx of spendTxs) {
-    const kind = classifySpend(offer, serverPubkey, tx, deposit);
-    if (kind !== "indeterminate") return kind;
-  }
-  return "indeterminate";
-}
-async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
-  const { serverPubkey, scanned = /* @__PURE__ */ new Set() } = opts;
-  const candidates = unscannedSwapCandidates(txs, existingIds, scanned);
-  if (candidates.length === 0) return { restored: [], scannedTxids: [] };
-  const byTxid = new Map(candidates.map((tx) => [tx.redeemTxid, tx]));
-  const parsedByTxid = await fetchParsedTxs(
-    indexer,
-    candidates.map((tx) => tx.redeemTxid)
-  );
-  const fetchedTxids = [];
-  const found = [];
-  for (const [txid, parsed] of parsedByTxid) {
-    const fundingTx = byTxid.get(txid);
-    if (!fundingTx) continue;
-    fetchedTxids.push(txid);
-    try {
-      const packet = Extension.fromTx(parsed).getPacketByType(OFFER_PACKET_TYPE);
-      if (!packet) continue;
-      const payload = packet.serialize();
-      found.push({
-        fundingTx,
-        offer: decodeOffer(payload),
-        offerHex: hex5.encode(payload)
-      });
-    } catch {
-    }
-  }
-  if (found.length === 0) return { restored: [], scannedTxids: fetchedTxids };
-  const scripts = [...new Set(found.map((f) => hex5.encode(f.offer.swapPkScript)))];
-  const { vtxos } = await indexer.getVtxos({ scripts });
-  const vtxoByScriptAndTxid = new Map(vtxos.map((v) => [`${v.script}:${v.txid}`, v]));
-  const txByAnyId = /* @__PURE__ */ new Map();
-  for (const tx of txs) {
-    for (const id of [tx.boardingTxid, tx.redeemTxid, tx.roundTxid]) {
-      if (id) txByAnyId.set(id, tx);
-    }
-  }
-  const spendTxids = /* @__PURE__ */ new Set();
-  for (const { fundingTx, offer } of found) {
-    const vtxo = vtxoByScriptAndTxid.get(
-      `${hex5.encode(offer.swapPkScript)}:${fundingTx.redeemTxid}`
-    );
-    if (vtxo?.virtualStatus.state !== "spent") continue;
-    for (const txid of spendTxidsOf(vtxo)) spendTxids.add(txid);
-  }
-  const spendTxByTxid = await fetchParsedTxs(indexer, [...spendTxids]);
-  const restored = [];
-  const unresolved = /* @__PURE__ */ new Set();
-  for (const { fundingTx, offer, offerHex } of found) {
-    const swapPkScript = hex5.encode(offer.swapPkScript);
-    const vtxo = vtxoByScriptAndTxid.get(`${swapPkScript}:${fundingTx.redeemTxid}`);
-    if (!vtxo) {
-      unresolved.add(fundingTx.redeemTxid);
-      continue;
-    }
-    const depositRider = vtxo.assets?.length === 1 && vtxo.assets[0].amount > BigInt(0) ? vtxo.assets[0] : void 0;
-    const fromAsset = offer.offerAsset?.toString() ?? depositRider?.assetId ?? BTC_ASSET_ID;
-    const toAsset = offer.wantAsset?.toString() ?? BTC_ASSET_ID;
-    const depositAmount = fromAsset === BTC_ASSET_ID ? BigInt(vtxo.value) : vtxo.assets?.find((a) => a.assetId === fromAsset)?.amount;
-    if (depositAmount === void 0) {
-      unresolved.add(fundingTx.redeemTxid);
-      continue;
-    }
-    const fromAmount = depositAmount.toString();
-    const state = vtxo.virtualStatus.state;
-    const spentTxid = state === "spent" ? vtxo.arkTxId || vtxo.spentBy : void 0;
-    let status = "pending";
-    if (state === "swept") status = "recoverable";
-    else if (state === "spent") {
-      const spendTxs = spendTxidsOf(vtxo).map((id) => spendTxByTxid.get(id)).filter((tx) => tx !== void 0);
-      const kind = classifyDepositSpend(offer, serverPubkey, spendTxs, {
-        txid: vtxo.txid,
-        vout: vtxo.vout
-      });
-      if (kind === "indeterminate") {
-        unresolved.add(fundingTx.redeemTxid);
-        continue;
-      }
-      status = kind;
-    }
-    restored.push({
-      id: fundingTx.redeemTxid,
-      fromAsset,
-      toAsset,
-      fromAmount,
-      toAmount: offer.wantAmount.toString(),
-      // ponytail(arkade-os/ts-sdk#680): empty address makes cancel fall back
-      // to the current server key; store the funded address if server-key
-      // rotations become real (cancelOffer now at least diagnoses the
-      // mismatch instead of reporting a missing VTXO)
-      swapAddress: "",
-      swapPkScript,
-      offerHex,
-      fundingTxid: fundingTx.redeemTxid,
-      spentTxid,
-      status,
-      createdAt: fundingTx.createdAt ? fundingTx.createdAt * 1e3 : vtxo.createdAt.getTime(),
-      // the completion time is the caller's record of the spend, if it
-      // has one — the psbt that classified it carries no timestamp
-      ...status === "fulfilled" && spentTxid && txByAnyId.get(spentTxid)?.createdAt ? { completedAt: txByAnyId.get(spentTxid).createdAt * 1e3 } : {}
-    });
-  }
-  return { restored, scannedTxids: fetchedTxids.filter((id) => !unresolved.has(id)) };
-}
-
 // src/watch.ts
 import { base64 as base642, hex as hex6 } from "@scure/base";
 import {
@@ -1463,34 +1843,54 @@ async function watchOfferSwaps({
       return "indeterminate";
     }
   };
-  const handleSpend = async (event) => {
-    if (event.contract.metadata?.kind !== OFFER_CONTRACT_KIND) return;
-    for (const vtxo of event.vtxos) {
+  const resolveSpends = async (contractScript, vtxos, { at, known } = {}) => {
+    let swaps = known ?? await getAssetSwaps(repository);
+    for (const vtxo of vtxos) {
       const spentTxid = vtxo.arkTxId || vtxo.spentBy;
       if (!spentTxid) continue;
-      const swap = (await getAssetSwaps(repository)).find(
-        (s) => s.fundingTxid === vtxo.txid && s.swapPkScript === event.contractScript
+      const swap = swaps.find(
+        (s) => s.fundingTxid === vtxo.txid && s.swapPkScript === contractScript
       );
       if (!swap) continue;
       const kind = await classify(swap, vtxo, spentTxid);
-      const changes = spendUpdate(swap, { txid: spentTxid, kind, at: event.timestamp });
+      const changes = spendUpdate(swap, { txid: spentTxid, kind, at });
       if (!changes) continue;
-      const { persisted, swaps } = await updateAssetSwapBestEffort(
+      const { persisted, swaps: written } = await updateAssetSwapBestEffort(
         repository,
         swap.id,
         changes
       );
       if (!persisted) continue;
+      swaps = written;
       onUpdate?.({ ...swap, ...changes });
       if (changes.status && RETIRABLE.includes(changes.status)) {
-        await retireOfferContract(manager, swaps, event.contractScript);
+        await retireOfferContract(manager, swaps, contractScript);
       }
     }
   };
+  const handleSpend = async (event) => {
+    if (event.contract.metadata?.kind !== OFFER_CONTRACT_KIND) return;
+    await resolveSpends(event.contractScript, event.vtxos, { at: event.timestamp });
+  };
+  const resolveOpenSwaps = async () => {
+    const swaps = await getAssetSwaps(repository);
+    const open = swaps.filter((s) => !TERMINAL.includes(s.status));
+    if (open.length === 0) return;
+    const script = [...new Set(open.map((s) => s.swapPkScript))];
+    for (const { contract, vtxos } of await manager.getContractsWithVtxos({ script })) {
+      if (contract.metadata?.kind !== OFFER_CONTRACT_KIND) continue;
+      await resolveSpends(
+        contract.script,
+        vtxos.filter((v) => v.isSpent),
+        { known: swaps }
+      );
+    }
+  };
   const unsubscribe = manager.onContractEvent((event) => {
     if (!isContractVtxoEvent(event) || event.type !== "vtxo_spent") return;
     enqueue(() => handleSpend(event));
   });
+  enqueue(resolveOpenSwaps);
   return {
     stop: unsubscribe,
     idle: () => queue
@@ -1644,6 +2044,7 @@ function solverOnchainRail(deps) {
         amount,
         fee: swap.fundAmount - amount,
         total: swap.fundAmount,
+        validUntil: swap.quote.valid_until,
         meta: {
           rfqId: swap.rfqId,
           validUntil: swap.quote.valid_until,
@@ -1754,6 +2155,9 @@ function solverLightningRail(deps) {
         amount: facts.amountSats,
         fee: swap.fundAmount - facts.amountSats,
         total: swap.fundAmount,
+        // The invoice can lapse before the quote does; the earlier bound
+        // is the one a holder must observe.
+        validUntil: Math.min(swap.quote.valid_until, facts.expiresAt),
         meta: {
           rfqId: swap.rfqId,
           validUntil: swap.quote.valid_until,
@@ -1811,6 +2215,7 @@ var parseAssetId = (assetId) => {
     return void 0;
   }
 };
+var marketLabel = (market) => `${market.base_asset.ticker || market.base_asset.id}/${market.quote_asset.ticker || market.quote_asset.id}`;
 function crossAssetRail(deps) {
   const planFor = async (asset2) => {
     const markets = await deps.discover();
@@ -1873,7 +2278,7 @@ function crossAssetRail(deps) {
           spent: { assetId: BTC_ASSET_ID, amount: plan.deposit.atomic }
         },
         meta: {
-          market: plan.market.pair,
+          market: marketLabel(plan.market),
           priceDisplay: plan.priceDisplay,
           give: plan.give
         },
@@ -3597,6 +4002,7 @@ async function lockupTxids(indexer, record, wantFunding) {
 export {
   ARKADE_ASSET,
   ARKADE_BTC,
+  ASSET_CARRIER_SATS,
   AddressMismatch,
   BTC_ASSET_ID,
   CROSS_ASSET_RAIL,
@@ -3611,6 +4017,7 @@ export {
   LockupContractMissing,
   LockupNeedsRecoveryError,
   LockupRegistrationFailed,
+  MARKET_CORRIDORS,
   MAX_MIN_CONFIRMATIONS,
   MIN_CLAIM_WINDOW_SECONDS,
   MIN_HEADROOM_SECONDS,
@@ -3625,6 +4032,7 @@ export {
   PreimageNotRecoverableError,
   QUOTE_OPTIONS,
   REFUND_MTP_LAG_SECONDS,
+  RFQ_REFUSAL_ERROR_CODES,
   RFQ_RESOLVED_STATES,
   RFQ_SWAP_RETENTION_SECONDS,
   RFQ_SWAP_TERMINAL_STATES,
@@ -3668,11 +4076,14 @@ export {
   discoverMarkets,
   encodeOffer,
   extractPreimage,
+  fillOffer,
   findLockupVtxos,
   findMarket,
   getAssetSwaps,
   getAssetSwapsOrThrow,
   httpTransport,
+  isRfqMarket,
+  isRfqRefusalErrorCode,
   isRfqSwapTerminal,
   isRfqTerminal,
   l1ScriptForAddress,
@@ -3681,6 +4092,9 @@ export {
   lightningSendVtxoScript,
   lockupContractParams,
   makeCachedFeedFetch,
+  marketAssetId,
+  marketCorridor,
+  marketPairLabel,
   newPreimage,
   newRfqId,
   nextOnchainAction,
@@ -3698,13 +4112,16 @@ export {
   rebuildRfqSwap,
   receiveVtxoScript,
   refundIfUnresolved,
+  registerAssetSwapRestore,
   registerLockupContract,
   relayTransport,
   requestLightningReceive,
   requestLightningSend,
   requestOnchainReceive,
   requestOnchainSend,
+  restoreAssetSwapRepository,
   restoreAssetSwaps,
+  restoreOfferCoverage,
   retireSettledOfferContracts,
   revealClaimPacket,
   revealFieldsFromScript,