@arkade-os/swap 0.0.4 → 0.0.6

package/dist/index.cjs

@@ -53,6 +53,7 @@ __export(index_exports, {
   ONCHAIN_RECEIVE_PAIR: () => ONCHAIN_RECEIVE_PAIR,
   ONCHAIN_SECONDS_PER_BLOCK: () => ONCHAIN_SECONDS_PER_BLOCK,
   ONCHAIN_SEND_PAIR: () => ONCHAIN_SEND_PAIR,
+  PreimageNotRecoverableError: () => PreimageNotRecoverableError,
   QUOTE_OPTIONS: () => QUOTE_OPTIONS,
   REFUND_MTP_LAG_SECONDS: () => REFUND_MTP_LAG_SECONDS,
   RFQ_RESOLVED_STATES: () => RFQ_RESOLVED_STATES,
@@ -60,6 +61,7 @@ __export(index_exports, {
   RFQ_TERMINAL_STATES: () => RFQ_TERMINAL_STATES,
   RefundNotLocallyPossibleError: () => RefundNotLocallyPossibleError,
   RfqSwapManager: () => RfqSwapManager,
+  SOLO_REFUND_HEADROOM_SECONDS: () => SOLO_REFUND_HEADROOM_SECONDS,
   SWAP_LOCKUP_CONTRACT_KIND: () => SWAP_LOCKUP_CONTRACT_KIND,
   SWAP_LOCKUP_CONTRACT_LABEL: () => SWAP_LOCKUP_CONTRACT_LABEL,
   SWAP_LOCKUP_CONTRACT_TYPE: () => SWAP_LOCKUP_CONTRACT_TYPE,
@@ -107,6 +109,7 @@ __export(index_exports, {
   onchainReceiveRequest: () => onchainReceiveRequest,
   onchainSendRequest: () => onchainSendRequest,
   paymentHashOf: () => paymentHashOf,
+  preimageForSwapRecord: () => preimageForSwapRecord,
   pushClaim: () => pushClaim,
   pushRefundWithoutReceiver: () => pushRefundWithoutReceiver,
   readLockupFate: () => readLockupFate,
@@ -125,6 +128,7 @@ __export(index_exports, {
   senderIdentityForSwapRecord: () => senderIdentityForSwapRecord,
   spendTxidsOf: () => spendTxidsOf,
   spendUpdate: () => spendUpdate,
+  swapActivityResolver: () => swapActivityResolver,
   swapPrograms: () => swapPrograms,
   swapSecretsToRecord: () => swapSecretsToRecord,
   unilateralClaimDelay: () => unilateralClaimDelay,
@@ -142,7 +146,7 @@ module.exports = __toCommonJS(index_exports);
 // src/offer.ts
 var import_base2 = require("@scure/base");
 var import_utils = require("@scure/btc-signer/utils.js");
-var import_sdk = require("@arkade-os/sdk");
+var import_sdk2 = require("@arkade-os/sdk");
 
 // src/swap-want-asset.program.json
 var swap_want_asset_program_default = {
@@ -273,6 +277,8 @@ async function retireSettledOfferContracts(manager, swaps) {
 
 // src/store.ts
 var import_base = require("@scure/base");
+var import_sha2 = require("@noble/hashes/sha2.js");
+var import_sdk = require("@arkade-os/sdk");
 var BTC_ASSET_ID = "btc";
 var byNewest = (a, b) => b.createdAt - a.createdAt;
 var getAssetSwapsOrThrow = async (repository) => {
@@ -327,13 +333,66 @@ var updateAssetSwapBestEffort = async (repository, id, changes) => {
 };
 var swapSecretsToRecord = (secrets) => ({
   signingDescriptor: secrets.descriptor,
-  ..."mustPersistPreimage" in secrets && secrets.mustPersistPreimage ? { preimageHex: import_base.hex.encode(secrets.preimage) } : {}
+  ..."mustPersistPreimage" in secrets && secrets.mustPersistPreimage ? { preimageHex: import_base.hex.encode(secrets.preimage) } : {},
+  ..."preimageSalt" in secrets && secrets.preimageSalt ? { preimageSaltHex: import_base.hex.encode(secrets.preimageSalt) } : {}
 });
+var decodeHex32 = (value, field) => {
+  const bytes = import_base.hex.decode(value);
+  if (bytes.length !== 32) {
+    throw new Error(`${field} must be 32 bytes, got ${bytes.length}`);
+  }
+  return bytes;
+};
+var PreimageNotRecoverableError = class extends Error {
+  constructor(reason, message, options) {
+    super(message, options);
+    this.reason = reason;
+  }
+  reason;
+  name = "PreimageNotRecoverableError";
+};
+var preimageForSwapRecord = async (wallet, record) => {
+  if (!record.signingDescriptor) {
+    throw new PreimageNotRecoverableError(
+      "no-secrets",
+      "this swap record carries no signing descriptor"
+    );
+  }
+  let stored;
+  let salt;
+  try {
+    stored = record.preimageHex ? decodeHex32(record.preimageHex, "preimageHex") : void 0;
+    salt = record.preimageSaltHex ? decodeHex32(record.preimageSaltHex, "preimageSaltHex") : void 0;
+  } catch (cause) {
+    throw new PreimageNotRecoverableError(
+      "malformed-record",
+      `this swap record's secrets projection is unreadable: ${String(cause)}`,
+      { cause }
+    );
+  }
+  let preimage;
+  try {
+    preimage = await (0, import_sdk.contractPreimage)(wallet, record.signingDescriptor, { stored, salt });
+  } catch (cause) {
+    throw new PreimageNotRecoverableError(
+      "not-derivable",
+      `this wallet cannot produce the preimage for ${record.signingDescriptor}`,
+      { cause }
+    );
+  }
+  if (record.paymentHash && import_base.hex.encode((0, import_sha2.sha256)(preimage)) !== record.paymentHash.toLowerCase()) {
+    throw new PreimageNotRecoverableError(
+      "hash-mismatch",
+      "the derived preimage does not match this swap's payment hash: wrong wallet, or a tampered salt"
+    );
+  }
+  return preimage;
+};
 
 // src/offer.ts
 var swapPrograms = {
-  wantAsset: import_sdk.arkade.parseArtifact(swap_want_asset_program_default),
-  wantBtc: import_sdk.arkade.parseArtifact(swap_want_btc_program_default)
+  wantAsset: import_sdk2.arkade.parseArtifact(swap_want_asset_program_default),
+  wantBtc: import_sdk2.arkade.parseArtifact(swap_want_btc_program_default)
 };
 function swapProgramBinding(offer, serverPubkey) {
   if (offer.makerPkScript.length !== FIELDS.makerPkScript.width) {
@@ -361,7 +420,7 @@ function swapProgramBinding(offer, serverPubkey) {
 }
 function offerVtxoScript(offer, serverPubkey) {
   const { program, args, keys } = swapProgramBinding(offer, serverPubkey);
-  return new import_sdk.arkade.ArkadeProgramScript(program, args, keys);
+  return new import_sdk2.arkade.ArkadeProgramScript(program, args, keys);
 }
 var OFFER_PACKET_TYPE = 3;
 var FIELDS = {
@@ -443,8 +502,8 @@ function decodeOffer(data) {
   return {
     swapPkScript: need("swapPkScript"),
     wantAmount: new DataView(amount.buffer, amount.byteOffset).getBigUint64(0, false),
-    ...fields.wantAsset && { wantAsset: import_sdk.asset.AssetId.fromBytes(fields.wantAsset) },
-    ...fields.offerAsset && { offerAsset: import_sdk.asset.AssetId.fromBytes(fields.offerAsset) },
+    ...fields.wantAsset && { wantAsset: import_sdk2.asset.AssetId.fromBytes(fields.wantAsset) },
+    ...fields.offerAsset && { offerAsset: import_sdk2.asset.AssetId.fromBytes(fields.offerAsset) },
     makerPkScript: need("makerPkScript"),
     makerPublicKey: need("makerPublicKey"),
     emulatorPubkey: need("emulatorPubkey")
@@ -455,17 +514,17 @@ 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 import_sdk.arkade.Arkade.connect({
-    arkade: new import_sdk.RestArkProvider(arkServerUrl),
-    indexer: new import_sdk.RestIndexerProvider(arkServerUrl),
+  const client = await import_sdk2.arkade.Arkade.connect({
+    arkade: new import_sdk2.RestArkProvider(arkServerUrl),
+    indexer: new import_sdk2.RestIndexerProvider(arkServerUrl),
     identity: wallet.identity,
     // without this the row's `address` would be derived against the SDK's
     // default network while its script is right — a row that disagrees with
     // the address the user is about to fund
-    network: (0, import_sdk.getNetwork)(network),
+    network: (0, import_sdk2.getNetwork)(network),
     contractManager
   });
-  const contract = new import_sdk.arkade.ArkadeContract(client, program, args, keys);
+  const contract = new import_sdk2.arkade.ArkadeContract(client, program, args, keys);
   if (import_base2.hex.encode(contract.pkScript) !== import_base2.hex.encode(expectedPkScript)) {
     throw new Error("derived covenant does not match the offer's swapPkScript");
   }
@@ -480,20 +539,20 @@ async function createOffer(wallet, arkServerUrl, params) {
     throw new Error("set exactly one of wantAsset (BTC->asset) or offerAsset (asset->BTC)");
   }
   const [info, makerAddress, makerPublicKey] = await Promise.all([
-    new import_sdk.RestArkProvider(arkServerUrl).getInfo(),
+    new import_sdk2.RestArkProvider(arkServerUrl).getInfo(),
     wallet.getAddress(),
     wallet.identity.xOnlyPublicKey()
   ]);
-  const serverPubKey = import_base2.hex.decode((0, import_sdk.toXOnlySignerHex)(info.signerPubkey));
-  const network = (0, import_sdk.getNetwork)(info.network);
+  const serverPubKey = import_base2.hex.decode((0, import_sdk2.toXOnlySignerHex)(info.signerPubkey));
+  const network = (0, import_sdk2.getNetwork)(info.network);
   const emuKey = import_base2.hex.decode(
-    (0, import_sdk.toXOnlySignerHex)((0, import_sdk.resolveEmulatorPubkey)(network, params.emulatorPubkey))
+    (0, import_sdk2.toXOnlySignerHex)((0, import_sdk2.resolveEmulatorPubkey)(network, params.emulatorPubkey))
   );
   const binding = {
     wantAmount: params.wantAmount,
     wantAsset: params.wantAsset,
     offerAsset: params.offerAsset,
-    makerPkScript: import_sdk.ArkAddress.decode(makerAddress).pkScript,
+    makerPkScript: import_sdk2.ArkAddress.decode(makerAddress).pkScript,
     makerPublicKey,
     emulatorPubkey: emuKey
   };
@@ -521,9 +580,9 @@ async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
   const { repository, fundingTxid, swapAddress } = opts;
   const offer = decodeOffer(import_base2.hex.decode(offerHex));
   const contractManager = await wallet.getContractManager();
-  const client = await import_sdk.arkade.Arkade.connect({
-    arkade: new import_sdk.RestArkProvider(arkServerUrl),
-    indexer: new import_sdk.RestIndexerProvider(arkServerUrl),
+  const client = await import_sdk2.arkade.Arkade.connect({
+    arkade: new import_sdk2.RestArkProvider(arkServerUrl),
+    indexer: new import_sdk2.RestIndexerProvider(arkServerUrl),
     identity: wallet.identity,
     // registered offers resolve their VTXOs from the contract repository
     // instead of a direct indexer query; the indexer above stays as the
@@ -533,15 +592,15 @@ async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
     // script and the payout script comes from wallet.getAddress(), so the
     // client's network (which only shapes address derivation) is unused here
   });
-  const serverKey = swapAddress ? import_sdk.ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
+  const serverKey = swapAddress ? import_sdk2.ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
   const { program, args, keys } = swapProgramBinding(offer, serverKey);
-  const rebuilt = new import_sdk.arkade.ArkadeProgramScript(program, args, keys);
+  const rebuilt = new import_sdk2.arkade.ArkadeProgramScript(program, args, keys);
   if (import_base2.hex.encode(rebuilt.pkScript) !== import_base2.hex.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 import_sdk.arkade.ArkadeContract(client, program, args, keys);
+  const contract = new import_sdk2.arkade.ArkadeContract(client, program, args, keys);
   const [vtxos, makerAddress] = await Promise.all([contract.getUtxos(), wallet.getAddress()]);
   if (!fundingTxid && vtxos.length > 1) {
     throw new Error(
@@ -550,7 +609,7 @@ async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
   }
   const vtxo = fundingTxid ? vtxos.find((v) => v.txid === fundingTxid) : vtxos[0];
   if (!vtxo) throw new Error("no spendable VTXO at the swap address");
-  const makerPkScript = import_sdk.ArkAddress.decode(makerAddress).pkScript;
+  const makerPkScript = import_sdk2.ArkAddress.decode(makerAddress).pkScript;
   const cancel = contract.functions.cancel().from({ txid: vtxo.txid, vout: vtxo.vout, value: vtxo.value }).to(makerPkScript, BigInt(vtxo.value));
   for (const a of vtxo.assets ?? []) {
     cancel.withAsset({
@@ -577,7 +636,7 @@ async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
 
 // src/markets.ts
 var import_solver_discovery = require("@arkade-os/solver-discovery");
-var import_sdk2 = require("@arkade-os/sdk");
+var import_sdk3 = require("@arkade-os/sdk");
 var QUOTE_OPTIONS = { safetyBps: 0 };
 var makeCachedFeedFetch = (ttlMs = 3e4, fetchImpl = fetch) => {
   const cache = /* @__PURE__ */ new Map();
@@ -694,7 +753,7 @@ var validatePlan = (plan, giveBalance, dust) => {
   const receiveIsBtc = plan.receive.asset.id === BTC_ASSET_ID;
   if (depositIsBtc || receiveIsBtc) {
     const btcSide = depositIsBtc ? plan.deposit.atomic : plan.receive.atomic;
-    if ((0, import_sdk2.isSubdust)(btcSide, dust)) return "below-dust";
+    if ((0, import_sdk3.isSubdust)(btcSide, dust)) return "below-dust";
   }
   return void 0;
 };
@@ -702,7 +761,7 @@ var validatePlan = (plan, giveBalance, dust) => {
 // src/repository.ts
 var marketsCacheKey = (network, registry) => `arkade-intents-markets-${network}-${registry}`;
 var InMemoryAssetSwapRepository = class {
-  version = 1;
+  version = 2;
   swaps = /* @__PURE__ */ new Map();
   scanned = /* @__PURE__ */ new Set();
   markets = /* @__PURE__ */ new Map();
@@ -734,7 +793,7 @@ var InMemoryAssetSwapRepository = class {
 };
 
 // src/indexedDbRepository.ts
-var import_sdk3 = require("@arkade-os/sdk");
+var import_sdk4 = require("@arkade-os/sdk");
 var DEFAULT_DB_NAME = "arkade-intents";
 var DB_VERSION = 1;
 var STORE_SWAPS = "swaps";
@@ -764,7 +823,7 @@ var IndexedDbAssetSwapRepository = class {
     this.dbName = dbName;
   }
   dbName;
-  version = 1;
+  version = 2;
   // the promise, not the resolved database: openDatabase bumps a refcount on
   // every call including cache hits, while dispose closes once, so two
   // concurrent first calls would strand the refcount above zero and leak the
@@ -772,7 +831,7 @@ var IndexedDbAssetSwapRepository = class {
   // can be retried rather than cached forever.
   dbPromise = null;
   ensureDb() {
-    return this.dbPromise ??= (0, import_sdk3.openDatabase)(this.dbName, DB_VERSION, initDatabase).catch(
+    return this.dbPromise ??= (0, import_sdk4.openDatabase)(this.dbName, DB_VERSION, initDatabase).catch(
       (err) => {
         this.dbPromise = null;
         throw err;
@@ -829,14 +888,14 @@ var IndexedDbAssetSwapRepository = class {
   }
   async [Symbol.asyncDispose]() {
     if (!this.dbPromise) return;
-    await (0, import_sdk3.closeDatabase)(this.dbName);
+    await (0, import_sdk4.closeDatabase)(this.dbName);
     this.dbPromise = null;
   }
 };
 
 // src/restore.ts
 var import_base3 = require("@scure/base");
-var import_sdk4 = require("@arkade-os/sdk");
+var import_sdk5 = require("@arkade-os/sdk");
 var TXS_PER_REQUEST = 50;
 async function fetchParsedTxs(indexer, txids) {
   const parsedByTxid = /* @__PURE__ */ new Map();
@@ -852,7 +911,7 @@ async function fetchParsedTxs(indexer, txids) {
     if (result.status !== "fulfilled") continue;
     for (const psbt of result.value) {
       try {
-        const parsed = import_sdk4.Transaction.fromPSBT(import_base3.base64.decode(psbt));
+        const parsed = import_sdk5.Transaction.fromPSBT(import_base3.base64.decode(psbt));
         parsedByTxid.set(parsed.id, parsed);
       } catch {
       }
@@ -880,7 +939,7 @@ function classifySpend(offer, serverPubkey, spendTx, deposit) {
     if (!input.txid || input.index !== deposit.vout) continue;
     if (import_base3.hex.encode(input.txid) !== deposit.txid) continue;
     for (const leaf of input.tapLeafScript ?? []) {
-      const spent = import_base3.hex.encode((0, import_sdk4.scriptFromTapLeafScript)(leaf));
+      const spent = import_base3.hex.encode((0, import_sdk5.scriptFromTapLeafScript)(leaf));
       if (leaves.cancel && spent === import_base3.hex.encode(leaves.cancel)) return "cancelled";
       if (leaves.fulfill && spent === import_base3.hex.encode(leaves.fulfill)) return "fulfilled";
     }
@@ -911,7 +970,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
     if (!fundingTx) continue;
     fetchedTxids.push(txid);
     try {
-      const packet = import_sdk4.Extension.fromTx(parsed).getPacketByType(OFFER_PACKET_TYPE);
+      const packet = import_sdk5.Extension.fromTx(parsed).getPacketByType(OFFER_PACKET_TYPE);
       if (!packet) continue;
       const payload = packet.serialize();
       found.push({
@@ -1002,7 +1061,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
 
 // src/watch.ts
 var import_base4 = require("@scure/base");
-var import_sdk5 = require("@arkade-os/sdk");
+var import_sdk6 = require("@arkade-os/sdk");
 var TERMINAL = ["fulfilled", "cancelled", "recoverable"];
 function spendUpdate(swap, spend) {
   if (TERMINAL.includes(swap.status)) return void 0;
@@ -1022,8 +1081,8 @@ async function watchOfferSwaps({
   onUpdate
 }) {
   const manager = await wallet.getContractManager();
-  const serverPubkey = import_sdk5.ArkAddress.decode(await wallet.getAddress()).serverPubKey;
-  const indexer = new import_sdk5.RestIndexerProvider(arkServerUrl);
+  const serverPubkey = import_sdk6.ArkAddress.decode(await wallet.getAddress()).serverPubKey;
+  const indexer = new import_sdk6.RestIndexerProvider(arkServerUrl);
   let queue = Promise.resolve();
   const enqueue = (task) => {
     queue = queue.then(task).catch(() => {
@@ -1038,7 +1097,7 @@ async function watchOfferSwaps({
       return classifyDepositSpend(
         decodeOffer(import_base4.hex.decode(swap.offerHex)),
         serverPubkey,
-        txs.map((psbt) => import_sdk5.Transaction.fromPSBT(import_base4.base64.decode(psbt))),
+        txs.map((psbt) => import_sdk6.Transaction.fromPSBT(import_base4.base64.decode(psbt))),
         { txid: vtxo.txid, vout: vtxo.vout }
       );
     } catch {
@@ -1082,11 +1141,11 @@ async function watchOfferSwaps({
 // src/rfq.ts
 var import_base8 = require("@scure/base");
 var import_legacy2 = require("@noble/hashes/legacy.js");
-var import_sdk7 = require("@arkade-os/sdk");
+var import_sdk8 = require("@arkade-os/sdk");
 
 // src/onchainHtlc.ts
 var import_base5 = require("@scure/base");
-var import_sha2 = require("@noble/hashes/sha2.js");
+var import_sha22 = require("@noble/hashes/sha2.js");
 var import_legacy = require("@noble/hashes/legacy.js");
 var btc = __toESM(require("@scure/btc-signer"), 1);
 var ONCHAIN_ORDER_MARGIN_SECONDS = 2 * 60 * 60;
@@ -1095,7 +1154,7 @@ var MAX_MIN_CONFIRMATIONS = 6;
 var ONCHAIN_SECONDS_PER_BLOCK = 600;
 var ONCHAIN_DUST_SATS = BigInt(330);
 var newPreimage = () => crypto.getRandomValues(new Uint8Array(32));
-var paymentHashOf = (preimage) => import_base5.hex.encode((0, import_sha2.sha256)(preimage));
+var paymentHashOf = (preimage) => import_base5.hex.encode((0, import_sha22.sha256)(preimage));
 var h160FromPaymentHash = (paymentHash) => (0, import_legacy.ripemd160)(import_base5.hex.decode(paymentHash));
 var L1_NETWORKS = {
   bitcoin: btc.NETWORK,
@@ -1236,7 +1295,7 @@ function extractPreimage(txHex, paymentHash) {
   }
   for (const stack of raw.witnesses ?? []) {
     for (const item of stack) {
-      if (item.length === 32 && import_base5.hex.encode((0, import_sha2.sha256)(item)) === paymentHash) return item;
+      if (item.length === 32 && import_base5.hex.encode((0, import_sha22.sha256)(item)) === paymentHash) return item;
     }
   }
   return null;
@@ -1291,13 +1350,13 @@ async function classifyOnchainHtlc(chain, input) {
 }
 
 // src/rfq.ts
-var import_sdk8 = require("@arkade-os/sdk");
+var import_sdk9 = require("@arkade-os/sdk");
 
 // src/claimPacket.ts
 var import_base6 = require("@scure/base");
 var import_secp256k1 = require("@noble/curves/secp256k1.js");
 var import_hkdf = require("@noble/hashes/hkdf.js");
-var import_sha22 = require("@noble/hashes/sha2.js");
+var import_sha23 = require("@noble/hashes/sha2.js");
 var HKDF_INFO = new TextEncoder().encode("covclaimd/preimage/v1");
 async function sealClaimPacket(input) {
   return sealWithEntropy(
@@ -1313,7 +1372,7 @@ async function sealWithEntropy(input, ephemeralKey, nonce) {
   }
   const ephemeralPub = import_secp256k1.secp256k1.getPublicKey(ephemeralKey, true);
   const sharedX = import_secp256k1.secp256k1.getSharedSecret(ephemeralKey, input.covclaimdPubkey, true).subarray(1);
-  const key = (0, import_hkdf.hkdf)(import_sha22.sha256, sharedX, ephemeralPub, HKDF_INFO, 32);
+  const key = (0, import_hkdf.hkdf)(import_sha23.sha256, sharedX, ephemeralPub, HKDF_INFO, 32);
   if (nonce.length !== 12) throw new Error("nonce must be 12 bytes");
   const aesKey = await crypto.subtle.importKey("raw", key, "AES-GCM", false, [
     "encrypt"
@@ -1338,7 +1397,7 @@ async function sealWithEntropy(input, ephemeralKey, nonce) {
 
 // src/lockupContract.ts
 var import_base7 = require("@scure/base");
-var import_sdk6 = require("@arkade-os/sdk");
+var import_sdk7 = require("@arkade-os/sdk");
 var SWAP_LOCKUP_CONTRACT_TYPE = "vhtlc-v2";
 var SWAP_LOCKUP_CONTRACT_LABEL = "Arkade RFQ swap lockup";
 var SWAP_LOCKUP_CONTRACT_KIND = "rfq-swap-lockup";
@@ -1360,7 +1419,7 @@ async function registerLockupContract(contracts, script, address) {
   try {
     await contracts.createContract({
       type: SWAP_LOCKUP_CONTRACT_TYPE,
-      params: import_sdk6.VHTLCV2ContractHandler.serializeParams(script.options),
+      params: import_sdk7.VHTLCV2ContractHandler.serializeParams(script.options),
       script: import_base7.hex.encode(script.pkScript),
       address,
       label: SWAP_LOCKUP_CONTRACT_LABEL,
@@ -1622,27 +1681,28 @@ var relayTransport = (relayUrl, options) => {
   };
 };
 var SEQUENCE_GRANULARITY_SECONDS = 512;
+var SOLO_REFUND_HEADROOM_SECONDS = 8 * SEQUENCE_GRANULARITY_SECONDS;
 var unilateralClaimDelay = (serverExitDelaySeconds) => {
   if (!Number.isFinite(serverExitDelaySeconds) || serverExitDelaySeconds < SEQUENCE_GRANULARITY_SECONDS) {
     throw new Error(
       `server exit delay must be at least ${SEQUENCE_GRANULARITY_SECONDS}s of seconds, got ${serverExitDelaySeconds}`
     );
   }
-  if (serverExitDelaySeconds > (65535 - 2) * SEQUENCE_GRANULARITY_SECONDS) {
+  if (serverExitDelaySeconds > 65535 * SEQUENCE_GRANULARITY_SECONDS - SOLO_REFUND_HEADROOM_SECONDS) {
     throw new Error(
-      `server exit delay ${serverExitDelaySeconds}s exceeds what BIP68 can encode once the two refund tiers are stacked above it`
+      `server exit delay ${serverExitDelaySeconds}s exceeds what BIP68 can encode once the solo refund's headroom is stacked above it`
     );
   }
   return Math.ceil(serverExitDelaySeconds / SEQUENCE_GRANULARITY_SECONDS) * SEQUENCE_GRANULARITY_SECONDS;
 };
-var unilateralRefundDelay = (claimDelay) => claimDelay + SEQUENCE_GRANULARITY_SECONDS;
-var unilateralRefundWithoutReceiverDelay = (claimDelay) => claimDelay + 2 * SEQUENCE_GRANULARITY_SECONDS;
+var unilateralRefundDelay = (claimDelay) => claimDelay;
+var unilateralRefundWithoutReceiverDelay = (claimDelay) => claimDelay + SOLO_REFUND_HEADROOM_SECONDS;
 function lightningSendVtxoScript(params) {
   const seconds = (value) => ({
     type: "seconds",
     value: BigInt(value)
   });
-  return new import_sdk7.VHTLC.ScriptV2({
+  return new import_sdk8.VHTLC.ScriptV2({
     sender: params.senderPubkey,
     receiver: params.solverPubkey,
     server: params.serverPubkey,
@@ -1665,10 +1725,10 @@ function lightningSendVtxoScript(params) {
 }
 async function requestLightningSend(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
-  const secrets = await (0, import_sdk8.provisionRefundKey)(wallet);
+  const secrets = await (0, import_sdk9.provisionRefundKey)(wallet);
   const senderPubkey = secrets.pubkey;
   const [info, refundAddress] = await Promise.all([
-    new import_sdk7.RestArkProvider(arkServerUrl).getInfo(),
+    new import_sdk8.RestArkProvider(arkServerUrl).getInfo(),
     wallet.getAddress()
   ]);
   const quote = await transport.requestQuote(
@@ -1692,7 +1752,7 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
     );
   }
   const serverPubkey = xOnly(import_base8.hex.decode(info.signerPubkey), "ark signer key");
-  const network = (0, import_sdk7.getNetwork)(info.network);
+  const network = (0, import_sdk8.getNetwork)(info.network);
   const script = lightningSendVtxoScript({
     solverPubkey: xOnly(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime: quote.refund_locktime,
@@ -1700,12 +1760,12 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
     paymentHash: params.invoice.paymentHash,
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
     emulatorPubkey: xOnly(
-      import_base8.hex.decode((0, import_sdk7.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
+      import_base8.hex.decode((0, import_sdk8.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
     senderPubkey,
     receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
-    refundPkScript: import_sdk7.ArkAddress.decode(refundAddress).pkScript
+    refundPkScript: import_sdk8.ArkAddress.decode(refundAddress).pkScript
   });
   const address = script.address(network.hrp, serverPubkey).encode();
   verifyLockupAddress(quote, address);
@@ -1800,7 +1860,7 @@ function deriveOnchainSend(input) {
     emulatorPubkey: input.emulatorPubkey,
     senderPubkey: input.senderPubkey,
     receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
-    refundPkScript: import_sdk7.ArkAddress.decode(input.refundAddress).pkScript
+    refundPkScript: import_sdk8.ArkAddress.decode(input.refundAddress).pkScript
   });
   const address = script.address(input.hrp, input.serverPubkey).encode();
   verifyLockupAddress(quote, address);
@@ -1826,7 +1886,7 @@ function deriveOnchainSend(input) {
 }
 async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
-  const secrets = await (0, import_sdk8.provisionClaimSecret)(wallet, { preimage: params.preimage });
+  const secrets = await (0, import_sdk9.provisionClaimSecret)(wallet, { preimage: params.preimage });
   if (secrets.mustPersistPreimage) {
     console.warn(
       "[swap] this swap's preimage cannot be re-derived from the seed and MUST be persisted with the record before funding"
@@ -1835,7 +1895,7 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
   const paymentHash = import_base8.hex.encode(secrets.paymentHash);
   const senderPubkey = secrets.pubkey;
   const [info, refundAddress] = await Promise.all([
-    new import_sdk7.RestArkProvider(arkServerUrl).getInfo(),
+    new import_sdk8.RestArkProvider(arkServerUrl).getInfo(),
     wallet.getAddress()
   ]);
   const quote = await transport.requestQuote(
@@ -1849,14 +1909,14 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
       amountSide: params.amountSide
     })
   );
-  const network = (0, import_sdk7.getNetwork)(info.network);
+  const network = (0, import_sdk8.getNetwork)(info.network);
   const derived = deriveOnchainSend({
     quote,
     paymentHash,
     payoutPubkey: params.payoutPubkey,
     serverPubkey: xOnly(import_base8.hex.decode(info.signerPubkey), "ark signer key"),
     emulatorPubkey: xOnly(
-      import_base8.hex.decode((0, import_sdk7.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
+      import_base8.hex.decode((0, import_sdk8.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
@@ -1964,7 +2024,7 @@ function receiveVtxoScript(params) {
     type: "seconds",
     value: BigInt(value)
   });
-  return new import_sdk7.VHTLC.ScriptV2({
+  return new import_sdk8.VHTLC.ScriptV2({
     sender: params.solverPubkey,
     receiver: params.payoutPubkey,
     server: params.serverPubkey,
@@ -2003,7 +2063,7 @@ function deriveLightningReceive(input) {
     emulatorPubkey: input.emulatorPubkey,
     solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
     payoutPubkey: input.payoutPubkey,
-    payoutPkScript: import_sdk7.ArkAddress.decode(input.payoutAddress).pkScript
+    payoutPkScript: import_sdk8.ArkAddress.decode(input.payoutAddress).pkScript
   });
   const address = script.address(input.hrp, input.serverPubkey).encode();
   verifyLockupAddress(quote, address);
@@ -2011,7 +2071,7 @@ function deriveLightningReceive(input) {
 }
 async function requestLightningReceive(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
-  const secrets = await (0, import_sdk8.provisionClaimSecret)(wallet);
+  const secrets = await (0, import_sdk9.provisionClaimSecret)(wallet);
   if (secrets.mustPersistPreimage) {
     console.warn(
       "[swap] this swap's preimage cannot be re-derived from the seed and MUST be persisted with the record before paying"
@@ -2021,7 +2081,7 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
   const paymentHash = import_base8.hex.encode(secrets.paymentHash);
   const payoutPubkey = secrets.pubkey;
   const [info, payoutAddress] = await Promise.all([
-    new import_sdk7.RestArkProvider(arkServerUrl).getInfo(),
+    new import_sdk8.RestArkProvider(arkServerUrl).getInfo(),
     wallet.getAddress()
   ]);
   const claimPacket = await sealClaimPacket({
@@ -2040,7 +2100,7 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
-  const network = (0, import_sdk7.getNetwork)(info.network);
+  const network = (0, import_sdk8.getNetwork)(info.network);
   const derived = deriveLightningReceive({
     quote,
     paymentHash,
@@ -2048,7 +2108,7 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
     payoutAddress,
     serverPubkey: xOnly(import_base8.hex.decode(info.signerPubkey), "ark signer key"),
     emulatorPubkey: xOnly(
-      import_base8.hex.decode((0, import_sdk7.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
+      import_base8.hex.decode((0, import_sdk8.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
@@ -2103,7 +2163,7 @@ function deriveOnchainReceive(input) {
     emulatorPubkey: input.emulatorPubkey,
     solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
     payoutPubkey: input.payoutPubkey,
-    payoutPkScript: import_sdk7.ArkAddress.decode(input.payoutAddress).pkScript
+    payoutPkScript: import_sdk8.ArkAddress.decode(input.payoutAddress).pkScript
   });
   const address = script.address(input.hrp, input.serverPubkey).encode();
   verifyLockupAddress(quote, address);
@@ -2129,7 +2189,7 @@ function deriveOnchainReceive(input) {
 }
 async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
-  const secrets = await (0, import_sdk8.provisionClaimSecret)(wallet);
+  const secrets = await (0, import_sdk9.provisionClaimSecret)(wallet);
   if (secrets.mustPersistPreimage) {
     console.warn(
       "[swap] this swap's preimage cannot be re-derived from the seed and MUST be persisted with the record before funding"
@@ -2139,7 +2199,7 @@ async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
   const paymentHash = import_base8.hex.encode(secrets.paymentHash);
   const payoutPubkey = secrets.pubkey;
   const [info, payoutAddress] = await Promise.all([
-    new import_sdk7.RestArkProvider(arkServerUrl).getInfo(),
+    new import_sdk8.RestArkProvider(arkServerUrl).getInfo(),
     wallet.getAddress()
   ]);
   const claimPacket = await sealClaimPacket({
@@ -2159,7 +2219,7 @@ async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
-  const network = (0, import_sdk7.getNetwork)(info.network);
+  const network = (0, import_sdk8.getNetwork)(info.network);
   const derived = deriveOnchainReceive({
     quote,
     paymentHash,
@@ -2168,7 +2228,7 @@ async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
     refundPubkey: params.refundPubkey,
     serverPubkey: xOnly(import_base8.hex.decode(info.signerPubkey), "ark signer key"),
     emulatorPubkey: xOnly(
-      import_base8.hex.decode((0, import_sdk7.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
+      import_base8.hex.decode((0, import_sdk8.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
@@ -2207,13 +2267,13 @@ async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
 // src/claim.ts
 var import_base10 = require("@scure/base");
 var import_legacy3 = require("@noble/hashes/legacy.js");
-var import_sha24 = require("@noble/hashes/sha2.js");
-var import_sdk10 = require("@arkade-os/sdk");
+var import_sha25 = require("@noble/hashes/sha2.js");
+var import_sdk11 = require("@arkade-os/sdk");
 
 // src/refund.ts
 var import_base9 = require("@scure/base");
-var import_sha23 = require("@noble/hashes/sha2.js");
-var import_sdk9 = require("@arkade-os/sdk");
+var import_sha24 = require("@noble/hashes/sha2.js");
+var import_sdk10 = require("@arkade-os/sdk");
 var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var isRfqTerminal = (state) => RFQ_TERMINAL_STATES.includes(state);
 var RFQ_RESOLVED_STATES = ["settled", "refunded"];
@@ -2285,9 +2345,9 @@ async function findLockupVtxos(indexer, swapPkScript) {
   }
   return out;
 }
-var hashesTo = (candidate, paymentHash) => import_base9.hex.encode((0, import_sha23.sha256)(candidate)) === paymentHash;
+var hashesTo = (candidate, paymentHash) => import_base9.hex.encode((0, import_sha24.sha256)(candidate)) === paymentHash;
 var candidateWitnessItems = (tx, inputIndex) => [
-  ...(0, import_sdk9.getArkPsbtFields)(tx, inputIndex, import_sdk9.ConditionWitness).flat(),
+  ...(0, import_sdk10.getArkPsbtFields)(tx, inputIndex, import_sdk10.ConditionWitness).flat(),
   ...tx.getInput(inputIndex).finalScriptWitness ?? []
 ];
 async function readLockupFate(indexer, input) {
@@ -2306,7 +2366,7 @@ async function readLockupFate(indexer, input) {
   for (const raw of txs) {
     let tx;
     try {
-      tx = import_sdk9.Transaction.fromPSBT(import_base9.base64.decode(raw));
+      tx = import_sdk10.Transaction.fromPSBT(import_base9.base64.decode(raw));
     } catch {
       continue;
     }
@@ -2343,14 +2403,14 @@ async function pushRefundWithoutReceiver(ark, input) {
   const info = await ark.getInfo();
   let serverUnrollScript;
   try {
-    serverUnrollScript = import_sdk9.CSVMultisigTapscript.decode(import_base9.hex.decode(info.checkpointTapscript));
+    serverUnrollScript = import_sdk10.CSVMultisigTapscript.decode(import_base9.hex.decode(info.checkpointTapscript));
   } catch {
     throw new Error("invalid checkpointTapscript from the Arkade server");
   }
   const leaf = input.script.refundWithoutReceiver();
   const tapTree = input.script.encode();
   const amount = input.vtxos.reduce((sum, vtxo) => sum + vtxo.value, 0);
-  const { arkTx, checkpoints } = (0, import_sdk9.buildOffchainTx)(
+  const { arkTx, checkpoints } = (0, import_sdk10.buildOffchainTx)(
     input.vtxos.map((vtxo) => ({
       txid: vtxo.txid,
       vout: vtxo.vout,
@@ -2366,8 +2426,8 @@ async function pushRefundWithoutReceiver(ark, input) {
     import_base9.base64.encode(signedArkTx.toPSBT()),
     checkpoints.map((c) => import_base9.base64.encode(c.toPSBT()))
   );
-  (0, import_sdk9.assertSubmittedArkTxid)(submitted, signedArkTx, "refundWithoutReceiver");
-  const matched = (0, import_sdk9.matchServerCheckpoints)(
+  (0, import_sdk10.assertSubmittedArkTxid)(submitted, signedArkTx, "refundWithoutReceiver");
+  const matched = (0, import_sdk10.matchServerCheckpoints)(
     submitted.signedCheckpointTxs,
     checkpoints,
     "refundWithoutReceiver"
@@ -2454,20 +2514,20 @@ async function pushClaim(ark, input) {
     }
   }
   const committed = input.script.options.preimageHash;
-  if (import_base10.hex.encode((0, import_legacy3.ripemd160)((0, import_sha24.sha256)(input.preimage))) !== import_base10.hex.encode(committed)) {
+  if (import_base10.hex.encode((0, import_legacy3.ripemd160)((0, import_sha25.sha256)(input.preimage))) !== import_base10.hex.encode(committed)) {
     throw new Error("preimage does not match the covenant's payment hash");
   }
   const info = await ark.getInfo();
   let serverUnrollScript;
   try {
-    serverUnrollScript = import_sdk10.CSVMultisigTapscript.decode(import_base10.hex.decode(info.checkpointTapscript));
+    serverUnrollScript = import_sdk11.CSVMultisigTapscript.decode(import_base10.hex.decode(info.checkpointTapscript));
   } catch {
     throw new Error("invalid checkpointTapscript from the Arkade server");
   }
   const leaf = input.script.claim();
   const tapTree = input.script.encode();
-  const arkTxid = await (0, import_sdk10.signAndSubmitOffchainTx)({
-    identity: (0, import_sdk10.claimWithPreimageIdentity)(input.receiver, input.preimage),
+  const arkTxid = await (0, import_sdk11.signAndSubmitOffchainTx)({
+    identity: (0, import_sdk11.claimWithPreimageIdentity)(input.receiver, input.preimage),
     provider: ark,
     inputs: input.vtxos.map((vtxo) => ({
       txid: vtxo.txid,
@@ -2514,7 +2574,7 @@ async function claimReceiveLockup(indexer, ark, input) {
 }
 
 // src/refundBlocked.ts
-var import_sdk11 = require("@arkade-os/sdk");
+var import_sdk12 = require("@arkade-os/sdk");
 var RefundNotLocallyPossibleError = class extends Error {
   constructor(reason, message, options) {
     super(message, options);
@@ -2531,16 +2591,16 @@ async function senderIdentityForSwapRecord(wallet, record) {
     );
   }
   try {
-    return await (0, import_sdk11.contractSigner)(wallet, record.signingDescriptor);
+    return await (0, import_sdk12.contractSigner)(wallet, record.signingDescriptor);
   } catch (cause) {
-    if (cause instanceof import_sdk11.WalletCannotSignError) {
+    if (cause instanceof import_sdk12.WalletCannotSignError) {
       throw new RefundNotLocallyPossibleError(
         "unsignable-wallet",
         `this wallet holds ${record.signingDescriptor} but cannot sign with it; attach its signer`,
         { cause }
       );
     }
-    if (cause instanceof import_sdk11.ForeignDescriptorError) {
+    if (cause instanceof import_sdk12.ForeignDescriptorError) {
       throw new RefundNotLocallyPossibleError(
         "foreign-descriptor",
         `this wallet cannot derive ${record.signingDescriptor}; the swap was created on another wallet`,
@@ -3317,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,
@@ -3342,6 +3456,7 @@ var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
   ONCHAIN_RECEIVE_PAIR,
   ONCHAIN_SECONDS_PER_BLOCK,
   ONCHAIN_SEND_PAIR,
+  PreimageNotRecoverableError,
   QUOTE_OPTIONS,
   REFUND_MTP_LAG_SECONDS,
   RFQ_RESOLVED_STATES,
@@ -3349,6 +3464,7 @@ var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
   RFQ_TERMINAL_STATES,
   RefundNotLocallyPossibleError,
   RfqSwapManager,
+  SOLO_REFUND_HEADROOM_SECONDS,
   SWAP_LOCKUP_CONTRACT_KIND,
   SWAP_LOCKUP_CONTRACT_LABEL,
   SWAP_LOCKUP_CONTRACT_TYPE,
@@ -3396,6 +3512,7 @@ var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
   onchainReceiveRequest,
   onchainSendRequest,
   paymentHashOf,
+  preimageForSwapRecord,
   pushClaim,
   pushRefundWithoutReceiver,
   readLockupFate,
@@ -3414,6 +3531,7 @@ var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
   senderIdentityForSwapRecord,
   spendTxidsOf,
   spendUpdate,
+  swapActivityResolver,
   swapPrograms,
   swapSecretsToRecord,
   unilateralClaimDelay,