@arkade-os/swap 0.1.0-rc.12 → 0.1.0-rc.13

package/dist/advanced.cjs

@@ -1739,6 +1739,7 @@ __export(advanced_exports, {
   esploraTip: () => esploraTip,
   exchange: () => exchange,
   familyOfSwapId: () => familyOfSwapId,
+  fateMoved: () => fateMoved,
   feedFetch: () => feedFetch,
   formatAssetId: () => formatAssetId,
   fromAtomicDecimal: () => fromAtomicDecimal,
@@ -1786,6 +1787,7 @@ __export(advanced_exports, {
   resolveCorridorBase: () => resolveCorridorBase,
   resolveCorridorDeps: () => resolveCorridorDeps,
   resolveRoute: () => resolveRoute,
+  restoredOfferRecord: () => restoredOfferRecord,
   revealClaimPacket: () => revealClaimPacket,
   revealFieldsFromScript: () => revealFieldsFromScript,
   rfqLeg: () => rfqLeg,
@@ -1813,7 +1815,7 @@ __export(advanced_exports, {
   verifyingDerivation: () => verifyingDerivation,
   walletLockupIndexer: () => walletLockupIndexer,
   withCanonicalAmount: () => withCanonicalAmount,
-  withOfferStatus: () => withOfferStatus,
+  withDepositFate: () => withDepositFate,
   withRfqState: () => withRfqState
 });
 module.exports = __toCommonJS(advanced_exports);
@@ -2306,10 +2308,10 @@ var QuoteExpired = class extends Error {
   name = "QuoteExpired";
 };
 var MaxFeeExceeded = class extends Error {
-  constructor(quoteId, asset5, fee, maxFee) {
-    super(`fee ${fee} of ${asset5} exceeds the ${maxFee} ceiling`);
+  constructor(quoteId, asset6, fee, maxFee) {
+    super(`fee ${fee} of ${asset6} exceeds the ${maxFee} ceiling`);
     this.quoteId = quoteId;
-    this.asset = asset5;
+    this.asset = asset6;
     this.fee = fee;
     this.maxFee = maxFee;
   }
@@ -2320,11 +2322,11 @@ var MaxFeeExceeded = class extends Error {
   name = "MaxFeeExceeded";
 };
 var InsufficientFunds = class extends Error {
-  constructor(asset5, required, available) {
+  constructor(asset6, required, available) {
     super(
-      `funding needs ${required} of ${asset5}` + (available === void 0 ? "" : `, wallet holds ${available}`)
+      `funding needs ${required} of ${asset6}` + (available === void 0 ? "" : `, wallet holds ${available}`)
     );
-    this.asset = asset5;
+    this.asset = asset6;
     this.required = required;
     this.available = available;
   }
@@ -2362,9 +2364,9 @@ var NotCancellable = class extends Error {
   name = "NotCancellable";
 };
 var InconsistentRoute = class extends Error {
-  constructor(asset5, destination) {
-    super(`destination ${JSON.stringify(destination)} is not on ${asset5}'s chain`);
-    this.asset = asset5;
+  constructor(asset6, destination) {
+    super(`destination ${JSON.stringify(destination)} is not on ${asset6}'s chain`);
+    this.asset = asset6;
     this.destination = destination;
   }
   asset;
@@ -2417,24 +2419,24 @@ function isSwapError(e, name) {
 // src/client/aliases.ts
 var toDiscoveryLeg = (id) => {
   const { rail, assetNamespace, assetReference } = parseAssetId(id);
-  const asset5 = `${assetNamespace}:${assetReference}`;
+  const asset6 = `${assetNamespace}:${assetReference}`;
   if (rail === "arkade") {
-    if (asset5 === BTC_ASSET_PART)
+    if (asset6 === BTC_ASSET_PART)
       return { corridor: "arkade", assetId: BTC_ASSET_ID, marketId: id };
     if (assetNamespace === ARKADE_ASSET_NAMESPACE) {
       return { corridor: "arkade", assetId: assetReference, marketId: id };
     }
-    throw new UnsupportedRoute(`the arkade corridor has no ${asset5}`);
+    throw new UnsupportedRoute(`the arkade corridor has no ${asset6}`);
   }
   if (rail === "bolt11") {
-    if (asset5 === BTC_ASSET_PART)
+    if (asset6 === BTC_ASSET_PART)
       return { corridor: "lightning", assetId: BTC_ASSET_ID, marketId: id };
-    throw new UnsupportedRoute(`the lightning corridor carries BTC only, not ${asset5}`);
+    throw new UnsupportedRoute(`the lightning corridor carries BTC only, not ${asset6}`);
   }
   if (rail === "bitcoin") {
-    if (asset5 === BTC_ASSET_PART)
+    if (asset6 === BTC_ASSET_PART)
       return { corridor: "onchain", assetId: BTC_ASSET_ID, marketId: id };
-    throw new UnsupportedRoute(`the onchain corridor carries BTC only, not ${asset5}`);
+    throw new UnsupportedRoute(`the onchain corridor carries BTC only, not ${asset6}`);
   }
   throw new UnsupportedRoute(`no corridor serves ${id}`);
 };
@@ -2715,8 +2717,8 @@ var Amount = {
    * result would not survive the record boundary, so one law holds in both
    * directions.
    */
-  parse(display, asset5) {
-    assertDecimals(asset5.decimals);
+  parse(display, asset6) {
+    assertDecimals(asset6.decimals);
     const parts = SCALED_DECIMAL.exec(display);
     if (!parts) {
       throw new AmountFormatError(
@@ -2725,17 +2727,17 @@ var Amount = {
       );
     }
     const [, whole, fraction = ""] = parts;
-    if (fraction.length > asset5.decimals) {
+    if (fraction.length > asset6.decimals) {
       throw new AmountFormatError(
         "too_precise",
-        `${display} has more precision than ${asset5.decimals} decimals allow`
+        `${display} has more precision than ${asset6.decimals} decimals allow`
       );
     }
     if (whole.length + fraction.length > MAX_SIGNIFICANT_DIGITS) {
       throw new AmountFormatError("too_large", `${display} has too many digits`);
     }
-    const value = (0, import_solver_discovery3.toAtomic)(display, asset5.decimals);
-    assertRepresentable(value, `${display} at ${asset5.decimals} decimals`);
+    const value = (0, import_solver_discovery3.toAtomic)(display, asset6.decimals);
+    assertRepresentable(value, `${display} at ${asset6.decimals} decimals`);
     return value;
   },
   /**
@@ -2744,13 +2746,13 @@ var Amount = {
    * Refuses a negative: every amount on this surface is an obligation, and a
    * negative one is a defect upstream rather than a number to render.
    */
-  format(value, asset5) {
-    assertDecimals(asset5.decimals);
+  format(value, asset6) {
+    assertDecimals(asset6.decimals);
     if (value < 0n) {
       throw new AmountFormatError("negative", `amount must be non-negative, got ${value}`);
     }
     assertRepresentable(value, `${value}`);
-    return (0, import_solver_discovery3.fromAtomic)(value, asset5.decimals);
+    return (0, import_solver_discovery3.fromAtomic)(value, asset6.decimals);
   }
 };
 var toAtomicDecimal = (value) => {
@@ -3215,9 +3217,9 @@ var LEGACY_CORRIDORS = {
 };
 var assetOf = (market, side) => side === "base" ? market.base_asset : market.quote_asset;
 var marketAssetId = (market, side) => {
-  const asset5 = assetOf(market, side);
-  if (typeof asset5?.caip19_id === "string") return asset5.caip19_id;
-  return typeof asset5?.id === "string" ? asset5.id : void 0;
+  const asset6 = assetOf(market, side);
+  if (typeof asset6?.caip19_id === "string") return asset6.caip19_id;
+  return typeof asset6?.id === "string" ? asset6.id : void 0;
 };
 var chainNamespaceOf = (id) => {
   if (id === void 0) return void 0;
@@ -3329,30 +3331,26 @@ var LockupNeedsRecoveryError = class extends Error {
     this.recoverableAfter = recoverableAfter;
   }
 };
-async function findLockupVtxos(indexer, swapPkScript) {
-  const scripts = [import_base9.hex.encode(swapPkScript)];
-  const [spendable, recoverable] = await Promise.all([
-    indexer.getVtxos({ scripts, spendableOnly: true }),
-    indexer.getVtxos({ scripts, recoverableOnly: true })
-  ]);
+async function findLockupVtxos(contracts, swapPkScript) {
+  const [row] = await contracts.getContractsWithVtxos({
+    script: import_base9.hex.encode(swapPkScript)
+  });
   const seen = /* @__PURE__ */ new Set();
   const out = [];
-  for (const [vtxos, isRecoverable] of [
-    [spendable.vtxos ?? [], false],
-    [recoverable.vtxos ?? [], true]
-  ]) {
-    for (const vtxo of vtxos) {
-      if (vtxo.isUnrolled) continue;
-      const key = `${vtxo.txid}:${vtxo.vout}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      out.push({
-        txid: vtxo.txid,
-        vout: vtxo.vout,
-        value: Number(vtxo.value),
-        recoverable: isRecoverable
-      });
-    }
+  for (const vtxo of row?.vtxos ?? []) {
+    if (vtxo.isUnrolled) continue;
+    if ((0, import_sdk10.hasTerminalSpend)(vtxo)) continue;
+    const key = `${vtxo.txid}:${vtxo.vout}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({
+      txid: vtxo.txid,
+      vout: vtxo.vout,
+      value: Number(vtxo.value),
+      // The manager's canonical `isSwept` fact; no coercion, because the
+      // normalized row guarantees a boolean.
+      recoverable: vtxo.isSwept
+    });
   }
   return out;
 }
@@ -3939,7 +3937,7 @@ var discoveryIndex = (input) => {
 
 // src/client/cancel.ts
 var import_base12 = require("@scure/base");
-var import_sdk17 = require("@arkade-os/sdk");
+var import_sdk18 = require("@arkade-os/sdk");
 init_coverage();
 init_offer();
 
@@ -4009,7 +4007,7 @@ function classifyDepositSpend(offer, operatorPubkey, spendTxs, deposit) {
   return "indeterminate";
 }
 async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
-  const { operatorPubkey, scanned = /* @__PURE__ */ new Set(), reopen = [] } = opts;
+  const { operatorPubkey, scanned = /* @__PURE__ */ new Set(), reopen = [], hrp } = opts;
   const reopened = [];
   for (const swap of reopen) {
     try {
@@ -4110,17 +4108,27 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
       restored.push({ ...existing, status, spentTxid, ...completion });
       continue;
     }
+    let swapAddress = "";
+    try {
+      const compiled = offerContract(offer, operatorPubkey);
+      if (import_base11.hex.encode(compiled.pkScript) !== swapPkScript) {
+        unresolved.add(fundingTx.redeemTxid);
+        continue;
+      }
+      if (hrp !== void 0) {
+        swapAddress = compiled.address(hrp, operatorPubkey).encode();
+      }
+    } catch {
+      unresolved.add(fundingTx.redeemTxid);
+      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 operator key; store the funded address if operator-key
-      // rotations become real (cancelOffer now at least diagnoses the
-      // mismatch instead of reporting a missing VTXO)
-      swapAddress: "",
+      swapAddress,
       swapPkScript,
       offerHex,
       fundingTxid: fundingTx.redeemTxid,
@@ -4136,6 +4144,8 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
 }
 
 // src/client/driveRecords.ts
+init_store();
+var import_sdk17 = require("@arkade-os/sdk");
 var splitRecords = (records) => {
   const corridor = [];
   const offer = [];
@@ -4277,7 +4287,44 @@ var applyOfferSpend = (record, changes, now) => ({
   ...changes.completedAt === void 0 ? {} : { completedAt: Math.floor(changes.completedAt / 1e3) },
   updatedAt: now
 });
-var withOfferStatus = (record, status, now) => ({ ...record, status, updatedAt: now });
+var withDepositFate = (record, fate, now) => ({
+  ...record,
+  status: fate.status,
+  ...fate.spentTxid === void 0 ? {} : { spentTxid: fate.spentTxid },
+  ...fate.completedAt === void 0 ? {} : { completedAt: Math.floor(fate.completedAt / 1e3) },
+  updatedAt: now
+});
+var fateMoved = (record, fate) => record.status !== fate.status || fate.spentTxid !== void 0 && record.spentTxid !== fate.spentTxid || fate.completedAt !== void 0 && record.completedAt !== Math.floor(fate.completedAt / 1e3);
+var restoredOfferRecord = (swap, network, now) => {
+  const give = restoredAssetId(network, swap.fromAsset);
+  const take = restoredAssetId(network, swap.toAsset);
+  const createdAt = Math.floor(swap.createdAt / 1e3);
+  return withDepositFate(
+    {
+      id: swap.fundingTxid,
+      family: "offer",
+      route: {
+        give: { corridor: "arkade", asset: give, instrument: { kind: "wallet" } },
+        take: { corridor: "arkade", asset: take, instrument: { kind: "wallet" } }
+      },
+      give: { asset: give, amount: toAtomicDecimal(BigInt(swap.fromAmount)) },
+      take: { asset: take, amount: toAtomicDecimal(BigInt(swap.toAmount)) },
+      fee: { asset: take, amount: toAtomicDecimal(BigInt(0)) },
+      market: { kind: "restored", backend: "feed" },
+      expiresAt: createdAt,
+      status: swap.status,
+      offerHex: swap.offerHex,
+      swapAddress: swap.swapAddress,
+      swapPkScript: swap.swapPkScript,
+      fundingTxid: swap.fundingTxid,
+      createdAt,
+      updatedAt: now
+    },
+    swap,
+    now
+  );
+};
+var restoredAssetId = (network, id) => id === BTC_ASSET_ID ? btcOn("arkade", network) : arkadeAsset(network, import_sdk17.asset.AssetId.fromString(id));
 var walletLockupIndexer = (wallet) => {
   let reader;
   const reading = () => reader ??= wallet.getArkadeReader();
@@ -4367,12 +4414,12 @@ var reconcileDepositSpend = async (record, indexer) => {
   const { txs } = await indexer.getVirtualTxs(candidates);
   const parsed = txs.map((psbt) => {
     try {
-      return import_sdk17.Transaction.fromPSBT(import_base12.base64.decode(psbt));
+      return import_sdk18.Transaction.fromPSBT(import_base12.base64.decode(psbt));
     } catch {
       return void 0;
     }
   }).filter((tx) => tx !== void 0);
-  const operatorPubkey = import_sdk17.ArkAddress.decode(record.swapAddress).serverPubKey;
+  const operatorPubkey = import_sdk18.ArkAddress.decode(record.swapAddress).serverPubKey;
   const kind = classifyDepositSpend(offer, operatorPubkey, parsed, {
     txid: deposit.txid,
     vout: deposit.vout
@@ -4411,14 +4458,14 @@ var retireOfferScripts = async (wallet, repository, record) => {
 var isMissingVtxo = (error) => error instanceof NoSpendableDepositError;
 
 // src/client/drive.ts
-var import_sdk23 = require("@arkade-os/sdk");
+var import_sdk24 = require("@arkade-os/sdk");
 var import_base17 = require("@scure/base");
 
 // src/claim.ts
 var import_base13 = require("@scure/base");
 var import_legacy3 = require("@noble/hashes/legacy.js");
 var import_sha25 = require("@noble/hashes/sha2.js");
-var import_sdk18 = require("@arkade-os/sdk");
+var import_sdk19 = require("@arkade-os/sdk");
 var LockupAmountMismatchError = class extends Error {
   name = "LockupAmountMismatchError";
   reason = "amount_mismatch";
@@ -4462,14 +4509,14 @@ async function pushClaim(operator, input) {
   const info = await operator.getInfo();
   let operatorUnrollScript;
   try {
-    operatorUnrollScript = import_sdk18.CSVMultisigTapscript.decode(import_base13.hex.decode(info.checkpointTapscript));
+    operatorUnrollScript = import_sdk19.CSVMultisigTapscript.decode(import_base13.hex.decode(info.checkpointTapscript));
   } catch {
     throw new Error("invalid checkpointTapscript from the operator");
   }
   const leaf = input.contract.claim();
   const tapTree = input.contract.encode();
-  const txid = await (0, import_sdk18.signAndSubmitOffchainTx)({
-    identity: (0, import_sdk18.claimWithPreimageIdentity)(input.receiver, input.preimage),
+  const txid = await (0, import_sdk19.signAndSubmitOffchainTx)({
+    identity: (0, import_sdk19.claimWithPreimageIdentity)(input.receiver, input.preimage),
     provider: operator,
     inputs: input.vtxos.map((vtxo) => ({
       txid: vtxo.txid,
@@ -4493,7 +4540,7 @@ init_coverage();
 init_lockupContract();
 
 // src/refundBlocked.ts
-var import_sdk19 = require("@arkade-os/sdk");
+var import_sdk20 = require("@arkade-os/sdk");
 var RefundNotLocallyPossibleError = class extends Error {
   constructor(reason, message, options) {
     super(message, options);
@@ -4510,16 +4557,16 @@ async function senderIdentityForSwapRecord(wallet, record) {
     );
   }
   try {
-    return await (0, import_sdk19.contractSigner)(wallet, record.signingDescriptor);
+    return await (0, import_sdk20.contractSigner)(wallet, record.signingDescriptor);
   } catch (cause) {
-    if (cause instanceof import_sdk19.WalletCannotSignError) {
+    if (cause instanceof import_sdk20.WalletCannotSignError) {
       throw new RefundNotLocallyPossibleError(
         "unsignable-wallet",
         `this wallet holds ${record.signingDescriptor} but cannot sign with it; attach its signer`,
         { cause }
       );
     }
-    if (cause instanceof import_sdk19.ForeignDescriptorError) {
+    if (cause instanceof import_sdk20.ForeignDescriptorError) {
       throw new RefundNotLocallyPossibleError(
         "foreign-descriptor",
         `this wallet cannot derive ${record.signingDescriptor}; the swap was created on another wallet`,
@@ -4539,7 +4586,7 @@ function arkadeRefunder(deps) {
         `swap ${swap.rfqId} carries no lockup covenant, so its refund cannot be built`
       );
     }
-    const vtxos = await findLockupVtxos(deps.indexer, swap.lockupPkScript);
+    const vtxos = await findLockupVtxos(deps.contracts, swap.lockupPkScript);
     if (vtxos.length === 0) return null;
     const record = await deps.repository.getRfqSwap(swap.rfqId);
     if (!record) {
@@ -4554,7 +4601,7 @@ function arkadeRefunder(deps) {
 }
 
 // src/rfqRecord.ts
-var import_sdk20 = require("@arkade-os/sdk");
+var import_sdk21 = require("@arkade-os/sdk");
 var import_base14 = require("@scure/base");
 
 // src/rfqSwapState.ts
@@ -4600,7 +4647,7 @@ function assertSameSwap(origin, swap) {
       `rfq swap record is a ${origin.kind} origin paired with a ${swap.kind} swap`
     );
   }
-  const funded = import_base14.hex.encode(import_sdk20.ArkAddress.decode(origin.lockupAddress).pkScript);
+  const funded = import_base14.hex.encode(import_sdk21.ArkAddress.decode(origin.lockupAddress).pkScript);
   const watched = import_base14.hex.encode(swap.lockupPkScript);
   if (funded !== watched) {
     throw new Error(
@@ -4649,8 +4696,8 @@ function rfqSwapOriginOf(record) {
   };
 }
 function lockupScript(params, lockupAddress) {
-  const script = import_sdk20.VHTLCV2ContractHandler.createScript(params);
-  const funded = import_sdk20.ArkAddress.decode(lockupAddress).pkScript;
+  const script = import_sdk21.VHTLCV2ContractHandler.createScript(params);
+  const funded = import_sdk21.ArkAddress.decode(lockupAddress).pkScript;
   if (import_base14.hex.encode(funded) !== import_base14.hex.encode(script.pkScript)) {
     throw new Error(
       `rfq swap covenant params derive ${import_base14.hex.encode(script.pkScript)}, but the record's lockup address holds ${import_base14.hex.encode(funded)} \u2014 these params are not this swap's`
@@ -4695,7 +4742,7 @@ init_store();
 
 // src/swapManager.ts
 var import_base15 = require("@scure/base");
-var import_sdk21 = require("@arkade-os/sdk");
+var import_sdk22 = require("@arkade-os/sdk");
 init_onchainHtlc();
 init_lockupContract();
 init_coverage();
@@ -5195,7 +5242,7 @@ var RfqSwapManager = class {
         });
         return;
       }
-      if (!(0, import_sdk21.isContractVtxoEvent)(event)) return;
+      if (!(0, import_sdk22.isContractVtxoEvent)(event)) return;
       const swap = this.byLockupScript.get(event.contractScript);
       if (!swap) return;
       void this.pollSwap(swap).catch(() => {
@@ -5384,7 +5431,10 @@ var RfqSwapManager = class {
       return;
     }
     if (swap.kind === "lightning_receive") {
-      return fate.fate === "exited" ? this.blockExitedLockup(swap, fate) : this.driveReceiveClaim(swap);
+      if (fate.fate === "exited") return this.blockExitedLockup(swap, fate);
+      if (fate.fate === "open") return this.driveReceiveClaim(swap);
+      if (this.config.now() >= swap.refundLocktime) return this.driveReceiveClaim(swap);
+      return;
     }
     if (swap.kind === "onchain_send" && swap.state !== "claimed") {
       if (await this.driveOnchain(swap) === "handled") return;
@@ -5439,7 +5489,7 @@ var RfqSwapManager = class {
     if (now < swap.refundLocktime) {
       let vtxos;
       try {
-        vtxos = await findLockupVtxos(this.deps.indexer, swap.lockupPkScript);
+        vtxos = await findLockupVtxos(this.deps.contracts, swap.lockupPkScript);
       } catch (error) {
         this.emitFailed(swap, error);
         return;
@@ -5843,7 +5893,7 @@ var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
 
 // src/watch.ts
 var import_base16 = require("@scure/base");
-var import_sdk22 = require("@arkade-os/sdk");
+var import_sdk23 = require("@arkade-os/sdk");
 init_coverage();
 init_offer();
 init_store();
@@ -5878,7 +5928,7 @@ async function watchOfferSwaps({
     wallet.getAddress(),
     wallet.getArkadeReader()
   ]);
-  const operatorPubkey = import_sdk22.ArkAddress.decode(address).serverPubKey;
+  const operatorPubkey = import_sdk23.ArkAddress.decode(address).serverPubKey;
   let queue = Promise.resolve();
   const enqueue = (task) => {
     queue = queue.then(task).catch(() => {
@@ -5893,7 +5943,7 @@ async function watchOfferSwaps({
       return classifyDepositSpend(
         decodeOffer(import_base16.hex.decode(swap.offerHex)),
         operatorPubkey,
-        txs.map((psbt) => import_sdk22.Transaction.fromPSBT(import_base16.base64.decode(psbt))),
+        txs.map((psbt) => import_sdk23.Transaction.fromPSBT(import_base16.base64.decode(psbt))),
         { txid: vtxo.txid, vout: vtxo.vout }
       );
     } catch {
@@ -5921,7 +5971,7 @@ async function watchOfferSwaps({
     }
   };
   const unsubscribe = manager.onContractEvent((event) => {
-    if (!(0, import_sdk22.isContractVtxoEvent)(event) || event.type !== "vtxo_spent") return;
+    if (!(0, import_sdk23.isContractVtxoEvent)(event) || event.type !== "vtxo_spent") return;
     enqueue(() => handleSpend(event));
   });
   return {
@@ -6104,7 +6154,7 @@ var createSwapDrive = (config) => {
       const secret = rfqClaimSecretOf(record);
       if (!secret) throw new Error(`rfq swap ${swap.rfqId} carries no claim secret`);
       const preimage = await preimageForSwapRecord(wallet, secret);
-      const signer = await (0, import_sdk23.contractSigner)(wallet, await (0, import_sdk23.identityDescriptor)(wallet.identity));
+      const signer = await (0, import_sdk24.contractSigner)(wallet, await (0, import_sdk24.identityDescriptor)(wallet.identity));
       const claimKey = record.profile.claimKey;
       if (typeof claimKey === "string") {
         const held = import_base17.hex.encode(await signer.xOnlyPublicKey());
@@ -6162,10 +6212,10 @@ var createSwapDrive = (config) => {
     return track(
       pushClaim(operator, {
         contract: script,
-        receiver: await (0, import_sdk23.contractSigner)(wallet, secret.signingDescriptor),
+        receiver: await (0, import_sdk24.contractSigner)(wallet, secret.signingDescriptor),
         preimage: await preimageForSwapRecord(wallet, secret),
         vtxos,
-        destinationPkScript: import_sdk23.ArkAddress.decode(payoutAddress).pkScript,
+        destinationPkScript: import_sdk24.ArkAddress.decode(payoutAddress).pkScript,
         // Passed straight through, both of them: the manager's own value
         // check decides WHEN to act, `pushClaim`'s decides whether `P` is
         // published, and it is the one with nothing between it and the
@@ -6198,7 +6248,7 @@ var createSwapDrive = (config) => {
     if (mode === "readonly") return;
     const push = arkadeRefunder({
       operator,
-      indexer,
+      contracts: lockupSource,
       wallet,
       repository: corridorStore()
     });
@@ -6224,16 +6274,13 @@ var createSwapDrive = (config) => {
   };
   let offerSource;
   const offers = () => offerSource ??= offerRecordSource(storage(), remember, now);
-  const sweepOfferDeposits = async (offer) => {
-    const funded = offer.filter(
-      (record) => record.fundingTxid !== void 0 && !RETIRABLE.includes(record.status)
-    );
-    if (funded.length === 0) return;
+  const restoreOfferDeposits = async (reopen) => {
     const store = storage();
-    const [history, scanned, address] = await Promise.all([
+    const [history, scanned, address, network] = await Promise.all([
       wallet.getTransactionHistory(),
       store.getScannedTxids(),
-      wallet.getAddress()
+      wallet.getAddress(),
+      config.network()
     ]);
     const txs = history.map((tx) => ({
       // `TxType` is `"SENT"`/`"RECEIVED"`; the scan filters on `"sent"`.
@@ -6244,30 +6291,61 @@ var createSwapDrive = (config) => {
       // The scan reads unix SECONDS; a wallet transaction carries ms.
       ...tx.createdAt ? { createdAt: Math.floor(tx.createdAt / 1e3) } : {}
     }));
+    const { hrp, serverPubKey: operatorPubkey } = import_sdk24.ArkAddress.decode(address);
+    const cursor = reopen === void 0 ? scanned : new Set([...scanned].filter((txid) => txid !== reopen));
     const { restored, scannedTxids } = await restoreAssetSwaps(indexer, txs, /* @__PURE__ */ new Set(), {
-      operatorPubkey: import_sdk23.ArkAddress.decode(address).serverPubKey,
-      scanned
+      operatorPubkey,
+      scanned: cursor,
+      hrp
     });
-    const byDeposit = new Map(restored.map((s) => [`${s.swapPkScript}:${s.fundingTxid}`, s]));
-    const stillLive = /* @__PURE__ */ new Set();
-    for (const record of funded) {
-      const found = byDeposit.get(`${record.swapPkScript}:${record.fundingTxid}`);
-      const status = found?.status ?? record.status;
-      if (status !== record.status) {
-        const updated = withOfferStatus(record, status, now());
-        await store.saveSwapRecord(updated);
-        remember(updated);
+    const { offer } = splitRecords(await store.getAllSwapRecords());
+    const current = new Map(offer.map((record) => [record.id, record]));
+    const byDeposit = new Map(
+      offer.filter((record) => record.fundingTxid !== void 0).map((record) => [`${record.swapPkScript}:${record.fundingTxid}`, record])
+    );
+    const unstamped = /* @__PURE__ */ new Map();
+    for (const record of offer) {
+      if (record.fundingTxid !== void 0 || !OFFER_LIVE(record.status)) continue;
+      unstamped.set(record.swapPkScript, [
+        ...unstamped.get(record.swapPkScript) ?? [],
+        record
+      ]);
+    }
+    const write = async (record) => {
+      await store.saveSwapRecord(record);
+      current.set(record.id, record);
+      remember(record);
+    };
+    for (const found of restored) {
+      const known = byDeposit.get(`${found.swapPkScript}:${found.fundingTxid}`);
+      if (known !== void 0) {
+        if (fateMoved(known, found)) await write(withDepositFate(known, found, now()));
+        continue;
+      }
+      const orphan = unstamped.get(found.swapPkScript)?.shift();
+      if (orphan !== void 0) {
+        await write(
+          withDepositFate({ ...orphan, fundingTxid: found.fundingTxid }, found, now())
+        );
+        continue;
       }
-      if (OFFER_LIVE(status) && record.fundingTxid) stillLive.add(record.fundingTxid);
+      await write(restoredOfferRecord(found, network, now()));
+    }
+    const stillLive = /* @__PURE__ */ new Set();
+    for (const record of current.values()) {
+      if (OFFER_LIVE(record.status) && record.fundingTxid) stillLive.add(record.fundingTxid);
     }
     await store.markTxidsScanned(scannedTxids.filter((txid) => !stillLive.has(txid)));
     const registry = managerDeps.contracts;
     if (registry) {
-      const { offer: current } = splitRecords(await store.getAllSwapRecords());
-      await retireSettledOfferContracts(registry, current.map(offerFactsOf));
+      await retireSettledOfferContracts(registry, [...current.values()].map(offerFactsOf));
     }
+    return [...current.values()];
   };
   const contractsOf = async () => managerDeps.contracts ??= await wallet.getContractManager();
+  const lockupSource = {
+    getContractsWithVtxos: async (filter) => (await contractsOf()).getContractsWithVtxos(filter)
+  };
   const registerCorridorSwap = async (record) => {
     if (mode === "readonly") return;
     if (!await drivable(record)) {
@@ -6338,13 +6416,14 @@ var createSwapDrive = (config) => {
         console.warn("[swap] the corridor restore could not drive", error);
       }
     }
+    let offers2 = offer;
     try {
-      await sweepOfferDeposits(offer);
+      offers2 = await restoreOfferDeposits();
     } catch (error) {
-      console.warn("[swap] the offer deposit sweep did not complete", error);
+      console.warn("[swap] the offer deposit restore did not complete", error);
     }
     emitAll();
-    if (mode === "auto" && await hasLiveWork(offer)) {
+    if (mode === "auto" && await hasLiveWork(offers2)) {
       try {
         await arm();
       } catch (error) {
@@ -6372,7 +6451,7 @@ var createSwapDrive = (config) => {
     }
     return probe.call(wallet);
   };
-  const recoverableAt = async (script) => (await findLockupVtxos(indexer, script)).filter((vtxo) => vtxo.recoverable);
+  const recoverableAt = async (script) => (await findLockupVtxos(lockupSource, script)).filter((vtxo) => vtxo.recoverable);
   const recover = async (id) => {
     if (disposed) throw new ClientDisposed("recover");
     if (mode === "readonly") {
@@ -6422,7 +6501,7 @@ var createSwapDrive = (config) => {
       );
     }
     const txid = await track((await recoverer()).recoverVtxos());
-    await sweepOfferDeposits([records.get(id)]);
+    await restoreOfferDeposits(record.fundingTxid);
     const after = records.get(id);
     const recovered = after?.family === "offer" && after.status !== "recoverable";
     return { recovered, txid, swap: swapView(id) };
@@ -6595,16 +6674,16 @@ var assembleRoute = (give, take) => {
   }
   return { give, take };
 };
-var endpoint = (corridor, asset5, instrument) => ({
+var endpoint = (corridor, asset6, instrument) => ({
   corridor,
-  asset: asset5,
+  asset: asset6,
   ...instrument === void 0 ? {} : { instrument }
 });
-var legFor = (asset5, expected) => {
-  const leg = toDiscoveryLeg(asset5);
+var legFor = (asset6, expected) => {
+  const leg = toDiscoveryLeg(asset6);
   if (expected !== void 0 && leg.corridor !== expected) {
     throw new UnsupportedRoute(
-      `${asset5} settles on ${leg.corridor}, and this leg is ${expected}`,
+      `${asset6} settles on ${leg.corridor}, and this leg is ${expected}`,
       { give: leg.corridor, take: expected }
     );
   }
@@ -6953,17 +7032,17 @@ var verifyPlanLegs = (plan, legs, give) => {
 
 // src/client/quoteRfq.ts
 var import_base18 = require("@scure/base");
-var import_sdk26 = require("@arkade-os/sdk");
+var import_sdk27 = require("@arkade-os/sdk");
 init_claimPacket();
 init_onchainHtlc();
 init_onchainHtlc();
 
 // src/payment/onchainSwap.ts
-var import_sdk25 = require("@arkade-os/sdk");
+var import_sdk26 = require("@arkade-os/sdk");
 init_onchainHtlc();
 
 // src/payment/swapRail.ts
-var import_sdk24 = require("@arkade-os/sdk");
+var import_sdk25 = require("@arkade-os/sdk");
 
 // src/client/sats.ts
 var satsOf = (value, field) => {
@@ -7015,14 +7094,14 @@ var parseRfqQuote = (quote) => ({
 
 // src/client/quoteRfq.ts
 var covenantInputs = (input) => {
-  const network = (0, import_sdk26.networkFromArkadeInfo)(input.info);
+  const network = (0, import_sdk27.networkFromArkadeInfo)(input.info);
   const arkade2 = input.corridors.get("arkade").deps;
   return {
-    operatorPubkey: (0, import_sdk26.toXOnly)(import_base18.hex.decode(input.info.signerPubkey), "ark signer key"),
+    operatorPubkey: (0, import_sdk27.toXOnly)(import_base18.hex.decode(input.info.signerPubkey), "ark signer key"),
     // The per-network pin the arkade module already resolved, never a key
     // the operator reports about itself: this one ends up in a covenant leaf
     // that decides who can move the funds.
-    emulatorPubkey: (0, import_sdk26.toXOnly)(import_base18.hex.decode(arkade2.emulatorPubkey), "emulator signer key"),
+    emulatorPubkey: (0, import_sdk27.toXOnly)(import_base18.hex.decode(arkade2.emulatorPubkey), "emulator signer key"),
     claimDelay: unilateralClaimDelay(Number(input.info.unilateralExitDelay)),
     hrp: network.hrp
   };
@@ -7066,7 +7145,7 @@ var quoteLightningSend = async (input) => {
   }
   const pair = rfqPairFor(input.legs.give, input.legs.take);
   const rfqId = newRfqId();
-  const secrets = await (0, import_sdk26.provisionRefundKey)(input.wallet);
+  const secrets = await (0, import_sdk27.provisionRefundKey)(input.wallet);
   const wire = await input.transport.requestQuote(
     lightningSendRequest({
       rfqId,
@@ -7139,7 +7218,7 @@ var quoteLightningReceive = async (input) => {
   const pinned = pinnedFor(input);
   const pair = rfqPairFor(input.legs.give, input.legs.take);
   const rfqId = newRfqId();
-  const secrets = await (0, import_sdk26.provisionClaimSecret)(input.wallet);
+  const secrets = await (0, import_sdk27.provisionClaimSecret)(input.wallet);
   const paymentHash = import_base18.hex.encode(secrets.paymentHash);
   const payoutAddress = await input.wallet.getAddress();
   const lightning = input.corridors.get("lightning").deps;
@@ -7262,8 +7341,8 @@ var quoteOnchainSend = async (input) => {
     claimVsize: onchain.claimVsize
   }) : void 0;
   const quoted = claimFee === void 0 ? pinned : { on: pinned.on, value: pinned.value + claimFee, source: pinned.source };
-  const secrets = await (0, import_sdk26.provisionClaimSecret)(input.wallet);
-  const payoutKey = await (0, import_sdk26.provisionRefundKey)(input.wallet);
+  const secrets = await (0, import_sdk27.provisionClaimSecret)(input.wallet);
+  const payoutKey = await (0, import_sdk27.provisionRefundKey)(input.wallet);
   const paymentHash = import_base18.hex.encode(secrets.paymentHash);
   const wire = await input.transport.requestQuote(
     withCanonicalAmount(
@@ -7374,7 +7453,7 @@ var quoteOnchainSend = async (input) => {
 };
 
 // src/client/verbs.ts
-var import_sdk27 = require("@arkade-os/sdk");
+var import_sdk28 = require("@arkade-os/sdk");
 var enforceFeeCeiling = (quote, call, policy) => {
   let ceiling;
   for (const [source, limit] of [
@@ -7399,9 +7478,9 @@ var settle = async (deps, input, maxFee) => {
   return deps.accept(quote);
 };
 var pay = async (deps, destination, options = {}) => {
-  const arkade2 = (0, import_sdk27.arkTarget)(destination);
+  const arkade2 = (0, import_sdk28.arkTarget)(destination);
   if (arkade2 !== void 0) {
-    const amount = (0, import_sdk27.resolveSendAmount)(
+    const amount = (0, import_sdk28.resolveSendAmount)(
       "ark",
       destination,
       options.amount === void 0 ? void 0 : satsOf(options.amount, "amount")
@@ -7484,6 +7563,7 @@ var createSwapClient = (config) => {
     operator,
     ...config.repository === void 0 ? {} : { repository: config.repository },
     corridors: async () => (await resolved()).corridors,
+    network: async () => (await resolved()).base.networkName,
     ...config.policy?.drive === void 0 ? {} : { mode: config.policy.drive },
     indexer
   });
@@ -7721,7 +7801,7 @@ var createSwapClient = (config) => {
 var import_base20 = require("@scure/base");
 var import_legacy4 = require("@noble/hashes/legacy.js");
 var import_sha26 = require("@noble/hashes/sha2.js");
-var import_sdk28 = require("@arkade-os/sdk");
+var import_sdk29 = require("@arkade-os/sdk");
 init_claimPacket();
 var CovclaimdRevealError = class extends Error {
   name = "CovclaimdRevealError";
@@ -7826,7 +7906,7 @@ function revealFieldsFromScript(script) {
 }
 async function revealClaimPacket(client, input) {
   const fields = revealFieldsFromScript(input.script);
-  if (import_base20.hex.encode(import_sdk28.ArkAddress.decode(input.address).pkScript) !== import_base20.hex.encode(input.script.pkScript)) {
+  if (import_base20.hex.encode(import_sdk29.ArkAddress.decode(input.address).pkScript) !== import_base20.hex.encode(input.script.pkScript)) {
     throw new Error("address does not belong to this covenant");
   }
   if (import_base20.hex.encode((0, import_legacy4.ripemd160)((0, import_sha26.sha256)(input.preimage))) !== import_base20.hex.encode(input.script.options.preimageHash)) {
@@ -7917,6 +7997,7 @@ async function revealClaimPacket(client, input) {
   esploraTip,
   exchange,
   familyOfSwapId,
+  fateMoved,
   feedFetch,
   formatAssetId,
   fromAtomicDecimal,
@@ -7964,6 +8045,7 @@ async function revealClaimPacket(client, input) {
   resolveCorridorBase,
   resolveCorridorDeps,
   resolveRoute,
+  restoredOfferRecord,
   revealClaimPacket,
   revealFieldsFromScript,
   rfqLeg,
@@ -7991,6 +8073,6 @@ async function revealClaimPacket(client, input) {
   verifyingDerivation,
   walletLockupIndexer,
   withCanonicalAmount,
-  withOfferStatus,
+  withDepositFate,
   withRfqState
 });