@arkade-os/swap 0.1.0-rc.21 → 0.1.0-rc.23

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (37) hide show
  1. package/README.md +7 -2
  2. package/dist/advanced.cjs +875 -129
  3. package/dist/advanced.d.cts +158 -14
  4. package/dist/advanced.d.ts +158 -14
  5. package/dist/advanced.js +255 -4
  6. package/dist/{chunk-ITFCQWPG.js → chunk-DQ2DY2L2.js} +223 -11
  7. package/dist/{chunk-HUQQVBC4.js → chunk-MZX62KMU.js} +220 -12
  8. package/dist/{chunk-PVB7EBAM.js → chunk-UFJEO4VV.js} +47 -21
  9. package/dist/{errors-hm7aqnRM.d.cts → errors-5q4e3PnH.d.cts} +48 -16
  10. package/dist/{errors-C3h8ANmE.d.ts → errors-DQ35FKJf.d.ts} +48 -16
  11. package/dist/index.cjs +670 -185
  12. package/dist/index.d.cts +5 -5
  13. package/dist/index.d.ts +5 -5
  14. package/dist/index.js +5 -3
  15. package/dist/node/index.d.cts +26 -4
  16. package/dist/node/index.d.ts +26 -4
  17. package/dist/nostr.cjs +12 -9
  18. package/dist/nostr.d.cts +1 -1
  19. package/dist/nostr.d.ts +1 -1
  20. package/dist/nostr.js +3 -1
  21. package/dist/{offer-Bd9Yvd8Z.d.ts → offer--IpfzhIm.d.ts} +1 -1
  22. package/dist/{offer-F88rtL_I.d.cts → offer-DqTXQeP1.d.cts} +1 -1
  23. package/dist/protocol.cjs +395 -156
  24. package/dist/protocol.d.cts +45 -8
  25. package/dist/protocol.d.ts +45 -8
  26. package/dist/protocol.js +10 -3
  27. package/dist/repositories/realm/index.d.cts +2 -2
  28. package/dist/repositories/realm/index.d.ts +2 -2
  29. package/dist/repositories/sqlite/index.d.cts +2 -2
  30. package/dist/repositories/sqlite/index.d.ts +2 -2
  31. package/dist/{repository-DYnRLPt-.d.ts → repository-B4rQWmS2.d.cts} +88 -20
  32. package/dist/{repository-BuYWGAKz.d.cts → repository-D_qvJk1S.d.ts} +88 -20
  33. package/dist/{rfq-60PGpQ_x.d.cts → rfq-BgdgO9OO.d.cts} +16 -7
  34. package/dist/{rfq-60PGpQ_x.d.ts → rfq-BgdgO9OO.d.ts} +16 -7
  35. package/dist/{watch-BTyiBLSd.d.ts → watch-BkPz0vf8.d.ts} +1 -1
  36. package/dist/{watch-M_KY-5ho.d.cts → watch-RRhKuBkh.d.cts} +1 -1
  37. package/package.json +3 -3
package/dist/protocol.cjs CHANGED
@@ -53,6 +53,7 @@ __export(protocol_exports, {
53
53
  ONCHAIN_SECONDS_PER_BLOCK: () => ONCHAIN_SECONDS_PER_BLOCK,
54
54
  ONCHAIN_SEND_PAIR: () => ONCHAIN_SEND_PAIR,
55
55
  OfferCovenantMismatchError: () => OfferCovenantMismatchError,
56
+ OnchainReceiveNeedsChainSource: () => OnchainReceiveNeedsChainSource,
56
57
  PreimageNotRecoverableError: () => PreimageNotRecoverableError,
57
58
  QUOTE_OPTIONS: () => QUOTE_OPTIONS,
58
59
  RFQ_SWAP_RETENTION_SECONDS: () => RFQ_SWAP_RETENTION_SECONDS,
@@ -107,11 +108,13 @@ __export(protocol_exports, {
107
108
  makeCachedFeedFetch: () => makeCachedFeedFetch,
108
109
  newPreimage: () => newPreimage,
109
110
  nextOnchainAction: () => nextOnchainAction,
111
+ nextOnchainReceiveAction: () => nextOnchainReceiveAction,
110
112
  normalizeMakerPkScript: () => normalizeMakerPkScript,
111
113
  normalizeMakerPublicKey: () => normalizeMakerPublicKey,
112
114
  normalizeRfqSwapRecord: () => normalizeRfqSwapRecord,
113
115
  offerContract: () => offerContract,
114
116
  onchainHtlcScript: () => onchainHtlcScript,
117
+ onchainReceiveProfile: () => onchainReceiveProfile,
115
118
  onchainReceiveRequest: () => onchainReceiveRequest,
116
119
  onchainSendProfile: () => onchainSendProfile,
117
120
  onchainSendRequest: () => onchainSendRequest,
@@ -161,18 +164,19 @@ __export(protocol_exports, {
161
164
  module.exports = __toCommonJS(protocol_exports);
162
165
 
163
166
  // src/activity.ts
164
- var import_sdk13 = require("@arkade-os/sdk");
167
+ var import_sdk14 = require("@arkade-os/sdk");
165
168
  var import_base11 = require("@scure/base");
166
169
 
167
170
  // src/swapManager.ts
168
171
  var import_base10 = require("@scure/base");
169
- var import_sdk10 = require("@arkade-os/sdk");
172
+ var import_sdk11 = require("@arkade-os/sdk");
170
173
 
171
174
  // src/onchainHtlc.ts
172
175
  var import_base = require("@scure/base");
173
176
  var import_sha2 = require("@noble/hashes/sha2.js");
174
177
  var import_legacy = require("@noble/hashes/legacy.js");
175
178
  var btc = __toESM(require("@scure/btc-signer"), 1);
179
+ var import_sdk = require("@arkade-os/sdk");
176
180
  var ONCHAIN_ORDER_MARGIN_SECONDS = 2 * 60 * 60;
177
181
  var ONCHAIN_CLAIM_MARGIN_SECONDS = 90 * 60;
178
182
  var MAX_MIN_CONFIRMATIONS = 6;
@@ -195,6 +199,7 @@ var gateError = (reason, message) => {
195
199
  var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
196
200
  async function pollUntil(probe, options, reason, message) {
197
201
  const pollMs = options.pollMs ?? 5e3;
202
+ (0, import_sdk.assertTimerMs)("pollMs", pollMs);
198
203
  for (; ; ) {
199
204
  const value = await probe();
200
205
  if (value !== void 0) return value;
@@ -410,14 +415,14 @@ async function classifyOnchainHtlc(chain, input) {
410
415
  // src/refund.ts
411
416
  var import_base7 = require("@scure/base");
412
417
  var import_sha24 = require("@noble/hashes/sha2.js");
413
- var import_sdk7 = require("@arkade-os/sdk");
418
+ var import_sdk8 = require("@arkade-os/sdk");
414
419
 
415
420
  // src/rfq.ts
416
421
  var import_base6 = require("@scure/base");
417
422
  var import_solver_discovery = require("@arkade-os/solver-discovery");
418
423
  var import_legacy2 = require("@noble/hashes/legacy.js");
419
- var import_sdk5 = require("@arkade-os/sdk");
420
424
  var import_sdk6 = require("@arkade-os/sdk");
425
+ var import_sdk7 = require("@arkade-os/sdk");
421
426
 
422
427
  // src/claimPacket.ts
423
428
  var import_base2 = require("@scure/base");
@@ -461,7 +466,7 @@ var tlv = (type, value) => Uint8Array.from([type, value.length >> 8 & 255, value
461
466
 
462
467
  // src/lockupContract.ts
463
468
  var import_base3 = require("@scure/base");
464
- var import_sdk = require("@arkade-os/sdk");
469
+ var import_sdk2 = require("@arkade-os/sdk");
465
470
  var SWAP_LOCKUP_CONTRACT_TYPE = "vhtlc-v2";
466
471
  var SWAP_LOCKUP_CONTRACT_LABEL = "Arkade RFQ swap lockup";
467
472
  var SWAP_LOCKUP_CONTRACT_KIND = "rfq-swap-lockup";
@@ -497,7 +502,7 @@ async function registerLockupContract(contracts, script, address) {
497
502
  try {
498
503
  await contracts.createContract({
499
504
  type: SWAP_LOCKUP_CONTRACT_TYPE,
500
- params: import_sdk.VHTLCV2ContractHandler.serializeParams(script.options),
505
+ params: import_sdk2.VHTLCV2ContractHandler.serializeParams(script.options),
501
506
  script: import_base3.hex.encode(script.pkScript),
502
507
  address,
503
508
  label: SWAP_LOCKUP_CONTRACT_LABEL,
@@ -508,7 +513,7 @@ async function registerLockupContract(contracts, script, address) {
508
513
  }
509
514
  }
510
515
  async function lockupContractParams(contracts, lockupAddress) {
511
- const script = import_base3.hex.encode(import_sdk.ArkAddress.decode(lockupAddress).pkScript);
516
+ const script = import_base3.hex.encode(import_sdk2.ArkAddress.decode(lockupAddress).pkScript);
512
517
  const [row] = await contracts.getContracts({ script });
513
518
  if (!row) throw new LockupContractMissing(lockupAddress, script);
514
519
  return row.params;
@@ -517,7 +522,7 @@ async function lockupContractParams(contracts, lockupAddress) {
517
522
  // src/offer.ts
518
523
  var import_base5 = require("@scure/base");
519
524
  var import_utils2 = require("@scure/btc-signer/utils.js");
520
- var import_sdk4 = require("@arkade-os/sdk");
525
+ var import_sdk5 = require("@arkade-os/sdk");
521
526
 
522
527
  // src/swap-want-asset.program.json
523
528
  var swap_want_asset_program_default = {
@@ -644,12 +649,12 @@ async function retireOfferContract(manager, swaps, script) {
644
649
  // src/store.ts
645
650
  var import_base4 = require("@scure/base");
646
651
  var import_sha23 = require("@noble/hashes/sha2.js");
647
- var import_sdk3 = require("@arkade-os/sdk");
652
+ var import_sdk4 = require("@arkade-os/sdk");
648
653
 
649
654
  // src/repository.ts
650
- var import_sdk2 = require("@arkade-os/sdk");
651
- var collectAssetSwaps = (repository) => (0, import_sdk2.collectPages)((page) => repository.getAssetSwapsPage(page));
652
- var collectRfqSwaps = (repository, filter = {}) => (0, import_sdk2.collectPages)(
655
+ var import_sdk3 = require("@arkade-os/sdk");
656
+ var collectAssetSwaps = (repository) => (0, import_sdk3.collectPages)((page) => repository.getAssetSwapsPage(page));
657
+ var collectRfqSwaps = (repository, filter = {}) => (0, import_sdk3.collectPages)(
653
658
  (page) => repository.getRfqSwapsPage(filter, page)
654
659
  );
655
660
 
@@ -747,7 +752,7 @@ var preimageForSwapRecord = async (wallet, record) => {
747
752
  }
748
753
  let preimage;
749
754
  try {
750
- preimage = await (0, import_sdk3.contractPreimage)(wallet, record.signingDescriptor, { stored, salt });
755
+ preimage = await (0, import_sdk4.contractPreimage)(wallet, record.signingDescriptor, { stored, salt });
751
756
  } catch (cause) {
752
757
  throw new PreimageNotRecoverableError(
753
758
  "not-derivable",
@@ -766,8 +771,8 @@ var preimageForSwapRecord = async (wallet, record) => {
766
771
 
767
772
  // src/offer.ts
768
773
  var swapPrograms = {
769
- wantAsset: import_sdk4.arkade.parseArtifact(swap_want_asset_program_default),
770
- wantBtc: import_sdk4.arkade.parseArtifact(swap_want_btc_program_default)
774
+ wantAsset: import_sdk5.arkade.parseArtifact(swap_want_asset_program_default),
775
+ wantBtc: import_sdk5.arkade.parseArtifact(swap_want_btc_program_default)
771
776
  };
772
777
  function withExitClosure(program, exit) {
773
778
  if (!exit) return program;
@@ -814,7 +819,7 @@ function swapProgramBinding(offer, operatorPubkey) {
814
819
  }
815
820
  function offerContract(offer, operatorPubkey) {
816
821
  const { program, args, keys } = swapProgramBinding(offer, operatorPubkey);
817
- return new import_sdk4.arkade.ArkadeProgramScript(program, args, keys);
822
+ return new import_sdk5.arkade.ArkadeProgramScript(program, args, keys);
818
823
  }
819
824
  var OFFER_PACKET_TYPE = 3;
820
825
  var FIELDS = {
@@ -951,8 +956,8 @@ function decodeOffer(data) {
951
956
  return {
952
957
  swapPkScript: need("swapPkScript"),
953
958
  wantAmount: readU64(amount),
954
- ...fields.wantAsset && { wantAsset: import_sdk4.asset.AssetId.fromBytes(fields.wantAsset) },
955
- ...fields.offerAsset && { offerAsset: import_sdk4.asset.AssetId.fromBytes(fields.offerAsset) },
959
+ ...fields.wantAsset && { wantAsset: import_sdk5.asset.AssetId.fromBytes(fields.wantAsset) },
960
+ ...fields.offerAsset && { offerAsset: import_sdk5.asset.AssetId.fromBytes(fields.offerAsset) },
956
961
  makerPkScript: need("makerPkScript"),
957
962
  makerPublicKey: need("makerPublicKey"),
958
963
  emulatorPubkey: need("emulatorPubkey"),
@@ -976,15 +981,15 @@ async function registerOfferContract(wallet, info, binding, operatorPubkey, expe
976
981
  );
977
982
  await promoteOfferContract(contractManager, import_base5.hex.encode(expectedPkScript));
978
983
  }
979
- var derivingClient = (wallet, info, contractManager) => import_sdk4.arkade.Arkade.connect({
984
+ var derivingClient = (wallet, info, contractManager) => import_sdk5.arkade.Arkade.connect({
980
985
  arkade: { getInfo: async () => info },
981
986
  identity: wallet.identity,
982
- network: (0, import_sdk4.networkFromArkadeInfo)(info),
987
+ network: (0, import_sdk5.networkFromArkadeInfo)(info),
983
988
  contractManager
984
989
  });
985
990
  function offerContractParams(client, binding, operatorPubkey, expectedPkScript) {
986
991
  const { program, args, keys } = swapProgramBinding(binding, operatorPubkey);
987
- const contract = new import_sdk4.arkade.ArkadeContract(client, program, args, keys);
992
+ const contract = new import_sdk5.arkade.ArkadeContract(client, program, args, keys);
988
993
  if (import_base5.hex.encode(contract.pkScript) !== import_base5.hex.encode(expectedPkScript)) {
989
994
  throw new Error("derived covenant does not match the offer's swapPkScript");
990
995
  }
@@ -1028,13 +1033,13 @@ async function deriveOffer(wallet, params) {
1028
1033
  wallet.getAddress(),
1029
1034
  wallet.identity.xOnlyPublicKey()
1030
1035
  ]);
1031
- return { pkScript: import_sdk4.ArkAddress.decode(address).pkScript, publicKey };
1036
+ return { pkScript: import_sdk5.ArkAddress.decode(address).pkScript, publicKey };
1032
1037
  })()
1033
1038
  ]);
1034
- const operatorPubKey = import_base5.hex.decode((0, import_sdk4.toXOnlySignerHex)(info.signerPubkey));
1035
- const network = (0, import_sdk4.networkFromArkadeInfo)(info);
1039
+ const operatorPubKey = import_base5.hex.decode((0, import_sdk5.toXOnlySignerHex)(info.signerPubkey));
1040
+ const network = (0, import_sdk5.networkFromArkadeInfo)(info);
1036
1041
  const emuKey = import_base5.hex.decode(
1037
- (0, import_sdk4.toXOnlySignerHex)((0, import_sdk4.resolveEmulatorPubkey)(network, params.emulatorPubkey))
1042
+ (0, import_sdk5.toXOnlySignerHex)((0, import_sdk5.resolveEmulatorPubkey)(network, params.emulatorPubkey))
1038
1043
  );
1039
1044
  const binding = Object.freeze({
1040
1045
  wantAmount: params.wantAmount,
@@ -1122,7 +1127,7 @@ async function prepareOfferCancel(wallet, offerHex, opts) {
1122
1127
  wallet.getArkadeReader(),
1123
1128
  wallet.getArkadeBroadcaster()
1124
1129
  ]);
1125
- const client = await import_sdk4.arkade.Arkade.connect({
1130
+ const client = await import_sdk5.arkade.Arkade.connect({
1126
1131
  arkade: { getInfo: async () => info, ...broadcaster },
1127
1132
  indexer: reader,
1128
1133
  identity: wallet.identity,
@@ -1131,18 +1136,18 @@ async function prepareOfferCancel(wallet, offerHex, opts) {
1131
1136
  contractManager
1132
1137
  // no `network`: the row lookup is by script and the payout comes from wallet.getAddress()
1133
1138
  });
1134
- const operatorPubkey = swapAddress ? import_sdk4.ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
1139
+ const operatorPubkey = swapAddress ? import_sdk5.ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
1135
1140
  const { program, args, keys } = swapProgramBinding(offer, operatorPubkey);
1136
1141
  let rebuilt;
1137
1142
  try {
1138
- rebuilt = new import_sdk4.arkade.ArkadeProgramScript(program, args, keys);
1143
+ rebuilt = new import_sdk5.arkade.ArkadeProgramScript(program, args, keys);
1139
1144
  } catch (cause) {
1140
1145
  throw new OfferCovenantMismatchError(import_base5.hex.encode(offer.swapPkScript), { cause });
1141
1146
  }
1142
1147
  if (import_base5.hex.encode(rebuilt.pkScript) !== import_base5.hex.encode(offer.swapPkScript)) {
1143
1148
  throw new OfferCovenantMismatchError(import_base5.hex.encode(offer.swapPkScript));
1144
1149
  }
1145
- const contract = new import_sdk4.arkade.ArkadeContract(client, program, args, keys);
1150
+ const contract = new import_sdk5.arkade.ArkadeContract(client, program, args, keys);
1146
1151
  const [vtxos, makerAddress] = await Promise.all([contract.getUtxos(), wallet.getAddress()]);
1147
1152
  if (!fundingTxid && vtxos.length > 1) {
1148
1153
  throw new Error(
@@ -1151,7 +1156,7 @@ async function prepareOfferCancel(wallet, offerHex, opts) {
1151
1156
  }
1152
1157
  const vtxo = fundingTxid ? vtxos.find((v) => v.txid === fundingTxid) : vtxos[0];
1153
1158
  if (!vtxo) throw new NoSpendableDepositError();
1154
- const makerPkScript = import_sdk4.ArkAddress.decode(makerAddress).pkScript;
1159
+ const makerPkScript = import_sdk5.ArkAddress.decode(makerAddress).pkScript;
1155
1160
  const cancel = contract.functions.cancel().from({ txid: vtxo.txid, vout: vtxo.vout, value: vtxo.value }).to(makerPkScript, BigInt(vtxo.value));
1156
1161
  for (const a of vtxo.assets ?? []) {
1157
1162
  cancel.withAsset({
@@ -1166,7 +1171,7 @@ async function prepareOfferCancel(wallet, offerHex, opts) {
1166
1171
  send: async () => (await cancel.send()).txid
1167
1172
  };
1168
1173
  }
1169
- var ASSET_CARRIER_SATS = BigInt(import_sdk4.ASSET_CARRIER_SATS);
1174
+ var ASSET_CARRIER_SATS = BigInt(import_sdk5.ASSET_CARRIER_SATS);
1170
1175
  async function fillOffer(wallet, arkServerUrl, offerHex, opts) {
1171
1176
  const {
1172
1177
  fund,
@@ -1194,25 +1199,25 @@ async function fillOffer(wallet, arkServerUrl, offerHex, opts) {
1194
1199
  }
1195
1200
  }
1196
1201
  const contractManager = await wallet.getContractManager();
1197
- const client = await import_sdk4.arkade.Arkade.connect({
1198
- arkade: new import_sdk4.RestArkProvider(arkServerUrl),
1199
- indexer: new import_sdk4.RestIndexerProvider(arkServerUrl),
1202
+ const client = await import_sdk5.arkade.Arkade.connect({
1203
+ arkade: new import_sdk5.RestArkProvider(arkServerUrl),
1204
+ indexer: new import_sdk5.RestIndexerProvider(arkServerUrl),
1200
1205
  identity: wallet.identity,
1201
1206
  contractManager,
1202
- emulator: typeof emulator === "string" ? new import_sdk4.RestEmulatorProvider(emulator) : emulator,
1207
+ emulator: typeof emulator === "string" ? new import_sdk5.RestEmulatorProvider(emulator) : emulator,
1203
1208
  // only for the client's own emulatorKey, which this fill never derives against (the offer's
1204
1209
  // key is bound below) — but it must still resolve on a network with no pinned key
1205
1210
  ...emulatorPubkey ? { emulatorPubkey } : {}
1206
1211
  });
1207
- const serverKey = swapAddress ? import_sdk4.ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
1212
+ const serverKey = swapAddress ? import_sdk5.ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
1208
1213
  const { program, args, keys } = swapProgramBinding(offer, serverKey);
1209
- const rebuilt = new import_sdk4.arkade.ArkadeProgramScript(program, args, keys);
1214
+ const rebuilt = new import_sdk5.arkade.ArkadeProgramScript(program, args, keys);
1210
1215
  if (import_base5.hex.encode(rebuilt.pkScript) !== import_base5.hex.encode(offer.swapPkScript)) {
1211
1216
  throw new Error(
1212
1217
  "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"
1213
1218
  );
1214
1219
  }
1215
- const contract = new import_sdk4.arkade.ArkadeContract(client, program, args, keys);
1220
+ const contract = new import_sdk5.arkade.ArkadeContract(client, program, args, keys);
1216
1221
  const [vtxos, takerAddress] = await Promise.all([contract.getUtxos(), wallet.getAddress()]);
1217
1222
  if (!fundingTxid && vtxos.length > 1) {
1218
1223
  throw new Error(
@@ -1230,7 +1235,7 @@ async function fillOffer(wallet, arkServerUrl, offerHex, opts) {
1230
1235
  );
1231
1236
  }
1232
1237
  }
1233
- const payout = payoutScript ?? import_sdk4.ArkAddress.decode(takerAddress).pkScript;
1238
+ const payout = payoutScript ?? import_sdk5.ArkAddress.decode(takerAddress).pkScript;
1234
1239
  const makerSats = wantedAssetId === void 0 ? offer.wantAmount : assetCarrierSats;
1235
1240
  const fill = contract.functions.fulfill().from({ txid: vtxo.txid, vout: vtxo.vout, value: vtxo.value }).fund(fund).to(offer.makerPkScript, makerSats).change(payout);
1236
1241
  const held = /* @__PURE__ */ new Map();
@@ -1520,6 +1525,12 @@ var assertFundable = (input) => {
1520
1525
  const fail = (reason, message) => {
1521
1526
  throw gateError(reason, message);
1522
1527
  };
1528
+ if (input.quote.pair.split("->").some((leg) => leg.startsWith("ethereum:"))) {
1529
+ fail(
1530
+ "evm_funding_unavailable",
1531
+ "EVM funding is unavailable until local contract, finality, and deadline verification is implemented"
1532
+ );
1533
+ }
1523
1534
  if (input.quote.valid_until === void 0) {
1524
1535
  fail("quote_malformed", "quote carries no valid_until");
1525
1536
  }
@@ -1653,6 +1664,7 @@ var httpTransport = (baseUrl, options = {}) => {
1653
1664
  };
1654
1665
  var relayTransport = (relayUrl, options) => {
1655
1666
  const timeoutMs = options.timeoutMs ?? 3e4;
1667
+ (0, import_sdk6.assertTimerMs)("timeoutMs", timeoutMs);
1656
1668
  const Ctor = options.WebSocketCtor ?? WebSocket;
1657
1669
  const pending = /* @__PURE__ */ new Map();
1658
1670
  let sequence = 0;
@@ -1756,7 +1768,7 @@ var seconds = (value) => ({
1756
1768
  type: "seconds",
1757
1769
  value: BigInt(value)
1758
1770
  });
1759
- var suiteVhtlc = (params, roles) => new import_sdk5.VHTLC.ScriptV2({
1771
+ var suiteVhtlc = (params, roles) => new import_sdk6.VHTLC.ScriptV2({
1760
1772
  sender: roles.sender,
1761
1773
  receiver: roles.receiver,
1762
1774
  server: params.operatorPubkey,
@@ -1803,7 +1815,7 @@ function deriveLightningSend(input) {
1803
1815
  throw new Error("lightning-send quote is missing profile.receiver_pk_script");
1804
1816
  }
1805
1817
  const contractParams = {
1806
- solverPubkey: (0, import_sdk5.toXOnly)(import_base6.hex.decode(quote.solver_pubkey), "solver key"),
1818
+ solverPubkey: (0, import_sdk6.toXOnly)(import_base6.hex.decode(quote.solver_pubkey), "solver key"),
1807
1819
  refundLocktime: quote.refund_locktime,
1808
1820
  operatorPubkey: input.operatorPubkey,
1809
1821
  paymentHash: input.paymentHash,
@@ -1833,7 +1845,7 @@ function deriveLightningSend(input) {
1833
1845
  }
1834
1846
  async function requestLightningSend(wallet, transport, params) {
1835
1847
  const rfqId = params.rfqId ?? newRfqId();
1836
- const secrets = await (0, import_sdk6.provisionRefundKey)(wallet);
1848
+ const secrets = await (0, import_sdk7.provisionRefundKey)(wallet);
1837
1849
  const senderPubkey = secrets.pubkey;
1838
1850
  const refundAddress = secrets.address;
1839
1851
  const info = await wallet.getArkadeInfo({ requireLive: true });
@@ -1852,16 +1864,16 @@ async function requestLightningSend(wallet, transport, params) {
1852
1864
  `quote from_amount ${quote.from_amount} is below the invoice amount \u2014 a negative spread is not a quote`
1853
1865
  );
1854
1866
  }
1855
- const operatorPubkey = (0, import_sdk5.toXOnly)(import_base6.hex.decode(info.signerPubkey), "ark signer key");
1856
- const network = (0, import_sdk5.networkFromArkadeInfo)(info);
1867
+ const operatorPubkey = (0, import_sdk6.toXOnly)(import_base6.hex.decode(info.signerPubkey), "ark signer key");
1868
+ const network = (0, import_sdk6.networkFromArkadeInfo)(info);
1857
1869
  const derived = deriveLightningSend({
1858
1870
  quote,
1859
1871
  paymentHash: params.invoice.paymentHash,
1860
1872
  senderPubkey,
1861
1873
  refundPkScript: secrets.pkScript,
1862
1874
  operatorPubkey,
1863
- emulatorPubkey: (0, import_sdk5.toXOnly)(
1864
- import_base6.hex.decode((0, import_sdk5.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
1875
+ emulatorPubkey: (0, import_sdk6.toXOnly)(
1876
+ import_base6.hex.decode((0, import_sdk6.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
1865
1877
  "emulator signer key"
1866
1878
  ),
1867
1879
  claimDelay,
@@ -1940,7 +1952,7 @@ async function requestArkadeSwap(wallet, transport, params) {
1940
1952
  wallet.getAddress(),
1941
1953
  wallet.identity.xOnlyPublicKey()
1942
1954
  ]);
1943
- const makerPkScript = import_sdk5.ArkAddress.decode(makerAddress).pkScript;
1955
+ const makerPkScript = import_sdk6.ArkAddress.decode(makerAddress).pkScript;
1944
1956
  const pair = rfqPair(
1945
1957
  params.offerAsset ? arkadeAssetLeg(params.offerAsset) : ARKADE_BTC,
1946
1958
  params.wantAsset ? arkadeAssetLeg(params.wantAsset) : ARKADE_BTC
@@ -2010,11 +2022,11 @@ async function requestArkadeSwap(wallet, transport, params) {
2010
2022
  }
2011
2023
  var l1NetworkFromArk = (network) => network === "bitcoin" ? "bitcoin" : network === "regtest" ? "regtest" : "testnet";
2012
2024
  var serverTerms = (info, emulatorPubkey) => {
2013
- const network = (0, import_sdk5.networkFromArkadeInfo)(info);
2025
+ const network = (0, import_sdk6.networkFromArkadeInfo)(info);
2014
2026
  return {
2015
- operatorPubkey: (0, import_sdk5.toXOnly)(import_base6.hex.decode(info.signerPubkey), "ark signer key"),
2016
- emulatorPubkey: (0, import_sdk5.toXOnly)(
2017
- import_base6.hex.decode((0, import_sdk5.resolveEmulatorPubkey)(network, emulatorPubkey)),
2027
+ operatorPubkey: (0, import_sdk6.toXOnly)(import_base6.hex.decode(info.signerPubkey), "ark signer key"),
2028
+ emulatorPubkey: (0, import_sdk6.toXOnly)(
2029
+ import_base6.hex.decode((0, import_sdk6.resolveEmulatorPubkey)(network, emulatorPubkey)),
2018
2030
  "emulator signer key"
2019
2031
  ),
2020
2032
  claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
@@ -2077,7 +2089,7 @@ function deriveOnchainSend(input) {
2077
2089
  throw new Error("onchain-send quote is missing a binding field");
2078
2090
  }
2079
2091
  const contractParams = {
2080
- solverPubkey: (0, import_sdk5.toXOnly)(import_base6.hex.decode(quote.solver_pubkey), "solver key"),
2092
+ solverPubkey: (0, import_sdk6.toXOnly)(import_base6.hex.decode(quote.solver_pubkey), "solver key"),
2081
2093
  refundLocktime,
2082
2094
  operatorPubkey: input.operatorPubkey,
2083
2095
  paymentHash: input.paymentHash,
@@ -2085,7 +2097,7 @@ function deriveOnchainSend(input) {
2085
2097
  emulatorPubkey: input.emulatorPubkey,
2086
2098
  senderPubkey: input.senderPubkey,
2087
2099
  receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
2088
- refundPkScript: import_sdk5.ArkAddress.decode(input.refundAddress).pkScript
2100
+ refundPkScript: import_sdk6.ArkAddress.decode(input.refundAddress).pkScript
2089
2101
  };
2090
2102
  const { script, address } = matchQuotedLockup(
2091
2103
  quote,
@@ -2096,7 +2108,7 @@ function deriveOnchainSend(input) {
2096
2108
  const htlcParams = {
2097
2109
  paymentHash: input.paymentHash,
2098
2110
  claimKey: input.payoutPubkey,
2099
- refundKey: (0, import_sdk5.toXOnly)(import_base6.hex.decode(htlcPubkey), "solver L1 htlc key"),
2111
+ refundKey: (0, import_sdk6.toXOnly)(import_base6.hex.decode(htlcPubkey), "solver L1 htlc key"),
2100
2112
  refundLocktime: htlcLocktime
2101
2113
  };
2102
2114
  const htlc = onchainHtlcScript(htlcParams, input.l1Network);
@@ -2116,7 +2128,7 @@ function deriveOnchainSend(input) {
2116
2128
  }
2117
2129
  async function requestOnchainSend(wallet, transport, params) {
2118
2130
  const rfqId = params.rfqId ?? newRfqId();
2119
- const secrets = await (0, import_sdk6.provisionClaimSecret)(wallet, { preimage: params.preimage });
2131
+ const secrets = await (0, import_sdk7.provisionClaimSecret)(wallet, { preimage: params.preimage });
2120
2132
  if (secrets.mustPersistPreimage) {
2121
2133
  console.warn(
2122
2134
  "[swap] this swap's preimage cannot be re-derived from the seed and MUST be persisted with the record before funding"
@@ -2258,7 +2270,7 @@ function lightningReceiveContract(params) {
2258
2270
  }
2259
2271
  var matchReceiveLockup = (input, refundLocktime, solverRefundPkScriptHex) => {
2260
2272
  const contractParams = {
2261
- solverPubkey: (0, import_sdk5.toXOnly)(import_base6.hex.decode(input.quote.solver_pubkey), "solver key"),
2273
+ solverPubkey: (0, import_sdk6.toXOnly)(import_base6.hex.decode(input.quote.solver_pubkey), "solver key"),
2262
2274
  refundLocktime,
2263
2275
  operatorPubkey: input.operatorPubkey,
2264
2276
  paymentHash: input.paymentHash,
@@ -2266,7 +2278,7 @@ var matchReceiveLockup = (input, refundLocktime, solverRefundPkScriptHex) => {
2266
2278
  emulatorPubkey: input.emulatorPubkey,
2267
2279
  solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
2268
2280
  payoutPubkey: input.payoutPubkey,
2269
- payoutPkScript: import_sdk5.ArkAddress.decode(input.payoutAddress).pkScript
2281
+ payoutPkScript: import_sdk6.ArkAddress.decode(input.payoutAddress).pkScript
2270
2282
  };
2271
2283
  const matched = matchQuotedLockup(
2272
2284
  input.quote,
@@ -2303,7 +2315,7 @@ function deriveLightningReceive(input) {
2303
2315
  };
2304
2316
  }
2305
2317
  var provisionReceive = async (wallet, covclaimdPubkey, persistBefore) => {
2306
- const secrets = await (0, import_sdk6.provisionClaimSecret)(wallet);
2318
+ const secrets = await (0, import_sdk7.provisionClaimSecret)(wallet);
2307
2319
  if (secrets.mustPersistPreimage) {
2308
2320
  console.warn(
2309
2321
  `[swap] this swap's preimage cannot be re-derived from the seed and MUST be persisted with the record before ${persistBefore}`
@@ -2319,15 +2331,29 @@ var provisionReceive = async (wallet, covclaimdPubkey, persistBefore) => {
2319
2331
  const claimPacket = covclaimdPubkey ? await sealClaimPacket({ preimage, covclaimdPubkey }) : void 0;
2320
2332
  return { secrets, paymentHash, payoutPubkey, info, payoutAddress, claimPacket };
2321
2333
  };
2334
+ var quoteReceive = async (wallet, transport, covclaimdPubkey, persistBefore, request) => {
2335
+ for (let attempt = 0; ; attempt++) {
2336
+ const provisioned = await provisionReceive(wallet, covclaimdPubkey, persistBefore);
2337
+ try {
2338
+ return { ...provisioned, quote: await transport.requestQuote(request(provisioned)) };
2339
+ } catch (error) {
2340
+ const conflict = error instanceof SwapRefusal && error.reason === "quote_conflict";
2341
+ if (!conflict || attempt >= 1) throw error;
2342
+ }
2343
+ }
2344
+ };
2322
2345
  async function requestLightningReceive(wallet, transport, params) {
2323
2346
  const rfqId = params.rfqId ?? newRfqId();
2324
- const { secrets, paymentHash, payoutPubkey, info, payoutAddress, claimPacket } = await provisionReceive(wallet, params.covclaimdPubkey, "paying");
2325
- const quote = await transport.requestQuote(
2326
- lightningReceiveRequest({
2347
+ const { secrets, paymentHash, payoutPubkey, info, payoutAddress, quote } = await quoteReceive(
2348
+ wallet,
2349
+ transport,
2350
+ params.covclaimdPubkey,
2351
+ "paying",
2352
+ ({ paymentHash: paymentHash2, payoutAddress: payoutAddress2, payoutPubkey: payoutPubkey2, claimPacket }) => lightningReceiveRequest({
2327
2353
  rfqId,
2328
- paymentHash,
2329
- payoutAddress,
2330
- payoutPubkey,
2354
+ paymentHash: paymentHash2,
2355
+ payoutAddress: payoutAddress2,
2356
+ payoutPubkey: payoutPubkey2,
2331
2357
  claimPacket: claimPacket?.packet,
2332
2358
  amount: params.amount,
2333
2359
  amountSide: params.amountSide
@@ -2387,21 +2413,20 @@ function deriveOnchainReceive(input) {
2387
2413
  refundLocktime,
2388
2414
  solverRefundPkScriptHex
2389
2415
  ).matched;
2390
- const htlc = onchainHtlcScript(
2391
- {
2392
- paymentHash: input.paymentHash,
2393
- claimKey: (0, import_sdk5.toXOnly)(import_base6.hex.decode(claimPubkey), "solver L1 claim key"),
2394
- refundKey: input.refundPubkey,
2395
- refundLocktime: htlcLocktime
2396
- },
2397
- input.l1Network
2398
- );
2416
+ const htlcParams = {
2417
+ paymentHash: input.paymentHash,
2418
+ claimKey: (0, import_sdk6.toXOnly)(import_base6.hex.decode(claimPubkey), "solver L1 claim key"),
2419
+ refundKey: input.refundPubkey,
2420
+ refundLocktime: htlcLocktime
2421
+ };
2422
+ const htlc = onchainHtlcScript(htlcParams, input.l1Network);
2399
2423
  if (htlc.address !== htlcAddress) throw new AddressMismatch(htlc.address, htlcAddress);
2400
2424
  return {
2401
2425
  address,
2402
2426
  swapPkScript: script.pkScript,
2403
2427
  script,
2404
2428
  htlc,
2429
+ htlcParams,
2405
2430
  refundLocktime,
2406
2431
  htlcLocktime,
2407
2432
  minConfirmations
@@ -2409,13 +2434,16 @@ function deriveOnchainReceive(input) {
2409
2434
  }
2410
2435
  async function requestOnchainReceive(wallet, transport, params) {
2411
2436
  const rfqId = params.rfqId ?? newRfqId();
2412
- const { secrets, paymentHash, payoutPubkey, info, payoutAddress, claimPacket } = await provisionReceive(wallet, params.covclaimdPubkey, "funding");
2413
- const quote = await transport.requestQuote(
2414
- onchainReceiveRequest({
2437
+ const { secrets, paymentHash, payoutPubkey, info, payoutAddress, quote } = await quoteReceive(
2438
+ wallet,
2439
+ transport,
2440
+ params.covclaimdPubkey,
2441
+ "funding",
2442
+ ({ paymentHash: paymentHash2, payoutAddress: payoutAddress2, payoutPubkey: payoutPubkey2, claimPacket }) => onchainReceiveRequest({
2415
2443
  rfqId,
2416
- paymentHash,
2417
- payoutAddress,
2418
- payoutPubkey,
2444
+ paymentHash: paymentHash2,
2445
+ payoutAddress: payoutAddress2,
2446
+ payoutPubkey: payoutPubkey2,
2419
2447
  refundPubkey: params.refundPubkey,
2420
2448
  claimPacket: claimPacket?.packet,
2421
2449
  amount: params.amount,
@@ -2502,7 +2530,7 @@ async function findLockupVtxos(contracts, swapPkScript) {
2502
2530
  const out = [];
2503
2531
  for (const vtxo of row?.vtxos ?? []) {
2504
2532
  if (vtxo.isUnrolled) continue;
2505
- if ((0, import_sdk7.isVtxoSpent)(vtxo)) continue;
2533
+ if ((0, import_sdk8.isVtxoSpent)(vtxo)) continue;
2506
2534
  const key = `${vtxo.txid}:${vtxo.vout}`;
2507
2535
  if (seen.has(key)) continue;
2508
2536
  seen.add(key);
@@ -2517,14 +2545,14 @@ async function findLockupVtxos(contracts, swapPkScript) {
2517
2545
  }
2518
2546
  var hashesTo = (candidate, paymentHash) => import_base7.hex.encode((0, import_sha24.sha256)(candidate)) === paymentHash;
2519
2547
  var candidateWitnessItems = (tx, inputIndex) => [
2520
- ...(0, import_sdk7.getArkPsbtFields)(tx, inputIndex, import_sdk7.ConditionWitness).flat(),
2548
+ ...(0, import_sdk8.getArkPsbtFields)(tx, inputIndex, import_sdk8.ConditionWitness).flat(),
2521
2549
  ...tx.getInput(inputIndex).finalScriptWitness ?? []
2522
2550
  ];
2523
2551
  async function readLockupFate(indexer, input) {
2524
2552
  const { vtxos } = await indexer.getVtxos({ scripts: [import_base7.hex.encode(input.swapPkScript)] });
2525
2553
  const all = vtxos ?? [];
2526
2554
  if (all.length === 0) return { fate: "unknown" };
2527
- const exited = all.filter((vtxo) => vtxo.isUnrolled && !(0, import_sdk7.isVtxoSpent)(vtxo));
2555
+ const exited = all.filter((vtxo) => vtxo.isUnrolled && !(0, import_sdk8.isVtxoSpent)(vtxo));
2528
2556
  if (exited.length > 0) {
2529
2557
  return {
2530
2558
  fate: "exited",
@@ -2534,7 +2562,7 @@ async function readLockupFate(indexer, input) {
2534
2562
  const spentBy = /* @__PURE__ */ new Map();
2535
2563
  let everySpendNamed = true;
2536
2564
  for (const vtxo of all) {
2537
- if (!(0, import_sdk7.isVtxoSpent)(vtxo)) return { fate: "open" };
2565
+ if (!(0, import_sdk8.isVtxoSpent)(vtxo)) return { fate: "open" };
2538
2566
  if (vtxo.spentBy)
2539
2567
  spentBy.set(vtxo.spentBy, {
2540
2568
  checkpointTxid: vtxo.spentBy,
@@ -2548,7 +2576,7 @@ async function readLockupFate(indexer, input) {
2548
2576
  for (const raw of txs) {
2549
2577
  let tx;
2550
2578
  try {
2551
- tx = import_sdk7.Transaction.fromPSBT(import_base7.base64.decode(raw));
2579
+ tx = import_sdk8.Transaction.fromPSBT(import_base7.base64.decode(raw));
2552
2580
  } catch {
2553
2581
  continue;
2554
2582
  }
@@ -2578,10 +2606,10 @@ var assertNoneSwept = (vtxos, contract) => {
2578
2606
  };
2579
2607
  var operatorUnrollScript = async (operator, network) => {
2580
2608
  const info = await operator.getInfo();
2581
- return (0, import_sdk7.assertValidServerUnrollScript)(
2609
+ return (0, import_sdk8.assertValidServerUnrollScript)(
2582
2610
  info.checkpointTapscript,
2583
- (0, import_sdk7.resolveCheckpointExitDelayPolicy)(network ?? (0, import_sdk7.networkFromArkadeInfo)(info), {
2584
- advertisedForfeitPubkey: (0, import_sdk7.toXOnly)(import_base7.hex.decode(info.forfeitPubkey), "forfeit key")
2611
+ (0, import_sdk8.resolveCheckpointExitDelayPolicy)(network ?? (0, import_sdk8.networkFromArkadeInfo)(info), {
2612
+ advertisedForfeitPubkey: (0, import_sdk8.toXOnly)(import_base7.hex.decode(info.forfeitPubkey), "forfeit key")
2585
2613
  })
2586
2614
  );
2587
2615
  };
@@ -2607,7 +2635,7 @@ async function pushRefundWithoutReceiver(operator, input) {
2607
2635
  const serverUnrollScript = await operatorUnrollScript(operator, input.network);
2608
2636
  const leaf = input.contract.refundWithoutReceiver();
2609
2637
  const amount = input.vtxos.reduce((sum, vtxo) => sum + vtxo.value, 0);
2610
- const { arkTx: tx, checkpoints } = (0, import_sdk7.buildOffchainTx)(
2638
+ const { arkTx: tx, checkpoints } = (0, import_sdk8.buildOffchainTx)(
2611
2639
  lockupInputs(input.vtxos, input.contract, leaf),
2612
2640
  [{ script: refundPkScript, amount: BigInt(amount) }],
2613
2641
  serverUnrollScript
@@ -2617,8 +2645,8 @@ async function pushRefundWithoutReceiver(operator, input) {
2617
2645
  import_base7.base64.encode(signedTx.toPSBT()),
2618
2646
  checkpoints.map((c) => import_base7.base64.encode(c.toPSBT()))
2619
2647
  );
2620
- (0, import_sdk7.assertSubmittedArkTxid)(submitted, signedTx, "refundWithoutReceiver");
2621
- const matched = (0, import_sdk7.matchServerCheckpoints)(
2648
+ (0, import_sdk8.assertSubmittedArkTxid)(submitted, signedTx, "refundWithoutReceiver");
2649
+ const matched = (0, import_sdk8.matchServerCheckpoints)(
2622
2650
  submitted.signedCheckpointTxs,
2623
2651
  checkpoints,
2624
2652
  "refundWithoutReceiver"
@@ -2634,6 +2662,7 @@ async function pushRefundWithoutReceiver(operator, input) {
2634
2662
  var REFUND_MTP_LAG_SECONDS = 2 * 60 * 60;
2635
2663
  async function refundIfUnresolved(transport, operator, contracts, indexer, input) {
2636
2664
  const pollMs = input.pollMs ?? 5e3;
2665
+ (0, import_sdk8.assertTimerMs)("pollMs", pollMs);
2637
2666
  const now = input.now ?? (() => Math.floor(Date.now() / 1e3));
2638
2667
  const attemptDeadline = input.attemptDeadline ?? input.refundLocktime + REFUND_MTP_LAG_SECONDS;
2639
2668
  for (; ; ) {
@@ -2682,7 +2711,7 @@ async function refundIfUnresolved(transport, operator, contracts, indexer, input
2682
2711
  }
2683
2712
 
2684
2713
  // src/rfqRecord.ts
2685
- var import_sdk8 = require("@arkade-os/sdk");
2714
+ var import_sdk9 = require("@arkade-os/sdk");
2686
2715
  var import_base9 = require("@scure/base");
2687
2716
 
2688
2717
  // src/rfqSwapState.ts
@@ -2911,9 +2940,80 @@ var OnchainSendCorridor = {
2911
2940
  // Our own L1 claim only: `funding` is the solver's tx, not a row this wallet made.
2912
2941
  activityTxids: (profile) => profile.claimTxid ? [profile.claimTxid] : []
2913
2942
  };
2943
+ function onchainReceiveProfile(result) {
2944
+ return {
2945
+ claimKey: import_base8.hex.encode(result.htlcParams.claimKey),
2946
+ refundKey: import_base8.hex.encode(result.htlcParams.refundKey),
2947
+ htlcLocktime: result.htlcParams.refundLocktime,
2948
+ network: result.l1Network,
2949
+ htlcAddress: result.htlc.address,
2950
+ minConfirmations: result.minConfirmations,
2951
+ refundPkScript: import_base8.hex.encode(result.refundPkScript),
2952
+ ...result.refundDescriptor === void 0 ? {} : { refundDescriptor: result.refundDescriptor }
2953
+ };
2954
+ }
2955
+ var OnchainReceiveCorridor = {
2956
+ kind: "onchain_receive",
2957
+ project: (swap) => {
2958
+ const receive = swap;
2959
+ return {
2960
+ expectedAmount: receive.expectedAmount,
2961
+ ...receive.claimTxid ? { claimTxid: receive.claimTxid } : {},
2962
+ ...receive.funding ? { funding: receive.funding } : {}
2963
+ };
2964
+ },
2965
+ hydrate(profile) {
2966
+ const { paymentHash } = hydrateHashlock(profile);
2967
+ if (typeof profile.expectedAmount !== "number" || !Number.isFinite(profile.expectedAmount)) {
2968
+ throw new Error("onchain_receive record carries no expectedAmount; it cannot claim");
2969
+ }
2970
+ if (!profile.claimKey || !profile.refundKey) {
2971
+ throw new Error(
2972
+ "onchain_receive record carries no L1 keys; its HTLC cannot be rebuilt and the trader's own funding could never be taken back"
2973
+ );
2974
+ }
2975
+ if (!Number.isInteger(profile.minConfirmations) || profile.minConfirmations < 1) {
2976
+ throw new Error(
2977
+ `onchain_receive record carries no usable minConfirmations (${String(profile.minConfirmations)}); the confirmation gate cannot be checked`
2978
+ );
2979
+ }
2980
+ if (!profile.refundPkScript) {
2981
+ throw new Error(
2982
+ "onchain_receive record carries no refundPkScript; its L1 refund could not be built, so the trader's funding would be stranded"
2983
+ );
2984
+ }
2985
+ const htlc = onchainHtlcScript(
2986
+ {
2987
+ paymentHash,
2988
+ claimKey: import_base8.hex.decode(profile.claimKey),
2989
+ refundKey: import_base8.hex.decode(profile.refundKey),
2990
+ refundLocktime: profile.htlcLocktime
2991
+ },
2992
+ profile.network
2993
+ );
2994
+ if (htlc.address !== profile.htlcAddress) {
2995
+ throw new Error(
2996
+ `onchain_receive record's L1 inputs derive ${htlc.address}, but the funding went to ${String(profile.htlcAddress)} \u2014 these are not this swap's`
2997
+ );
2998
+ }
2999
+ return {
3000
+ paymentHash,
3001
+ htlc,
3002
+ expectedAmount: profile.expectedAmount,
3003
+ minConfirmations: profile.minConfirmations,
3004
+ refundPkScript: import_base8.hex.decode(profile.refundPkScript),
3005
+ ...profile.claimTxid ? { claimTxid: profile.claimTxid } : {},
3006
+ ...profile.funding ? { funding: profile.funding } : {}
3007
+ };
3008
+ },
3009
+ claimSecret: (profile) => ({ ...profile.signer, ...profile.hashlock }),
3010
+ // The L1 refund is the record's own `refundTxid`, read by the activity resolver directly.
3011
+ activityTxids: (profile) => profile.claimTxid ? [profile.claimTxid] : []
3012
+ };
2914
3013
  rfqCorridorHandlers.register(LightningSendCorridor);
2915
3014
  rfqCorridorHandlers.register(LightningReceiveCorridor);
2916
3015
  rfqCorridorHandlers.register(OnchainSendCorridor);
3016
+ rfqCorridorHandlers.register(OnchainReceiveCorridor);
2917
3017
 
2918
3018
  // src/rfqRecord.ts
2919
3019
  var RFQ_SWAP_RETENTION_SECONDS = 30 * 24 * 60 * 60;
@@ -2957,7 +3057,7 @@ function assertSameSwap(origin, swap) {
2957
3057
  `rfq swap record is a ${origin.kind} origin paired with a ${swap.kind} swap`
2958
3058
  );
2959
3059
  }
2960
- const funded = import_base9.hex.encode(import_sdk8.ArkAddress.decode(origin.lockupAddress).pkScript);
3060
+ const funded = import_base9.hex.encode(import_sdk9.ArkAddress.decode(origin.lockupAddress).pkScript);
2961
3061
  const watched = import_base9.hex.encode(swap.lockupPkScript);
2962
3062
  if (funded !== watched) {
2963
3063
  throw new Error(
@@ -3004,8 +3104,8 @@ function rfqSwapOriginOf(record) {
3004
3104
  };
3005
3105
  }
3006
3106
  function lockupScript(params, lockupAddress) {
3007
- const script = import_sdk8.VHTLCV2ContractHandler.createScript(params);
3008
- const funded = import_sdk8.ArkAddress.decode(lockupAddress).pkScript;
3107
+ const script = import_sdk9.VHTLCV2ContractHandler.createScript(params);
3108
+ const funded = import_sdk9.ArkAddress.decode(lockupAddress).pkScript;
3009
3109
  if (import_base9.hex.encode(funded) !== import_base9.hex.encode(script.pkScript)) {
3010
3110
  throw new Error(
3011
3111
  `rfq swap covenant params derive ${import_base9.hex.encode(script.pkScript)}, but the record's lockup address holds ${import_base9.hex.encode(funded)} \u2014 these params are not this swap's`
@@ -3041,7 +3141,7 @@ function shouldRetainRfqSwap(record, now) {
3041
3141
  }
3042
3142
 
3043
3143
  // src/refundBlocked.ts
3044
- var import_sdk9 = require("@arkade-os/sdk");
3144
+ var import_sdk10 = require("@arkade-os/sdk");
3045
3145
  var RefundNotLocallyPossibleError = class extends Error {
3046
3146
  constructor(reason, message, options) {
3047
3147
  super(message, options);
@@ -3058,16 +3158,16 @@ async function senderIdentityForSwapRecord(wallet, record) {
3058
3158
  );
3059
3159
  }
3060
3160
  try {
3061
- return await (0, import_sdk9.contractSigner)(wallet, record.signingDescriptor);
3161
+ return await (0, import_sdk10.contractSigner)(wallet, record.signingDescriptor);
3062
3162
  } catch (cause) {
3063
- if (cause instanceof import_sdk9.WalletCannotSignError) {
3163
+ if (cause instanceof import_sdk10.WalletCannotSignError) {
3064
3164
  throw new RefundNotLocallyPossibleError(
3065
3165
  "unsignable-wallet",
3066
3166
  `this wallet holds ${record.signingDescriptor} but cannot sign with it; attach its signer`,
3067
3167
  { cause }
3068
3168
  );
3069
3169
  }
3070
- if (cause instanceof import_sdk9.ForeignDescriptorError) {
3170
+ if (cause instanceof import_sdk10.ForeignDescriptorError) {
3071
3171
  throw new RefundNotLocallyPossibleError(
3072
3172
  "foreign-descriptor",
3073
3173
  `this wallet cannot derive ${record.signingDescriptor}; the swap was created on another wallet`,
@@ -3094,12 +3194,29 @@ function nextOnchainAction(input) {
3094
3194
  return input.htlcLocktime - input.now >= ONCHAIN_CLAIM_MARGIN_SECONDS ? "claim" : "claim_window_closed";
3095
3195
  }
3096
3196
  }
3197
+ function nextOnchainReceiveAction(input) {
3198
+ switch (input.phase.phase) {
3199
+ case "unfunded":
3200
+ case "awaiting_confirmations":
3201
+ case "claimable":
3202
+ return "wait";
3203
+ case "claimed":
3204
+ return "taken";
3205
+ case "swept":
3206
+ return "refunded";
3207
+ case "refundable":
3208
+ return input.settled ? "taken" : "refund";
3209
+ }
3210
+ }
3097
3211
  var RFQ_CONFIGURATION_REFUSAL = {
3098
3212
  noClaimLockupCallback: "no claimLockup callback is wired, so this wallet cannot claim the lockup",
3099
3213
  noCallbacksForClaim: "no callbacks are wired, so this wallet cannot claim the lockup",
3100
3214
  noClaimOnchainCallback: "no claimOnchain callback is wired, so this wallet cannot claim the L1 fill",
3101
3215
  autoActionsDisabled: "automatic actions are disabled, so this wallet will not push the refund",
3102
- noCallbacksForRefund: "no callbacks are wired, so this wallet cannot push the refund"
3216
+ noCallbacksForRefund: "no callbacks are wired, so this wallet cannot push the refund",
3217
+ noRefundOnchainCallback: "no refundOnchain callback is wired, so this wallet cannot take the L1 funding back",
3218
+ noCallbacksForL1Refund: "no callbacks are wired, so this wallet cannot take the L1 funding back",
3219
+ autoActionsDisabledForL1Refund: "automatic actions are disabled, so this wallet will not push the L1 refund"
3103
3220
  };
3104
3221
  var RFQ_CONFIGURATION_REFUSALS = Object.values(RFQ_CONFIGURATION_REFUSAL);
3105
3222
  var RfqSwapOriginRequired = class extends Error {
@@ -3113,6 +3230,16 @@ var RfqSwapOriginRequired = class extends Error {
3113
3230
  this.rfqId = rfqId;
3114
3231
  }
3115
3232
  };
3233
+ var OnchainReceiveNeedsChainSource = class extends Error {
3234
+ rfqId;
3235
+ constructor(rfqId) {
3236
+ super(
3237
+ `rfq swap ${rfqId} is an onchain_receive swap and this manager has no ChainSource; its L1 refund could be neither seen nor made, so it is refused rather than monitored blind`
3238
+ );
3239
+ this.name = "OnchainReceiveNeedsChainSource";
3240
+ this.rfqId = rfqId;
3241
+ }
3242
+ };
3116
3243
  var notify = (listeners, call) => {
3117
3244
  for (const listener of listeners) {
3118
3245
  try {
@@ -3177,6 +3304,7 @@ var RfqSwapManager = class _RfqSwapManager {
3177
3304
  timer = null;
3178
3305
  running = false;
3179
3306
  constructor(deps, config = {}) {
3307
+ (0, import_sdk11.assertTimerMs)("pollIntervalMs", config.pollIntervalMs);
3180
3308
  this.deps = deps;
3181
3309
  this.config = {
3182
3310
  enableAutoActions: config.enableAutoActions ?? true,
@@ -3232,6 +3360,9 @@ var RfqSwapManager = class _RfqSwapManager {
3232
3360
  let swap;
3233
3361
  try {
3234
3362
  swap = rebuildRfqSwap(record, await params(record));
3363
+ if (swap.kind === "onchain_receive" && !this.deps.chain) {
3364
+ throw new OnchainReceiveNeedsChainSource(swap.rfqId);
3365
+ }
3235
3366
  } catch (error) {
3236
3367
  failed.push({
3237
3368
  rfqId: record.rfqId,
@@ -3366,6 +3497,9 @@ var RfqSwapManager = class _RfqSwapManager {
3366
3497
  * origin, one remembered from an earlier `addSwap`, or the stored record (one read).
3367
3498
  */
3368
3499
  async admit(swap, origin) {
3500
+ if (swap.kind === "onchain_receive" && !this.deps.chain) {
3501
+ throw new OnchainReceiveNeedsChainSource(swap.rfqId);
3502
+ }
3369
3503
  if (origin) {
3370
3504
  assertSameSwap(origin, swap);
3371
3505
  this.origins.set(swap.rfqId, origin);
@@ -3514,7 +3648,7 @@ var RfqSwapManager = class _RfqSwapManager {
3514
3648
  });
3515
3649
  return;
3516
3650
  }
3517
- if (!(0, import_sdk10.isContractVtxoEvent)(event)) return;
3651
+ if (!(0, import_sdk11.isContractVtxoEvent)(event)) return;
3518
3652
  const swap = this.byLockupScript.get(event.contractScript);
3519
3653
  if (!swap) return;
3520
3654
  void this.pollSwap(swap).catch(() => {
@@ -3632,6 +3766,7 @@ var RfqSwapManager = class _RfqSwapManager {
3632
3766
  } catch {
3633
3767
  fate = { fate: "unknown" };
3634
3768
  }
3769
+ if (swap.kind === "onchain_receive") return this.driveOnchainReceive(swap, fate);
3635
3770
  if (fate.fate === "claimed" || fate.fate === "returned") {
3636
3771
  this.stampLockupSpends(swap, fate.spends);
3637
3772
  if (fate.fate === "claimed") this.stampSettlementPreimage(swap, fate.preimage);
@@ -3741,8 +3876,8 @@ var RfqSwapManager = class _RfqSwapManager {
3741
3876
  this.setState(swap, "claimed");
3742
3877
  this.emitAction(swap, "claimLockup");
3743
3878
  } catch (error) {
3744
- const ark = (0, import_sdk10.isArkError)(error) ? error : (0, import_sdk10.maybeArkError)(error);
3745
- if ((0, import_sdk10.isArkError)(ark, import_sdk10.ArkErrorName.VTXO_ALREADY_SPENT)) {
3879
+ const ark = (0, import_sdk11.isArkError)(error) ? error : (0, import_sdk11.maybeArkError)(error);
3880
+ if ((0, import_sdk11.isArkError)(ark, import_sdk11.ArkErrorName.VTXO_ALREADY_SPENT)) {
3746
3881
  if (swap.claimFailure !== void 0) {
3747
3882
  delete swap.claimFailure;
3748
3883
  this.touch(swap);
@@ -3754,6 +3889,94 @@ var RfqSwapManager = class _RfqSwapManager {
3754
3889
  this.emitFailed(swap, error);
3755
3890
  }
3756
3891
  }
3892
+ /** `settled` ends the swap; `returned` does NOT, signalling their L1
3893
+ * funding is stranded. */
3894
+ async driveOnchainReceive(swap, fate) {
3895
+ const settled = fate.fate === "claimed";
3896
+ if (settled || fate.fate === "returned") this.stampLockupSpends(swap, fate.spends);
3897
+ if (settled) {
3898
+ this.setState(swap, "settled");
3899
+ return;
3900
+ }
3901
+ const l1 = await this.driveOnchainRefund(swap, swap.claimTxid !== void 0);
3902
+ if (fate.fate === "returned") {
3903
+ if (l1.verdict === "resolved") this.setState(swap, "refunded");
3904
+ else if (l1.blocked) this.block(swap, l1.blocked);
3905
+ return;
3906
+ }
3907
+ if (fate.fate === "exited") return this.blockExitedLockup(swap, fate);
3908
+ if (l1.verdict === "live" && this.config.now() >= swap.refundLocktime + REFUND_MTP_LAG_SECONDS) {
3909
+ return this.block(
3910
+ swap,
3911
+ l1.blocked ?? "the Arkade claim window closed unclaimed and the L1 HTLC is still funded \u2014 holding the swap open until its refund leaf opens"
3912
+ );
3913
+ }
3914
+ if (swap.refundTxid || l1.attempted) {
3915
+ return this.block(
3916
+ swap,
3917
+ "the L1 funding was refunded, so claiming the lockup too would take both sides of the trade \u2014 the solver's reclaim ends this swap"
3918
+ );
3919
+ }
3920
+ await this.driveReceiveClaim(swap);
3921
+ if (l1.blocked && !isRfqSwapTerminal(swap.state)) this.block(swap, l1.blocked);
3922
+ }
3923
+ /** `resolved`: the HTLC can hold nothing more. `blocked` is a refusal the
3924
+ * caller applies once the Arkade arm has run. No give-up branch. */
3925
+ async driveOnchainRefund(swap, claimSubmitted) {
3926
+ if (!this.deps.chain) return { verdict: "live" };
3927
+ let phase;
3928
+ try {
3929
+ phase = await classifyOnchainHtlc(this.deps.chain, {
3930
+ htlc: swap.htlc,
3931
+ minConfirmations: swap.minConfirmations,
3932
+ funding: swap.funding
3933
+ });
3934
+ } catch {
3935
+ return { verdict: "live" };
3936
+ }
3937
+ if ("utxo" in phase && !swap.funding) {
3938
+ swap.funding = { txid: phase.utxo.txid, vout: phase.utxo.vout };
3939
+ this.touch(swap);
3940
+ }
3941
+ if (phase.phase === "unfunded" && !swap.funding) return { verdict: "resolved" };
3942
+ switch (nextOnchainReceiveAction({ phase, settled: claimSubmitted })) {
3943
+ case "taken":
3944
+ return { verdict: "resolved" };
3945
+ case "refunded":
3946
+ if (phase.phase === "swept" && !swap.refundTxid) {
3947
+ swap.refundTxid = phase.txid;
3948
+ this.touch(swap);
3949
+ }
3950
+ return { verdict: "resolved" };
3951
+ case "wait":
3952
+ return { verdict: "live" };
3953
+ case "refund":
3954
+ break;
3955
+ }
3956
+ if (phase.phase !== "refundable") return { verdict: "live" };
3957
+ if (swap.refundTxid) return { verdict: "live" };
3958
+ if (!this.callbacks?.refundOnchain) {
3959
+ return {
3960
+ verdict: "live",
3961
+ blocked: this.callbacks ? RFQ_CONFIGURATION_REFUSAL.noRefundOnchainCallback : RFQ_CONFIGURATION_REFUSAL.noCallbacksForL1Refund
3962
+ };
3963
+ }
3964
+ if (!this.config.enableAutoActions) {
3965
+ return {
3966
+ verdict: "live",
3967
+ blocked: RFQ_CONFIGURATION_REFUSAL.autoActionsDisabledForL1Refund
3968
+ };
3969
+ }
3970
+ try {
3971
+ const { txid } = await this.callbacks.refundOnchain(swap, phase.utxo);
3972
+ swap.refundTxid = txid;
3973
+ this.touch(swap);
3974
+ this.emitAction(swap, "refundOnchain");
3975
+ } catch (error) {
3976
+ this.emitFailed(swap, error);
3977
+ }
3978
+ return { verdict: "live", attempted: true };
3979
+ }
3757
3980
  /** `handled` ends the pass; `continue` falls through to the refund gate. */
3758
3981
  async driveOnchain(swap) {
3759
3982
  if (!this.deps.chain) {
@@ -4032,10 +4255,10 @@ var RfqSwapManager = class _RfqSwapManager {
4032
4255
  this.waiters.delete(swap.rfqId);
4033
4256
  }
4034
4257
  };
4035
- var traderClaimTxid = (swap) => swap.kind === "onchain_send" || swap.kind === "lightning_receive" ? swap.claimTxid : void 0;
4258
+ var traderClaimTxid = (swap) => swap.kind === "lightning_send" ? void 0 : swap.claimTxid;
4036
4259
  var isPayoutDecided = (swap) => swap.state === "settled" || swap.state === "refunded" || swap.kind === "onchain_send" && swap.claimTxid !== void 0;
4037
4260
  var outcomeOf = (swap) => {
4038
- const lostReceive = swap.kind === "lightning_receive" && swap.state === "refunded";
4261
+ const lostReceive = (swap.kind === "lightning_receive" || swap.kind === "onchain_receive") && swap.state === "refunded";
4039
4262
  return {
4040
4263
  state: swap.state,
4041
4264
  txid: lostReceive ? swap.refundTxid : traderClaimTxid(swap) ?? swap.refundTxid
@@ -4043,18 +4266,18 @@ var outcomeOf = (swap) => {
4043
4266
  };
4044
4267
  var outcomeOfRecord = (stored) => {
4045
4268
  const record = normalizeRfqSwapRecord(stored);
4046
- const profileClaim = record.kind === "onchain_send" || record.kind === "lightning_receive" ? record.profile.claimTxid : void 0;
4269
+ const profileClaim = record.kind === "lightning_send" ? void 0 : record.profile.claimTxid;
4047
4270
  const claimTxid = typeof profileClaim === "string" ? profileClaim : void 0;
4048
4271
  return {
4049
4272
  state: record.state,
4050
- txid: record.kind === "lightning_receive" && record.state === "refunded" ? record.refundTxid : claimTxid ?? record.refundTxid
4273
+ txid: (record.kind === "lightning_receive" || record.kind === "onchain_receive") && record.state === "refunded" ? record.refundTxid : claimTxid ?? record.refundTxid
4051
4274
  };
4052
4275
  };
4053
4276
  var errorMessage = (error) => error instanceof Error ? error.message : String(error);
4054
4277
  var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
4055
4278
 
4056
4279
  // src/client/corridors/lightning.ts
4057
- var import_sdk11 = require("@arkade-os/sdk");
4280
+ var import_sdk12 = require("@arkade-os/sdk");
4058
4281
  var INVOICE_HRPS = [
4059
4282
  ["lnbcrt", ["regtest"]],
4060
4283
  ["lntbs", ["signet", "mutinynet"]],
@@ -4084,7 +4307,7 @@ var lightningCorridor = Object.assign(
4084
4307
  deps,
4085
4308
  drive: LIGHTNING_DRIVE,
4086
4309
  matches(raw) {
4087
- const invoice = (0, import_sdk11.invoiceTarget)(raw);
4310
+ const invoice = (0, import_sdk12.invoiceTarget)(raw);
4088
4311
  if (invoice === void 0) return void 0;
4089
4312
  const networks = networksOfInvoiceHrp(invoice);
4090
4313
  if (networks === void 0) {
@@ -4130,11 +4353,11 @@ var lightningCorridor = Object.assign(
4130
4353
  };
4131
4354
  }
4132
4355
  }),
4133
- { target: import_sdk11.invoiceTarget }
4356
+ { target: import_sdk12.invoiceTarget }
4134
4357
  );
4135
4358
 
4136
4359
  // src/client/corridors/onchain.ts
4137
- var import_sdk12 = require("@arkade-os/sdk");
4360
+ var import_sdk13 = require("@arkade-os/sdk");
4138
4361
  var btc2 = __toESM(require("@scure/btc-signer"), 1);
4139
4362
  var ONCHAIN_DRIVE = {
4140
4363
  take: {
@@ -4144,6 +4367,14 @@ var ONCHAIN_DRIVE = {
4144
4367
  ],
4145
4368
  actions: ["claimOnchain", "refundArkade"],
4146
4369
  seams: ["indexer", "chain"]
4370
+ },
4371
+ give: {
4372
+ lockups: [
4373
+ { covenant: "arkade_lockup", owner: "solver", deadline: "refund_locktime" },
4374
+ { covenant: "onchain_htlc", owner: "trader", deadline: "htlc_refund_locktime" }
4375
+ ],
4376
+ actions: ["claimLockup", "refundOnchain"],
4377
+ seams: ["indexer", "chain"]
4147
4378
  }
4148
4379
  };
4149
4380
  var onchainCorridor = Object.assign(
@@ -4154,14 +4385,14 @@ var onchainCorridor = Object.assign(
4154
4385
  deps,
4155
4386
  drive: ONCHAIN_DRIVE,
4156
4387
  matches(raw) {
4157
- const target = (0, import_sdk12.btcTarget)(raw);
4388
+ const target = (0, import_sdk13.btcTarget)(raw);
4158
4389
  if (target === void 0) return void 0;
4159
4390
  try {
4160
4391
  btc2.Address(L1_NETWORKS[l1]).decode(target);
4161
4392
  } catch {
4162
4393
  return { refused: `this is not a ${l1} address` };
4163
4394
  }
4164
- const amount = import_sdk12.BIP21.amountSats(raw);
4395
+ const amount = import_sdk13.BIP21.amountSats(raw);
4165
4396
  return {
4166
4397
  claimed: {
4167
4398
  kind: "address",
@@ -4172,19 +4403,21 @@ var onchainCorridor = Object.assign(
4172
4403
  }
4173
4404
  };
4174
4405
  },
4175
- { target: import_sdk12.btcTarget }
4406
+ { target: import_sdk13.btcTarget }
4176
4407
  );
4177
4408
 
4178
4409
  // src/client/outcome.ts
4179
4410
  var CORRIDOR_PASS = {
4180
4411
  lightning_send: LIGHTNING_DRIVE.take,
4181
4412
  lightning_receive: LIGHTNING_DRIVE.give,
4182
- onchain_send: ONCHAIN_DRIVE.take
4413
+ onchain_send: ONCHAIN_DRIVE.take,
4414
+ onchain_receive: ONCHAIN_DRIVE.give
4183
4415
  };
4184
4416
  var LOCKUP_OWNER = {
4185
4417
  lightning_send: CORRIDOR_PASS.lightning_send.lockups[0].owner,
4186
4418
  lightning_receive: CORRIDOR_PASS.lightning_receive.lockups[0].owner,
4187
- onchain_send: CORRIDOR_PASS.onchain_send.lockups[0].owner
4419
+ onchain_send: CORRIDOR_PASS.onchain_send.lockups[0].owner,
4420
+ onchain_receive: CORRIDOR_PASS.onchain_receive.lockups[0].owner
4188
4421
  };
4189
4422
  var at = (outcome) => () => outcome;
4190
4423
  var CORRIDOR_OUTCOME = {
@@ -4205,8 +4438,9 @@ var CORRIDOR_OUTCOME = {
4205
4438
  needs_counterparty: at("needs_recovery"),
4206
4439
  // Matched by the hash, not our txid, so a claim that lands without us counts.
4207
4440
  settled: at("claimed"),
4208
- // The inversion: a receive lockup's non-claim leaves are all the solver's.
4209
- refunded: at("lapsed"),
4441
+ // The inversion: a receive lockup's non-claim leaves are all the solver's. On
4442
+ // `onchain_receive` the swap is `refunded` only once the trader's own L1 half is.
4443
+ refunded: (kind) => kind === "onchain_receive" ? "refunded" : "lapsed",
4210
4444
  failed: at("failed")
4211
4445
  }
4212
4446
  };
@@ -4234,7 +4468,8 @@ var ACTIVITY_TOKEN = {
4234
4468
  var LABELS = {
4235
4469
  lightning_send: "Lightning send",
4236
4470
  lightning_receive: "Lightning receive",
4237
- onchain_send: "Onchain send"
4471
+ onchain_send: "Onchain send",
4472
+ onchain_receive: "Onchain receive"
4238
4473
  };
4239
4474
  var outcomeToken = (kind, state) => ACTIVITY_TOKEN[corridorOutcome(kind, state)];
4240
4475
  function swapActivityResolver(deps) {
@@ -4298,7 +4533,7 @@ async function activityInputOf(stored, indexer) {
4298
4533
  async function lockupTxids(indexer, record, wantFunding) {
4299
4534
  let script;
4300
4535
  try {
4301
- script = import_base11.hex.encode(import_sdk13.ArkAddress.decode(record.lockupAddress).pkScript);
4536
+ script = import_base11.hex.encode(import_sdk14.ArkAddress.decode(record.lockupAddress).pkScript);
4302
4537
  } catch {
4303
4538
  return [];
4304
4539
  }
@@ -4387,7 +4622,7 @@ var chainSourceFrom = (provider, network) => {
4387
4622
  };
4388
4623
 
4389
4624
  // src/claim.ts
4390
- var import_sdk14 = require("@arkade-os/sdk");
4625
+ var import_sdk15 = require("@arkade-os/sdk");
4391
4626
  var LockupAmountMismatchError = class extends Error {
4392
4627
  name = "LockupAmountMismatchError";
4393
4628
  reason = "amount_mismatch";
@@ -4419,8 +4654,8 @@ async function pushClaim(operator, input) {
4419
4654
  assertPreimageMatches(input.preimage, input.contract.options.preimageHash);
4420
4655
  const serverUnrollScript = await operatorUnrollScript(operator, input.network);
4421
4656
  const leaf = input.contract.claim();
4422
- const txid = await (0, import_sdk14.signAndSubmitOffchainTx)({
4423
- identity: (0, import_sdk14.claimWithPreimageIdentity)(input.receiver, input.preimage),
4657
+ const txid = await (0, import_sdk15.signAndSubmitOffchainTx)({
4658
+ identity: (0, import_sdk15.claimWithPreimageIdentity)(input.receiver, input.preimage),
4424
4659
  provider: operator,
4425
4660
  inputs: lockupInputs(input.vtxos, input.contract, leaf),
4426
4661
  // One aggregate output: this leaf inspects nothing about the output set.
@@ -4449,7 +4684,7 @@ async function claimReceiveLockup(contracts, operator, input) {
4449
4684
 
4450
4685
  // src/markets.ts
4451
4686
  var import_solver_discovery2 = require("@arkade-os/solver-discovery");
4452
- var import_sdk15 = require("@arkade-os/sdk");
4687
+ var import_sdk16 = require("@arkade-os/sdk");
4453
4688
 
4454
4689
  // src/marketShape.ts
4455
4690
  var MARKET_CORRIDORS = ["arkade", "bolt11", "bitcoin", "eip155"];
@@ -4483,6 +4718,7 @@ var marketCorridor = (market, side) => {
4483
4718
  // src/markets.ts
4484
4719
  var QUOTE_OPTIONS = { safetyBps: 0 };
4485
4720
  var makeCachedFeedFetch = (ttlMs = 3e4, fetchImpl = fetch) => {
4721
+ (0, import_sdk16.assertNonNegativeMs)("ttlMs", ttlMs);
4486
4722
  const cache = /* @__PURE__ */ new Map();
4487
4723
  const inflight = /* @__PURE__ */ new Map();
4488
4724
  return async (input, init) => {
@@ -4625,17 +4861,17 @@ var validatePlan = (plan, giveBalance, dust) => {
4625
4861
  const receiveIsBtc = plan.receive.asset.id === BTC_ASSET_ID;
4626
4862
  if (depositIsBtc || receiveIsBtc) {
4627
4863
  const btcSide = depositIsBtc ? plan.deposit.atomic : plan.receive.atomic;
4628
- if ((0, import_sdk15.isSubdust)(btcSide, dust)) return "below-dust";
4864
+ if ((0, import_sdk16.isSubdust)(btcSide, dust)) return "below-dust";
4629
4865
  }
4630
4866
  return void 0;
4631
4867
  };
4632
4868
 
4633
4869
  // src/payment/crossAsset.ts
4634
- var import_sdk16 = require("@arkade-os/sdk");
4870
+ var import_sdk17 = require("@arkade-os/sdk");
4635
4871
  var CROSS_ASSET_RAIL = "cross-asset";
4636
4872
  var parseAssetId = (assetId) => {
4637
4873
  try {
4638
- return import_sdk16.asset.AssetId.fromString(assetId);
4874
+ return import_sdk17.asset.AssetId.fromString(assetId);
4639
4875
  } catch {
4640
4876
  return void 0;
4641
4877
  }
@@ -4653,9 +4889,9 @@ function crossAssetRail(deps) {
4653
4889
  };
4654
4890
  return {
4655
4891
  id: CROSS_ASSET_RAIL,
4656
- match: (req) => (0, import_sdk16.arkTarget)(req.raw) !== void 0,
4892
+ match: (req) => (0, import_sdk17.arkTarget)(req.raw) !== void 0,
4657
4893
  available: async (req) => {
4658
- const assets = (0, import_sdk16.assetsOf)(req);
4894
+ const assets = (0, import_sdk17.assetsOf)(req);
4659
4895
  if (assets.length !== 1) return false;
4660
4896
  const [asset3] = assets;
4661
4897
  if (asset3.assetId === BTC_ASSET_ID) return false;
@@ -4665,8 +4901,8 @@ function crossAssetRail(deps) {
4665
4901
  return planned !== void 0 && planned.error === void 0;
4666
4902
  },
4667
4903
  quote: async (req, ctx) => {
4668
- const payTo = (0, import_sdk16.arkTarget)(req.raw);
4669
- const asset3 = (0, import_sdk16.resolveAssetAmount)(CROSS_ASSET_RAIL, req);
4904
+ const payTo = (0, import_sdk17.arkTarget)(req.raw);
4905
+ const asset3 = (0, import_sdk17.resolveAssetAmount)(CROSS_ASSET_RAIL, req);
4670
4906
  const wantAsset = parseAssetId(asset3.assetId);
4671
4907
  if (!wantAsset) {
4672
4908
  throw new Error(
@@ -4689,7 +4925,7 @@ function crossAssetRail(deps) {
4689
4925
  );
4690
4926
  }
4691
4927
  const depositSats = Number(plan.deposit.atomic);
4692
- const carrier = deps.carrierSats ?? import_sdk16.ASSET_CARRIER_SATS;
4928
+ const carrier = deps.carrierSats ?? import_sdk17.ASSET_CARRIER_SATS;
4693
4929
  return {
4694
4930
  railId: CROSS_ASSET_RAIL,
4695
4931
  // OPEN QUESTION for review: `total = amount + fee` forces the
@@ -4707,7 +4943,7 @@ function crossAssetRail(deps) {
4707
4943
  priceDisplay: plan.priceDisplay,
4708
4944
  give: plan.give
4709
4945
  },
4710
- send: async () => (0, import_sdk16.makeHandle)(CROSS_ASSET_RAIL, async (emit) => {
4946
+ send: async () => (0, import_sdk17.makeHandle)(CROSS_ASSET_RAIL, async (emit) => {
4711
4947
  const offer = await createOffer(ctx.wallet, {
4712
4948
  wantAmount: asset3.amount,
4713
4949
  wantAsset,
@@ -4791,10 +5027,10 @@ var solverRendezvous = (markets, payoutCorridor, amountSats, fallbackEmulatorPub
4791
5027
  };
4792
5028
 
4793
5029
  // src/payment/solverLightning.ts
4794
- var import_sdk18 = require("@arkade-os/sdk");
5030
+ var import_sdk19 = require("@arkade-os/sdk");
4795
5031
 
4796
5032
  // src/payment/solverOnchain.ts
4797
- var import_sdk17 = require("@arkade-os/sdk");
5033
+ var import_sdk18 = require("@arkade-os/sdk");
4798
5034
  var SOLVER_ONCHAIN_RAIL = "solver-onchain";
4799
5035
  var solverOnchainRendezvous = (markets, amountSats, fallbackEmulatorPubkey) => solverRendezvous(markets, "onchain", amountSats, fallbackEmulatorPubkey);
4800
5036
  async function fundSolverSend(railId, ctx, emit, deps, swap, settledFields) {
@@ -4821,24 +5057,24 @@ function solverOnchainRail(deps) {
4821
5057
  const rendezvousFor = async (amount) => solverOnchainRendezvous(await deps.discover(), amount, deps.fallbackEmulatorPubkey);
4822
5058
  return {
4823
5059
  id: SOLVER_ONCHAIN_RAIL,
4824
- match: (req) => (0, import_sdk17.btcTarget)(req.raw) !== void 0,
5060
+ match: (req) => (0, import_sdk18.btcTarget)(req.raw) !== void 0,
4825
5061
  available: async (req) => {
4826
- if ((0, import_sdk17.assetsOf)(req).length > 0) return false;
4827
- const address = (0, import_sdk17.btcTarget)(req.raw);
5062
+ if ((0, import_sdk18.assetsOf)(req).length > 0) return false;
5063
+ const address = (0, import_sdk18.btcTarget)(req.raw);
4828
5064
  if (!address) return false;
4829
5065
  try {
4830
5066
  l1ScriptForAddress(address, deps.l1Network);
4831
5067
  } catch {
4832
5068
  return false;
4833
5069
  }
4834
- const amount = (0, import_sdk17.tryResolveSendAmount)(req.raw, req.amount);
5070
+ const amount = (0, import_sdk18.tryResolveSendAmount)(req.raw, req.amount);
4835
5071
  if (amount === void 0) return false;
4836
5072
  return await rendezvousFor(amount) !== void 0;
4837
5073
  },
4838
5074
  quote: async (req, ctx) => {
4839
- const address = (0, import_sdk17.btcTarget)(req.raw);
4840
- (0, import_sdk17.assertNoAssets)(SOLVER_ONCHAIN_RAIL, req);
4841
- const amount = (0, import_sdk17.resolveSendAmount)(SOLVER_ONCHAIN_RAIL, req.raw, req.amount);
5075
+ const address = (0, import_sdk18.btcTarget)(req.raw);
5076
+ (0, import_sdk18.assertNoAssets)(SOLVER_ONCHAIN_RAIL, req);
5077
+ const amount = (0, import_sdk18.resolveSendAmount)(SOLVER_ONCHAIN_RAIL, req.raw, req.amount);
4842
5078
  const payoutPkScript = l1ScriptForAddress(address, deps.l1Network);
4843
5079
  const rendezvous = await rendezvousFor(amount);
4844
5080
  if (!rendezvous) {
@@ -4877,7 +5113,7 @@ function solverOnchainRail(deps) {
4877
5113
  // not knowable now, so `amount` is the payout, not the net.
4878
5114
  claimFeeDeductedFromPayout: true
4879
5115
  },
4880
- send: async () => (0, import_sdk17.makeHandle)(SOLVER_ONCHAIN_RAIL, async (emit) => {
5116
+ send: async () => (0, import_sdk18.makeHandle)(SOLVER_ONCHAIN_RAIL, async (emit) => {
4881
5117
  assertFundable({
4882
5118
  quote: swap.quote,
4883
5119
  now: Math.floor(Date.now() / 1e3),
@@ -4904,7 +5140,7 @@ function solverOnchainRail(deps) {
4904
5140
  // src/payment/solverLightning.ts
4905
5141
  var SOLVER_LIGHTNING_RAIL = "solver-lightning";
4906
5142
  var factsOf = (raw, decode, now) => {
4907
- const invoice = (0, import_sdk18.invoiceTarget)(raw);
5143
+ const invoice = (0, import_sdk19.invoiceTarget)(raw);
4908
5144
  if (!invoice) return void 0;
4909
5145
  let facts;
4910
5146
  try {
@@ -4916,22 +5152,22 @@ var factsOf = (raw, decode, now) => {
4916
5152
  if (facts.expiresAt <= now) return void 0;
4917
5153
  return facts;
4918
5154
  };
4919
- var contradicts = (req, facts) => req.amount !== void 0 && req.amount !== facts.amountSats && req.amount !== import_sdk18.BIP21.amountSats(req.raw);
5155
+ var contradicts = (req, facts) => req.amount !== void 0 && req.amount !== facts.amountSats && req.amount !== import_sdk19.BIP21.amountSats(req.raw);
4920
5156
  var solverLightningRendezvous = (markets, amountSats, fallbackEmulatorPubkey) => solverRendezvous(markets, "lightning", amountSats, fallbackEmulatorPubkey);
4921
5157
  function solverLightningRail(deps) {
4922
5158
  const rendezvousFor = async (amountSats) => solverLightningRendezvous(await deps.discover(), amountSats, deps.fallbackEmulatorPubkey);
4923
5159
  return {
4924
5160
  id: SOLVER_LIGHTNING_RAIL,
4925
- match: (req) => (0, import_sdk18.invoiceTarget)(req.raw) !== void 0,
5161
+ match: (req) => (0, import_sdk19.invoiceTarget)(req.raw) !== void 0,
4926
5162
  available: async (req) => {
4927
- if ((0, import_sdk18.assetsOf)(req).length > 0) return false;
5163
+ if ((0, import_sdk19.assetsOf)(req).length > 0) return false;
4928
5164
  const facts = factsOf(req.raw, deps.decodeInvoice, Math.floor(Date.now() / 1e3));
4929
5165
  if (!facts) return false;
4930
5166
  if (contradicts(req, facts)) return false;
4931
5167
  return await rendezvousFor(facts.amountSats) !== void 0;
4932
5168
  },
4933
5169
  quote: async (req, ctx) => {
4934
- (0, import_sdk18.assertNoAssets)(SOLVER_LIGHTNING_RAIL, req);
5170
+ (0, import_sdk19.assertNoAssets)(SOLVER_LIGHTNING_RAIL, req);
4935
5171
  const facts = factsOf(req.raw, deps.decodeInvoice, Math.floor(Date.now() / 1e3));
4936
5172
  if (!facts) {
4937
5173
  throw new Error(
@@ -4974,7 +5210,7 @@ function solverLightningRail(deps) {
4974
5210
  invoiceExpiresAt: facts.expiresAt,
4975
5211
  solverPubkey: rendezvous.solverPubkey
4976
5212
  },
4977
- send: async () => (0, import_sdk18.makeHandle)(SOLVER_LIGHTNING_RAIL, async (emit) => {
5213
+ send: async () => (0, import_sdk19.makeHandle)(SOLVER_LIGHTNING_RAIL, async (emit) => {
4978
5214
  assertFundable({
4979
5215
  quote: swap.quote,
4980
5216
  invoiceExpiresAt: facts.expiresAt,
@@ -4996,7 +5232,7 @@ function solverLightningRail(deps) {
4996
5232
 
4997
5233
  // src/restore.ts
4998
5234
  var import_base14 = require("@scure/base");
4999
- var import_sdk19 = require("@arkade-os/sdk");
5235
+ var import_sdk20 = require("@arkade-os/sdk");
5000
5236
  var TXS_PER_REQUEST = 50;
5001
5237
  async function fetchParsedTxs(indexer, txids) {
5002
5238
  const parsedByTxid = /* @__PURE__ */ new Map();
@@ -5012,7 +5248,7 @@ async function fetchParsedTxs(indexer, txids) {
5012
5248
  if (result.status !== "fulfilled") continue;
5013
5249
  for (const psbt of result.value) {
5014
5250
  try {
5015
- const parsed = import_sdk19.Transaction.fromPSBT(import_base14.base64.decode(psbt));
5251
+ const parsed = import_sdk20.Transaction.fromPSBT(import_base14.base64.decode(psbt));
5016
5252
  parsedByTxid.set(parsed.id, parsed);
5017
5253
  } catch {
5018
5254
  }
@@ -5041,7 +5277,7 @@ function classifySpend(offer, operatorPubkey, spendTx, deposit) {
5041
5277
  if (!input.txid || input.index !== deposit.vout) continue;
5042
5278
  if (import_base14.hex.encode(input.txid) !== deposit.txid) continue;
5043
5279
  for (const leaf of input.tapLeafScript ?? []) {
5044
- const spent = import_base14.hex.encode((0, import_sdk19.scriptFromTapLeafScript)(leaf));
5280
+ const spent = import_base14.hex.encode((0, import_sdk20.scriptFromTapLeafScript)(leaf));
5045
5281
  if (leaves.returned.some((back) => spent === import_base14.hex.encode(back))) return "cancelled";
5046
5282
  if (leaves.fulfill && spent === import_base14.hex.encode(leaves.fulfill)) return "fulfilled";
5047
5283
  }
@@ -5095,7 +5331,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
5095
5331
  if (!fundingTx) continue;
5096
5332
  fetchedTxids.push(txid);
5097
5333
  try {
5098
- const packet = import_sdk19.Extension.fromTx(parsed).getPacketByType(OFFER_PACKET_TYPE);
5334
+ const packet = import_sdk20.Extension.fromTx(parsed).getPacketByType(OFFER_PACKET_TYPE);
5099
5335
  if (!packet) continue;
5100
5336
  const payload = packet.serialize();
5101
5337
  found.push({
@@ -5207,7 +5443,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
5207
5443
 
5208
5444
  // src/watch.ts
5209
5445
  var import_base15 = require("@scure/base");
5210
- var import_sdk20 = require("@arkade-os/sdk");
5446
+ var import_sdk21 = require("@arkade-os/sdk");
5211
5447
  var TERMINAL = ["fulfilled", "cancelled", "recoverable"];
5212
5448
  var assetSwapSource = (repository) => ({
5213
5449
  list: () => getAssetSwaps(repository),
@@ -5239,7 +5475,7 @@ async function watchOfferSwaps({
5239
5475
  wallet.getAddress(),
5240
5476
  wallet.getArkadeReader()
5241
5477
  ]);
5242
- const operatorPubkey = import_sdk20.ArkAddress.decode(address).serverPubKey;
5478
+ const operatorPubkey = import_sdk21.ArkAddress.decode(address).serverPubKey;
5243
5479
  let queue = Promise.resolve();
5244
5480
  const enqueue = (task) => {
5245
5481
  queue = queue.then(task).catch(() => {
@@ -5254,7 +5490,7 @@ async function watchOfferSwaps({
5254
5490
  return classifyDepositSpend(
5255
5491
  decodeOffer(import_base15.hex.decode(swap.offerHex)),
5256
5492
  operatorPubkey,
5257
- txs.map((psbt) => import_sdk20.Transaction.fromPSBT(import_base15.base64.decode(psbt))),
5493
+ txs.map((psbt) => import_sdk21.Transaction.fromPSBT(import_base15.base64.decode(psbt))),
5258
5494
  { txid: vtxo.txid, vout: vtxo.vout }
5259
5495
  );
5260
5496
  } catch {
@@ -5282,7 +5518,7 @@ async function watchOfferSwaps({
5282
5518
  }
5283
5519
  };
5284
5520
  const unsubscribe = manager.onContractEvent((event) => {
5285
- if (!(0, import_sdk20.isContractVtxoEvent)(event) || event.type !== "vtxo_spent") return;
5521
+ if (!(0, import_sdk21.isContractVtxoEvent)(event) || event.type !== "vtxo_spent") return;
5286
5522
  enqueue(() => handleSpend(event));
5287
5523
  });
5288
5524
  return {
@@ -5315,6 +5551,7 @@ async function watchOfferSwaps({
5315
5551
  ONCHAIN_SECONDS_PER_BLOCK,
5316
5552
  ONCHAIN_SEND_PAIR,
5317
5553
  OfferCovenantMismatchError,
5554
+ OnchainReceiveNeedsChainSource,
5318
5555
  PreimageNotRecoverableError,
5319
5556
  QUOTE_OPTIONS,
5320
5557
  RFQ_SWAP_RETENTION_SECONDS,
@@ -5369,11 +5606,13 @@ async function watchOfferSwaps({
5369
5606
  makeCachedFeedFetch,
5370
5607
  newPreimage,
5371
5608
  nextOnchainAction,
5609
+ nextOnchainReceiveAction,
5372
5610
  normalizeMakerPkScript,
5373
5611
  normalizeMakerPublicKey,
5374
5612
  normalizeRfqSwapRecord,
5375
5613
  offerContract,
5376
5614
  onchainHtlcScript,
5615
+ onchainReceiveProfile,
5377
5616
  onchainReceiveRequest,
5378
5617
  onchainSendProfile,
5379
5618
  onchainSendRequest,