@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/index.cjs CHANGED
@@ -244,7 +244,7 @@ async function classifyOnchainHtlc(chain, input) {
244
244
  if (mtp >= input.htlc.refundLocktime) return { phase: "refundable", utxo: best };
245
245
  return { phase: "claimable", utxo: best };
246
246
  }
247
- var import_base, import_sha2, import_legacy, btc, ONCHAIN_ORDER_MARGIN_SECONDS, ONCHAIN_CLAIM_MARGIN_SECONDS, MAX_MIN_CONFIRMATIONS, LOCKTIME_THRESHOLD, ONCHAIN_SECONDS_PER_BLOCK, ONCHAIN_DUST_SATS, ONCHAIN_CLAIM_VSIZE, paymentHashOf, h160FromPaymentHash, assertPreimageMatches, gateError, L1_NETWORKS, l1ScriptForAddress, buildLeafSpend, buildHtlcClaim;
247
+ var import_base, import_sha2, import_legacy, btc, import_sdk2, ONCHAIN_ORDER_MARGIN_SECONDS, ONCHAIN_CLAIM_MARGIN_SECONDS, MAX_MIN_CONFIRMATIONS, LOCKTIME_THRESHOLD, ONCHAIN_SECONDS_PER_BLOCK, ONCHAIN_DUST_SATS, ONCHAIN_CLAIM_VSIZE, paymentHashOf, h160FromPaymentHash, assertPreimageMatches, gateError, L1_NETWORKS, l1ScriptForAddress, buildLeafSpend, buildHtlcClaim, buildHtlcRefund;
248
248
  var init_onchainHtlc = __esm({
249
249
  "src/onchainHtlc.ts"() {
250
250
  "use strict";
@@ -252,6 +252,7 @@ var init_onchainHtlc = __esm({
252
252
  import_sha2 = require("@noble/hashes/sha2.js");
253
253
  import_legacy = require("@noble/hashes/legacy.js");
254
254
  btc = __toESM(require("@scure/btc-signer"), 1);
255
+ import_sdk2 = require("@arkade-os/sdk");
255
256
  ONCHAIN_ORDER_MARGIN_SECONDS = 2 * 60 * 60;
256
257
  ONCHAIN_CLAIM_MARGIN_SECONDS = 90 * 60;
257
258
  MAX_MIN_CONFIRMATIONS = 6;
@@ -339,6 +340,19 @@ var init_onchainHtlc = __esm({
339
340
  sequence: 4294967293
340
341
  });
341
342
  };
343
+ buildHtlcRefund = (input) => buildLeafSpend({
344
+ htlc: input.htlc,
345
+ utxo: input.utxo,
346
+ leaf: input.htlc.leaves.refund,
347
+ controlBlock: input.htlc.controlBlocks.refund,
348
+ stackAboveSig: [],
349
+ payoutPkScript: input.payoutPkScript,
350
+ feeRateSatVb: input.feeRateSatVb,
351
+ sign: input.sign,
352
+ lockTime: input.htlc.refundLocktime,
353
+ // any value below 0xffffffff enables nLockTime enforcement
354
+ sequence: 4294967294
355
+ });
342
356
  }
343
357
  });
344
358
 
@@ -444,7 +458,7 @@ async function registerLockupContract(contracts, script, address) {
444
458
  try {
445
459
  await contracts.createContract({
446
460
  type: SWAP_LOCKUP_CONTRACT_TYPE,
447
- params: import_sdk2.VHTLCV2ContractHandler.serializeParams(script.options),
461
+ params: import_sdk3.VHTLCV2ContractHandler.serializeParams(script.options),
448
462
  script: import_base3.hex.encode(script.pkScript),
449
463
  address,
450
464
  label: SWAP_LOCKUP_CONTRACT_LABEL,
@@ -455,17 +469,17 @@ async function registerLockupContract(contracts, script, address) {
455
469
  }
456
470
  }
457
471
  async function lockupContractParams(contracts, lockupAddress) {
458
- const script = import_base3.hex.encode(import_sdk2.ArkAddress.decode(lockupAddress).pkScript);
472
+ const script = import_base3.hex.encode(import_sdk3.ArkAddress.decode(lockupAddress).pkScript);
459
473
  const [row] = await contracts.getContracts({ script });
460
474
  if (!row) throw new LockupContractMissing(lockupAddress, script);
461
475
  return row.params;
462
476
  }
463
- var import_base3, import_sdk2, SWAP_LOCKUP_CONTRACT_TYPE, SWAP_LOCKUP_CONTRACT_LABEL, SWAP_LOCKUP_CONTRACT_KIND, LockupContractMissing, LockupRegistrationFailed;
477
+ var import_base3, import_sdk3, SWAP_LOCKUP_CONTRACT_TYPE, SWAP_LOCKUP_CONTRACT_LABEL, SWAP_LOCKUP_CONTRACT_KIND, LockupContractMissing, LockupRegistrationFailed;
464
478
  var init_lockupContract = __esm({
465
479
  "src/lockupContract.ts"() {
466
480
  "use strict";
467
481
  import_base3 = require("@scure/base");
468
- import_sdk2 = require("@arkade-os/sdk");
482
+ import_sdk3 = require("@arkade-os/sdk");
469
483
  SWAP_LOCKUP_CONTRACT_TYPE = "vhtlc-v2";
470
484
  SWAP_LOCKUP_CONTRACT_LABEL = "Arkade RFQ swap lockup";
471
485
  SWAP_LOCKUP_CONTRACT_KIND = "rfq-swap-lockup";
@@ -645,13 +659,13 @@ var init_coverage = __esm({
645
659
  });
646
660
 
647
661
  // src/store.ts
648
- var import_base4, import_sha23, import_sdk3, BTC_ASSET_ID, byNewest, getAssetSwapsOrThrow, getAssetSwaps, saveSwapOrThrow, updateAssetSwap, updateAssetSwapBestEffort, swapSecretsToRecord, decodeHex32, PreimageNotRecoverableError, preimageForSwapRecord;
662
+ var import_base4, import_sha23, import_sdk4, BTC_ASSET_ID, byNewest, getAssetSwapsOrThrow, getAssetSwaps, saveSwapOrThrow, updateAssetSwap, updateAssetSwapBestEffort, swapSecretsToRecord, decodeHex32, PreimageNotRecoverableError, preimageForSwapRecord;
649
663
  var init_store = __esm({
650
664
  "src/store.ts"() {
651
665
  "use strict";
652
666
  import_base4 = require("@scure/base");
653
667
  import_sha23 = require("@noble/hashes/sha2.js");
654
- import_sdk3 = require("@arkade-os/sdk");
668
+ import_sdk4 = require("@arkade-os/sdk");
655
669
  init_repository();
656
670
  BTC_ASSET_ID = "btc";
657
671
  byNewest = (a, b) => b.createdAt - a.createdAt;
@@ -737,7 +751,7 @@ var init_store = __esm({
737
751
  }
738
752
  let preimage;
739
753
  try {
740
- preimage = await (0, import_sdk3.contractPreimage)(wallet, record.signingDescriptor, { stored, salt });
754
+ preimage = await (0, import_sdk4.contractPreimage)(wallet, record.signingDescriptor, { stored, salt });
741
755
  } catch (cause) {
742
756
  throw new PreimageNotRecoverableError(
743
757
  "not-derivable",
@@ -802,7 +816,7 @@ function swapProgramBinding(offer, operatorPubkey) {
802
816
  }
803
817
  function offerContract(offer, operatorPubkey) {
804
818
  const { program, args, keys } = swapProgramBinding(offer, operatorPubkey);
805
- return new import_sdk4.arkade.ArkadeProgramScript(program, args, keys);
819
+ return new import_sdk5.arkade.ArkadeProgramScript(program, args, keys);
806
820
  }
807
821
  function u64(name, value) {
808
822
  if (value < BigInt(0) || value >> BigInt(64) > BigInt(0)) {
@@ -918,8 +932,8 @@ function decodeOffer(data) {
918
932
  return {
919
933
  swapPkScript: need("swapPkScript"),
920
934
  wantAmount: readU64(amount),
921
- ...fields.wantAsset && { wantAsset: import_sdk4.asset.AssetId.fromBytes(fields.wantAsset) },
922
- ...fields.offerAsset && { offerAsset: import_sdk4.asset.AssetId.fromBytes(fields.offerAsset) },
935
+ ...fields.wantAsset && { wantAsset: import_sdk5.asset.AssetId.fromBytes(fields.wantAsset) },
936
+ ...fields.offerAsset && { offerAsset: import_sdk5.asset.AssetId.fromBytes(fields.offerAsset) },
923
937
  makerPkScript: need("makerPkScript"),
924
938
  makerPublicKey: need("makerPublicKey"),
925
939
  emulatorPubkey: need("emulatorPubkey"),
@@ -943,7 +957,7 @@ async function registerOfferContract(wallet, info, binding, operatorPubkey, expe
943
957
  }
944
958
  function offerContractParams(client, binding, operatorPubkey, expectedPkScript) {
945
959
  const { program, args, keys } = swapProgramBinding(binding, operatorPubkey);
946
- const contract = new import_sdk4.arkade.ArkadeContract(client, program, args, keys);
960
+ const contract = new import_sdk5.arkade.ArkadeContract(client, program, args, keys);
947
961
  if (import_base5.hex.encode(contract.pkScript) !== import_base5.hex.encode(expectedPkScript)) {
948
962
  throw new Error("derived covenant does not match the offer's swapPkScript");
949
963
  }
@@ -960,7 +974,7 @@ async function restoreOfferCoverage(wallet, swaps) {
960
974
  wallet.getArkadeInfo({ requireLive: true }),
961
975
  wallet.getContractManager()
962
976
  ]);
963
- const operatorPubkey = import_base5.hex.decode((0, import_sdk4.toXOnlySignerHex)(info.signerPubkey));
977
+ const operatorPubkey = import_base5.hex.decode((0, import_sdk5.toXOnlySignerHex)(info.signerPubkey));
964
978
  const client = await derivingClient(wallet, info, contractManager);
965
979
  const seen = /* @__PURE__ */ new Set();
966
980
  const covenants = [];
@@ -1027,13 +1041,13 @@ async function deriveOffer(wallet, params) {
1027
1041
  wallet.getAddress(),
1028
1042
  wallet.identity.xOnlyPublicKey()
1029
1043
  ]);
1030
- return { pkScript: import_sdk4.ArkAddress.decode(address).pkScript, publicKey };
1044
+ return { pkScript: import_sdk5.ArkAddress.decode(address).pkScript, publicKey };
1031
1045
  })()
1032
1046
  ]);
1033
- const operatorPubKey = import_base5.hex.decode((0, import_sdk4.toXOnlySignerHex)(info.signerPubkey));
1034
- const network = (0, import_sdk4.networkFromArkadeInfo)(info);
1047
+ const operatorPubKey = import_base5.hex.decode((0, import_sdk5.toXOnlySignerHex)(info.signerPubkey));
1048
+ const network = (0, import_sdk5.networkFromArkadeInfo)(info);
1035
1049
  const emuKey = import_base5.hex.decode(
1036
- (0, import_sdk4.toXOnlySignerHex)((0, import_sdk4.resolveEmulatorPubkey)(network, params.emulatorPubkey))
1050
+ (0, import_sdk5.toXOnlySignerHex)((0, import_sdk5.resolveEmulatorPubkey)(network, params.emulatorPubkey))
1037
1051
  );
1038
1052
  const binding = Object.freeze({
1039
1053
  wantAmount: params.wantAmount,
@@ -1078,7 +1092,7 @@ async function prepareOfferCancel(wallet, offerHex, opts) {
1078
1092
  wallet.getArkadeReader(),
1079
1093
  wallet.getArkadeBroadcaster()
1080
1094
  ]);
1081
- const client = await import_sdk4.arkade.Arkade.connect({
1095
+ const client = await import_sdk5.arkade.Arkade.connect({
1082
1096
  arkade: { getInfo: async () => info, ...broadcaster },
1083
1097
  indexer: reader,
1084
1098
  identity: wallet.identity,
@@ -1087,18 +1101,18 @@ async function prepareOfferCancel(wallet, offerHex, opts) {
1087
1101
  contractManager
1088
1102
  // no `network`: the row lookup is by script and the payout comes from wallet.getAddress()
1089
1103
  });
1090
- const operatorPubkey = swapAddress ? import_sdk4.ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
1104
+ const operatorPubkey = swapAddress ? import_sdk5.ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
1091
1105
  const { program, args, keys } = swapProgramBinding(offer, operatorPubkey);
1092
1106
  let rebuilt;
1093
1107
  try {
1094
- rebuilt = new import_sdk4.arkade.ArkadeProgramScript(program, args, keys);
1108
+ rebuilt = new import_sdk5.arkade.ArkadeProgramScript(program, args, keys);
1095
1109
  } catch (cause) {
1096
1110
  throw new OfferCovenantMismatchError(import_base5.hex.encode(offer.swapPkScript), { cause });
1097
1111
  }
1098
1112
  if (import_base5.hex.encode(rebuilt.pkScript) !== import_base5.hex.encode(offer.swapPkScript)) {
1099
1113
  throw new OfferCovenantMismatchError(import_base5.hex.encode(offer.swapPkScript));
1100
1114
  }
1101
- const contract = new import_sdk4.arkade.ArkadeContract(client, program, args, keys);
1115
+ const contract = new import_sdk5.arkade.ArkadeContract(client, program, args, keys);
1102
1116
  const [vtxos, makerAddress] = await Promise.all([contract.getUtxos(), wallet.getAddress()]);
1103
1117
  if (!fundingTxid && vtxos.length > 1) {
1104
1118
  throw new Error(
@@ -1107,7 +1121,7 @@ async function prepareOfferCancel(wallet, offerHex, opts) {
1107
1121
  }
1108
1122
  const vtxo = fundingTxid ? vtxos.find((v) => v.txid === fundingTxid) : vtxos[0];
1109
1123
  if (!vtxo) throw new NoSpendableDepositError();
1110
- const makerPkScript = import_sdk4.ArkAddress.decode(makerAddress).pkScript;
1124
+ const makerPkScript = import_sdk5.ArkAddress.decode(makerAddress).pkScript;
1111
1125
  const cancel = contract.functions.cancel().from({ txid: vtxo.txid, vout: vtxo.vout, value: vtxo.value }).to(makerPkScript, BigInt(vtxo.value));
1112
1126
  for (const a of vtxo.assets ?? []) {
1113
1127
  cancel.withAsset({
@@ -1122,20 +1136,20 @@ async function prepareOfferCancel(wallet, offerHex, opts) {
1122
1136
  send: async () => (await cancel.send()).txid
1123
1137
  };
1124
1138
  }
1125
- var import_base5, import_utils2, import_sdk4, swapPrograms, OFFER_PACKET_TYPE, FIELDS, EXIT_TYPES, NAMES, readU64, setRatio, OFFER_CONTRACT_LABEL, OFFER_CONTRACT_KIND, derivingClient, NoSpendableDepositError, OfferCovenantMismatchError, ASSET_CARRIER_SATS;
1139
+ var import_base5, import_utils2, import_sdk5, swapPrograms, OFFER_PACKET_TYPE, FIELDS, EXIT_TYPES, NAMES, readU64, setRatio, OFFER_CONTRACT_LABEL, OFFER_CONTRACT_KIND, derivingClient, NoSpendableDepositError, OfferCovenantMismatchError, ASSET_CARRIER_SATS;
1126
1140
  var init_offer = __esm({
1127
1141
  "src/offer.ts"() {
1128
1142
  "use strict";
1129
1143
  import_base5 = require("@scure/base");
1130
1144
  import_utils2 = require("@scure/btc-signer/utils.js");
1131
- import_sdk4 = require("@arkade-os/sdk");
1145
+ import_sdk5 = require("@arkade-os/sdk");
1132
1146
  init_swap_want_asset_program();
1133
1147
  init_swap_want_btc_program();
1134
1148
  init_coverage();
1135
1149
  init_store();
1136
1150
  swapPrograms = {
1137
- wantAsset: import_sdk4.arkade.parseArtifact(swap_want_asset_program_default),
1138
- wantBtc: import_sdk4.arkade.parseArtifact(swap_want_btc_program_default)
1151
+ wantAsset: import_sdk5.arkade.parseArtifact(swap_want_asset_program_default),
1152
+ wantBtc: import_sdk5.arkade.parseArtifact(swap_want_btc_program_default)
1139
1153
  };
1140
1154
  OFFER_PACKET_TYPE = 3;
1141
1155
  FIELDS = {
@@ -1160,10 +1174,10 @@ var init_offer = __esm({
1160
1174
  };
1161
1175
  OFFER_CONTRACT_LABEL = "Arkade swap offer";
1162
1176
  OFFER_CONTRACT_KIND = "asset-swap-offer";
1163
- derivingClient = (wallet, info, contractManager) => import_sdk4.arkade.Arkade.connect({
1177
+ derivingClient = (wallet, info, contractManager) => import_sdk5.arkade.Arkade.connect({
1164
1178
  arkade: { getInfo: async () => info },
1165
1179
  identity: wallet.identity,
1166
- network: (0, import_sdk4.networkFromArkadeInfo)(info),
1180
+ network: (0, import_sdk5.networkFromArkadeInfo)(info),
1167
1181
  contractManager
1168
1182
  });
1169
1183
  NoSpendableDepositError = class extends Error {
@@ -1183,7 +1197,7 @@ var init_offer = __esm({
1183
1197
  swapPkScript;
1184
1198
  name = "OfferCovenantMismatchError";
1185
1199
  };
1186
- ASSET_CARRIER_SATS = BigInt(import_sdk4.ASSET_CARRIER_SATS);
1200
+ ASSET_CARRIER_SATS = BigInt(import_sdk5.ASSET_CARRIER_SATS);
1187
1201
  }
1188
1202
  });
1189
1203
 
@@ -1217,7 +1231,7 @@ function deriveLightningSend(input) {
1217
1231
  throw new Error("lightning-send quote is missing profile.receiver_pk_script");
1218
1232
  }
1219
1233
  const contractParams = {
1220
- solverPubkey: (0, import_sdk5.toXOnly)(import_base6.hex.decode(quote.solver_pubkey), "solver key"),
1234
+ solverPubkey: (0, import_sdk6.toXOnly)(import_base6.hex.decode(quote.solver_pubkey), "solver key"),
1221
1235
  refundLocktime: quote.refund_locktime,
1222
1236
  operatorPubkey: input.operatorPubkey,
1223
1237
  paymentHash: input.paymentHash,
@@ -1258,7 +1272,7 @@ function deriveOnchainSend(input) {
1258
1272
  throw new Error("onchain-send quote is missing a binding field");
1259
1273
  }
1260
1274
  const contractParams = {
1261
- solverPubkey: (0, import_sdk5.toXOnly)(import_base6.hex.decode(quote.solver_pubkey), "solver key"),
1275
+ solverPubkey: (0, import_sdk6.toXOnly)(import_base6.hex.decode(quote.solver_pubkey), "solver key"),
1262
1276
  refundLocktime,
1263
1277
  operatorPubkey: input.operatorPubkey,
1264
1278
  paymentHash: input.paymentHash,
@@ -1266,7 +1280,7 @@ function deriveOnchainSend(input) {
1266
1280
  emulatorPubkey: input.emulatorPubkey,
1267
1281
  senderPubkey: input.senderPubkey,
1268
1282
  receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
1269
- refundPkScript: import_sdk5.ArkAddress.decode(input.refundAddress).pkScript
1283
+ refundPkScript: import_sdk6.ArkAddress.decode(input.refundAddress).pkScript
1270
1284
  };
1271
1285
  const { script, address } = matchQuotedLockup(
1272
1286
  quote,
@@ -1277,7 +1291,7 @@ function deriveOnchainSend(input) {
1277
1291
  const htlcParams = {
1278
1292
  paymentHash: input.paymentHash,
1279
1293
  claimKey: input.payoutPubkey,
1280
- refundKey: (0, import_sdk5.toXOnly)(import_base6.hex.decode(htlcPubkey), "solver L1 htlc key"),
1294
+ refundKey: (0, import_sdk6.toXOnly)(import_base6.hex.decode(htlcPubkey), "solver L1 htlc key"),
1281
1295
  refundLocktime: htlcLocktime
1282
1296
  };
1283
1297
  const htlc = onchainHtlcScript(htlcParams, input.l1Network);
@@ -1329,17 +1343,53 @@ function deriveLightningReceive(input) {
1329
1343
  }
1330
1344
  };
1331
1345
  }
1332
- var import_base6, import_solver_discovery, import_legacy2, import_sdk5, import_sdk6, solverHex, quoteSats, quoteAmountSats, quoteExpectedSats, ARKADE_BTC, LIGHTNING_BTC, ONCHAIN_BTC, arkadeAssetLeg, rfqPair, LIGHTNING_SEND_PAIR, LIGHTNING_RECEIVE_PAIR, ONCHAIN_SEND_PAIR, ONCHAIN_RECEIVE_PAIR, RFQ_REFUSAL_ERROR_CODES, isRfqRefusalErrorCode, REFUSAL_FIELDS, REFUSAL_UNITS, safeInteger, safeRefusalDetail, refusalMessage, SwapRefusal, AddressMismatch, newRfqId, lightningSendRequest, arkadeSwapRequest, canonicalAssetAmount, normalizeHexBytes, normalizeMakerPkScript, normalizeMakerPublicKey, MIN_HEADROOM_SECONDS, assertFinite, MAX_PAIR_LENGTH, assertPairLength, verifyLockupAddress, LOCKUP_SHAPE_VARIANTS, matchQuotedLockup, assertFundable, expectQuote, pairOf, SEQUENCE_GRANULARITY_SECONDS, SOLO_REFUND_HEADROOM_SECONDS, unilateralClaimDelay, unilateralRefundDelay, unilateralRefundWithoutReceiverDelay, seconds, suiteVhtlc, offerTermsFromQuote, verifyOfferAddress, quoteCarrierSats, l1NetworkFromArk, onchainSendRequest, lightningReceiveRequest, MIN_CLAIM_WINDOW_SECONDS, assertReceivable, matchReceiveLockup;
1346
+ function deriveOnchainReceive(input) {
1347
+ const { quote } = input;
1348
+ const profile = quote.profile ?? {};
1349
+ const refundLocktime = quote.refund_locktime;
1350
+ const claimPubkey = profile.claim_pubkey;
1351
+ const htlcLocktime = profile.htlc_locktime;
1352
+ const htlcAddress = profile.htlc_address;
1353
+ const minConfirmations = profile.min_confirmations;
1354
+ const solverRefundPkScriptHex = profile.solver_refund_pk_script;
1355
+ if (refundLocktime === void 0 || claimPubkey === void 0 || htlcLocktime === void 0 || minConfirmations === void 0 || solverRefundPkScriptHex === void 0) {
1356
+ throw new Error("onchain-receive quote is missing a binding field");
1357
+ }
1358
+ const { script, address } = matchReceiveLockup(
1359
+ input,
1360
+ refundLocktime,
1361
+ solverRefundPkScriptHex
1362
+ ).matched;
1363
+ const htlcParams = {
1364
+ paymentHash: input.paymentHash,
1365
+ claimKey: (0, import_sdk6.toXOnly)(import_base6.hex.decode(claimPubkey), "solver L1 claim key"),
1366
+ refundKey: input.refundPubkey,
1367
+ refundLocktime: htlcLocktime
1368
+ };
1369
+ const htlc = onchainHtlcScript(htlcParams, input.l1Network);
1370
+ if (htlc.address !== htlcAddress) throw new AddressMismatch(htlc.address, htlcAddress);
1371
+ return {
1372
+ address,
1373
+ swapPkScript: script.pkScript,
1374
+ script,
1375
+ htlc,
1376
+ htlcParams,
1377
+ refundLocktime,
1378
+ htlcLocktime,
1379
+ minConfirmations
1380
+ };
1381
+ }
1382
+ var import_base6, import_solver_discovery, import_legacy2, import_sdk6, import_sdk7, solverHex, quoteSats, quoteAmountSats, quoteExpectedSats, ARKADE_BTC, LIGHTNING_BTC, ONCHAIN_BTC, arkadeAssetLeg, rfqPair, LIGHTNING_SEND_PAIR, LIGHTNING_RECEIVE_PAIR, ONCHAIN_SEND_PAIR, ONCHAIN_RECEIVE_PAIR, RFQ_REFUSAL_ERROR_CODES, isRfqRefusalErrorCode, REFUSAL_FIELDS, REFUSAL_UNITS, safeInteger, safeRefusalDetail, refusalMessage, SwapRefusal, AddressMismatch, newRfqId, lightningSendRequest, arkadeSwapRequest, canonicalAssetAmount, normalizeHexBytes, normalizeMakerPkScript, normalizeMakerPublicKey, MIN_HEADROOM_SECONDS, assertFinite, MAX_PAIR_LENGTH, assertPairLength, verifyLockupAddress, LOCKUP_SHAPE_VARIANTS, matchQuotedLockup, assertFundable, expectQuote, pairOf, SEQUENCE_GRANULARITY_SECONDS, SOLO_REFUND_HEADROOM_SECONDS, unilateralClaimDelay, unilateralRefundDelay, unilateralRefundWithoutReceiverDelay, seconds, suiteVhtlc, offerTermsFromQuote, verifyOfferAddress, quoteCarrierSats, l1NetworkFromArk, onchainSendRequest, lightningReceiveRequest, onchainReceiveRequest, MIN_CLAIM_WINDOW_SECONDS, assertReceivable, matchReceiveLockup;
1333
1383
  var init_rfq = __esm({
1334
1384
  "src/rfq.ts"() {
1335
1385
  "use strict";
1336
1386
  import_base6 = require("@scure/base");
1337
1387
  import_solver_discovery = require("@arkade-os/solver-discovery");
1338
1388
  import_legacy2 = require("@noble/hashes/legacy.js");
1339
- import_sdk5 = require("@arkade-os/sdk");
1389
+ import_sdk6 = require("@arkade-os/sdk");
1340
1390
  init_onchainHtlc();
1341
1391
  init_onchainHtlc();
1342
- import_sdk6 = require("@arkade-os/sdk");
1392
+ import_sdk7 = require("@arkade-os/sdk");
1343
1393
  init_claimPacket();
1344
1394
  init_lockupContract();
1345
1395
  init_offer();
@@ -1580,6 +1630,12 @@ var init_rfq = __esm({
1580
1630
  const fail = (reason, message) => {
1581
1631
  throw gateError(reason, message);
1582
1632
  };
1633
+ if (input.quote.pair.split("->").some((leg) => leg.startsWith("ethereum:"))) {
1634
+ fail(
1635
+ "evm_funding_unavailable",
1636
+ "EVM funding is unavailable until local contract, finality, and deadline verification is implemented"
1637
+ );
1638
+ }
1583
1639
  if (input.quote.valid_until === void 0) {
1584
1640
  fail("quote_malformed", "quote carries no valid_until");
1585
1641
  }
@@ -1697,7 +1753,7 @@ var init_rfq = __esm({
1697
1753
  type: "seconds",
1698
1754
  value: BigInt(value)
1699
1755
  });
1700
- suiteVhtlc = (params, roles) => new import_sdk5.VHTLC.ScriptV2({
1756
+ suiteVhtlc = (params, roles) => new import_sdk6.VHTLC.ScriptV2({
1701
1757
  sender: roles.sender,
1702
1758
  receiver: roles.receiver,
1703
1759
  server: params.operatorPubkey,
@@ -1774,6 +1830,21 @@ var init_rfq = __esm({
1774
1830
  ...input.claimPacket === void 0 ? {} : { claim_packet: input.claimPacket }
1775
1831
  }
1776
1832
  });
1833
+ onchainReceiveRequest = (input) => ({
1834
+ v: 1,
1835
+ type: "rfq_request",
1836
+ rfq_id: input.rfqId,
1837
+ pair: ONCHAIN_RECEIVE_PAIR,
1838
+ amount_side: input.amountSide,
1839
+ amount: input.amount,
1840
+ profile: {
1841
+ payment_hash: input.paymentHash,
1842
+ ...input.claimPacket === void 0 ? {} : { claim_packet: input.claimPacket },
1843
+ refund_pubkey: import_base6.hex.encode(input.refundPubkey),
1844
+ payout_address: input.payoutAddress,
1845
+ payout_pubkey: import_base6.hex.encode(input.payoutPubkey)
1846
+ }
1847
+ });
1777
1848
  MIN_CLAIM_WINDOW_SECONDS = 30 * 60;
1778
1849
  assertReceivable = (input) => {
1779
1850
  assertFinite(input.payDeadline, "quote_malformed", "payDeadline");
@@ -1803,7 +1874,7 @@ var init_rfq = __esm({
1803
1874
  };
1804
1875
  matchReceiveLockup = (input, refundLocktime, solverRefundPkScriptHex) => {
1805
1876
  const contractParams = {
1806
- solverPubkey: (0, import_sdk5.toXOnly)(import_base6.hex.decode(input.quote.solver_pubkey), "solver key"),
1877
+ solverPubkey: (0, import_sdk6.toXOnly)(import_base6.hex.decode(input.quote.solver_pubkey), "solver key"),
1807
1878
  refundLocktime,
1808
1879
  operatorPubkey: input.operatorPubkey,
1809
1880
  paymentHash: input.paymentHash,
@@ -1811,7 +1882,7 @@ var init_rfq = __esm({
1811
1882
  emulatorPubkey: input.emulatorPubkey,
1812
1883
  solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
1813
1884
  payoutPubkey: input.payoutPubkey,
1814
- payoutPkScript: import_sdk5.ArkAddress.decode(input.payoutAddress).pkScript
1885
+ payoutPkScript: import_sdk6.ArkAddress.decode(input.payoutAddress).pkScript
1815
1886
  };
1816
1887
  const matched = matchQuotedLockup(
1817
1888
  input.quote,
@@ -1833,11 +1904,12 @@ __export(nostr_exports, {
1833
1904
  TransportClosed: () => TransportClosed,
1834
1905
  nostrRfqTransport: () => nostrRfqTransport
1835
1906
  });
1836
- var import_nostr_tools, RFQ_DIRECTED_KIND, RFQ_AD_KIND, DEFAULT_TIMEOUT_MS, RelayUnavailable, TransportClosed, closeReasons, nostrRfqTransport;
1907
+ var import_sdk32, import_nostr_tools, RFQ_DIRECTED_KIND, RFQ_AD_KIND, DEFAULT_TIMEOUT_MS, RelayUnavailable, TransportClosed, closeReasons, nostrRfqTransport;
1837
1908
  var init_nostr = __esm({
1838
1909
  "src/nostr.ts"() {
1839
1910
  "use strict";
1840
1911
  init_rfq();
1912
+ import_sdk32 = require("@arkade-os/sdk");
1841
1913
  import_nostr_tools = require("nostr-tools");
1842
1914
  RFQ_DIRECTED_KIND = 24859;
1843
1915
  RFQ_AD_KIND = 38859;
@@ -1862,6 +1934,7 @@ var init_nostr = __esm({
1862
1934
  return url ? `${url}: ${reason ?? "closed"}` : reason ?? "closed";
1863
1935
  });
1864
1936
  nostrRfqTransport = (options) => {
1937
+ (0, import_sdk32.assertTimerMs)("timeoutMs", options.timeoutMs);
1865
1938
  const relays = options.relays;
1866
1939
  const solverPubkey = options.solverPubkey;
1867
1940
  const secretKey = options.secretKey ?? (0, import_nostr_tools.generateSecretKey)();
@@ -1970,6 +2043,7 @@ __export(index_exports, {
1970
2043
  BTC_ASSET_PART: () => BTC_ASSET_PART,
1971
2044
  CLAIM_PACKET_TYPE: () => CLAIM_PACKET_TYPE,
1972
2045
  ClientDisposed: () => ClientDisposed,
2046
+ DEFAULT_MAX_REFUND_WINDOW_SECONDS: () => DEFAULT_MAX_REFUND_WINDOW_SECONDS,
1973
2047
  DiscoverySnapshotUnavailable: () => DiscoverySnapshotUnavailable,
1974
2048
  InMemoryAssetSwapRepository: () => InMemoryAssetSwapRepository,
1975
2049
  InconsistentRoute: () => InconsistentRoute,
@@ -2044,7 +2118,7 @@ init_repository();
2044
2118
  // src/refund.ts
2045
2119
  var import_base7 = require("@scure/base");
2046
2120
  var import_sha24 = require("@noble/hashes/sha2.js");
2047
- var import_sdk7 = require("@arkade-os/sdk");
2121
+ var import_sdk8 = require("@arkade-os/sdk");
2048
2122
  init_onchainHtlc();
2049
2123
  init_rfq();
2050
2124
  var walletOperator = (wallet) => {
@@ -2082,7 +2156,7 @@ async function findLockupVtxos(contracts, swapPkScript) {
2082
2156
  const out = [];
2083
2157
  for (const vtxo of row?.vtxos ?? []) {
2084
2158
  if (vtxo.isUnrolled) continue;
2085
- if ((0, import_sdk7.isVtxoSpent)(vtxo)) continue;
2159
+ if ((0, import_sdk8.isVtxoSpent)(vtxo)) continue;
2086
2160
  const key = `${vtxo.txid}:${vtxo.vout}`;
2087
2161
  if (seen.has(key)) continue;
2088
2162
  seen.add(key);
@@ -2097,14 +2171,14 @@ async function findLockupVtxos(contracts, swapPkScript) {
2097
2171
  }
2098
2172
  var hashesTo = (candidate, paymentHash) => import_base7.hex.encode((0, import_sha24.sha256)(candidate)) === paymentHash;
2099
2173
  var candidateWitnessItems = (tx, inputIndex) => [
2100
- ...(0, import_sdk7.getArkPsbtFields)(tx, inputIndex, import_sdk7.ConditionWitness).flat(),
2174
+ ...(0, import_sdk8.getArkPsbtFields)(tx, inputIndex, import_sdk8.ConditionWitness).flat(),
2101
2175
  ...tx.getInput(inputIndex).finalScriptWitness ?? []
2102
2176
  ];
2103
2177
  async function readLockupFate(indexer, input) {
2104
2178
  const { vtxos } = await indexer.getVtxos({ scripts: [import_base7.hex.encode(input.swapPkScript)] });
2105
2179
  const all = vtxos ?? [];
2106
2180
  if (all.length === 0) return { fate: "unknown" };
2107
- const exited = all.filter((vtxo) => vtxo.isUnrolled && !(0, import_sdk7.isVtxoSpent)(vtxo));
2181
+ const exited = all.filter((vtxo) => vtxo.isUnrolled && !(0, import_sdk8.isVtxoSpent)(vtxo));
2108
2182
  if (exited.length > 0) {
2109
2183
  return {
2110
2184
  fate: "exited",
@@ -2114,7 +2188,7 @@ async function readLockupFate(indexer, input) {
2114
2188
  const spentBy = /* @__PURE__ */ new Map();
2115
2189
  let everySpendNamed = true;
2116
2190
  for (const vtxo of all) {
2117
- if (!(0, import_sdk7.isVtxoSpent)(vtxo)) return { fate: "open" };
2191
+ if (!(0, import_sdk8.isVtxoSpent)(vtxo)) return { fate: "open" };
2118
2192
  if (vtxo.spentBy)
2119
2193
  spentBy.set(vtxo.spentBy, {
2120
2194
  checkpointTxid: vtxo.spentBy,
@@ -2128,7 +2202,7 @@ async function readLockupFate(indexer, input) {
2128
2202
  for (const raw of txs) {
2129
2203
  let tx;
2130
2204
  try {
2131
- tx = import_sdk7.Transaction.fromPSBT(import_base7.base64.decode(raw));
2205
+ tx = import_sdk8.Transaction.fromPSBT(import_base7.base64.decode(raw));
2132
2206
  } catch {
2133
2207
  continue;
2134
2208
  }
@@ -2158,10 +2232,10 @@ var assertNoneSwept = (vtxos, contract) => {
2158
2232
  };
2159
2233
  var operatorUnrollScript = async (operator, network) => {
2160
2234
  const info = await operator.getInfo();
2161
- return (0, import_sdk7.assertValidServerUnrollScript)(
2235
+ return (0, import_sdk8.assertValidServerUnrollScript)(
2162
2236
  info.checkpointTapscript,
2163
- (0, import_sdk7.resolveCheckpointExitDelayPolicy)(network ?? (0, import_sdk7.networkFromArkadeInfo)(info), {
2164
- advertisedForfeitPubkey: (0, import_sdk7.toXOnly)(import_base7.hex.decode(info.forfeitPubkey), "forfeit key")
2237
+ (0, import_sdk8.resolveCheckpointExitDelayPolicy)(network ?? (0, import_sdk8.networkFromArkadeInfo)(info), {
2238
+ advertisedForfeitPubkey: (0, import_sdk8.toXOnly)(import_base7.hex.decode(info.forfeitPubkey), "forfeit key")
2165
2239
  })
2166
2240
  );
2167
2241
  };
@@ -2187,7 +2261,7 @@ async function pushRefundWithoutReceiver(operator, input) {
2187
2261
  const serverUnrollScript = await operatorUnrollScript(operator, input.network);
2188
2262
  const leaf = input.contract.refundWithoutReceiver();
2189
2263
  const amount = input.vtxos.reduce((sum, vtxo) => sum + vtxo.value, 0);
2190
- const { arkTx: tx, checkpoints } = (0, import_sdk7.buildOffchainTx)(
2264
+ const { arkTx: tx, checkpoints } = (0, import_sdk8.buildOffchainTx)(
2191
2265
  lockupInputs(input.vtxos, input.contract, leaf),
2192
2266
  [{ script: refundPkScript, amount: BigInt(amount) }],
2193
2267
  serverUnrollScript
@@ -2197,8 +2271,8 @@ async function pushRefundWithoutReceiver(operator, input) {
2197
2271
  import_base7.base64.encode(signedTx.toPSBT()),
2198
2272
  checkpoints.map((c) => import_base7.base64.encode(c.toPSBT()))
2199
2273
  );
2200
- (0, import_sdk7.assertSubmittedArkTxid)(submitted, signedTx, "refundWithoutReceiver");
2201
- const matched = (0, import_sdk7.matchServerCheckpoints)(
2274
+ (0, import_sdk8.assertSubmittedArkTxid)(submitted, signedTx, "refundWithoutReceiver");
2275
+ const matched = (0, import_sdk8.matchServerCheckpoints)(
2202
2276
  submitted.signedCheckpointTxs,
2203
2277
  checkpoints,
2204
2278
  "refundWithoutReceiver"
@@ -2214,7 +2288,7 @@ async function pushRefundWithoutReceiver(operator, input) {
2214
2288
  var REFUND_MTP_LAG_SECONDS = 2 * 60 * 60;
2215
2289
 
2216
2290
  // src/client/corridors/registry.ts
2217
- var import_sdk13 = require("@arkade-os/sdk");
2291
+ var import_sdk14 = require("@arkade-os/sdk");
2218
2292
 
2219
2293
  // src/client/corridor.ts
2220
2294
  var CORRIDORS = ["arkade", "lightning", "onchain"];
@@ -2411,7 +2485,7 @@ function isSwapError(e, name) {
2411
2485
  }
2412
2486
 
2413
2487
  // src/client/corridors/arkade.ts
2414
- var import_sdk8 = require("@arkade-os/sdk");
2488
+ var import_sdk9 = require("@arkade-os/sdk");
2415
2489
  var ARKADE_DRIVE = {};
2416
2490
  var messageOf = (error) => error instanceof Error ? error.message : String(error);
2417
2491
  var arkadeCorridor = Object.assign(
@@ -2420,11 +2494,11 @@ var arkadeCorridor = Object.assign(
2420
2494
  deps,
2421
2495
  drive: ARKADE_DRIVE,
2422
2496
  matches(raw) {
2423
- const target = (0, import_sdk8.arkTarget)(raw);
2497
+ const target = (0, import_sdk9.arkTarget)(raw);
2424
2498
  if (target === void 0) return void 0;
2425
2499
  try {
2426
- const address = import_sdk8.ArkAddress.decode(target);
2427
- (0, import_sdk8.assertRecipientArkadeAddress)(target, address, {
2500
+ const address = import_sdk9.ArkAddress.decode(target);
2501
+ (0, import_sdk9.assertRecipientArkadeAddress)(target, address, {
2428
2502
  hrp: deps.network.hrp,
2429
2503
  signerSet: deps.signerSet
2430
2504
  });
@@ -2434,11 +2508,11 @@ var arkadeCorridor = Object.assign(
2434
2508
  return { claimed: { kind: "address", address: target } };
2435
2509
  }
2436
2510
  }),
2437
- { target: import_sdk8.arkTarget }
2511
+ { target: import_sdk9.arkTarget }
2438
2512
  );
2439
2513
 
2440
2514
  // src/client/corridors/deps.ts
2441
- var import_sdk11 = require("@arkade-os/sdk");
2515
+ var import_sdk12 = require("@arkade-os/sdk");
2442
2516
  init_onchainHtlc();
2443
2517
  init_rfq();
2444
2518
 
@@ -2446,7 +2520,7 @@ init_rfq();
2446
2520
  var import_light_bolt11_decoder = __toESM(require("light-bolt11-decoder"), 1);
2447
2521
 
2448
2522
  // src/client/corridors/lightning.ts
2449
- var import_sdk9 = require("@arkade-os/sdk");
2523
+ var import_sdk10 = require("@arkade-os/sdk");
2450
2524
  var INVOICE_HRPS = [
2451
2525
  ["lnbcrt", ["regtest"]],
2452
2526
  ["lntbs", ["signet", "mutinynet"]],
@@ -2476,7 +2550,7 @@ var lightningCorridor = Object.assign(
2476
2550
  deps,
2477
2551
  drive: LIGHTNING_DRIVE,
2478
2552
  matches(raw) {
2479
- const invoice = (0, import_sdk9.invoiceTarget)(raw);
2553
+ const invoice = (0, import_sdk10.invoiceTarget)(raw);
2480
2554
  if (invoice === void 0) return void 0;
2481
2555
  const networks2 = networksOfInvoiceHrp(invoice);
2482
2556
  if (networks2 === void 0) {
@@ -2522,7 +2596,7 @@ var lightningCorridor = Object.assign(
2522
2596
  };
2523
2597
  }
2524
2598
  }),
2525
- { target: import_sdk9.invoiceTarget }
2599
+ { target: import_sdk10.invoiceTarget }
2526
2600
  );
2527
2601
 
2528
2602
  // src/client/corridors/bolt11.ts
@@ -2553,7 +2627,7 @@ var decodeBolt11 = (invoice) => {
2553
2627
  // src/client/corridors/chainSource.ts
2554
2628
  var import_base8 = require("@scure/base");
2555
2629
  var btc2 = __toESM(require("@scure/btc-signer"), 1);
2556
- var import_sdk10 = require("@arkade-os/sdk");
2630
+ var import_sdk11 = require("@arkade-os/sdk");
2557
2631
  var addressOfScript = (script, network) => btc2.Address(network).encode(btc2.OutScript.decode(script));
2558
2632
  var chainSourceOver = (backend, network) => {
2559
2633
  const spenderFromVins = async (txid, vout, pkScript) => {
@@ -2615,7 +2689,7 @@ var esploraTip = async (esploraUrl, fetchImpl) => {
2615
2689
  };
2616
2690
  var esploraChainSource = (input) => chainSourceOver(
2617
2691
  {
2618
- provider: new import_sdk10.EsploraProvider(input.esploraUrl),
2692
+ provider: new import_sdk11.EsploraProvider(input.esploraUrl),
2619
2693
  tip: () => esploraTip(input.esploraUrl, input.fetchImpl)
2620
2694
  },
2621
2695
  input.network
@@ -2641,10 +2715,10 @@ var refusedIfMalformed = (value, dep) => {
2641
2715
  };
2642
2716
  var emulatorPubkeyFor = (base) => {
2643
2717
  if (base.emulatorPubkey !== void 0) {
2644
- return (0, import_sdk11.resolveEmulatorPubkey)(base.network, base.emulatorPubkey);
2718
+ return (0, import_sdk12.resolveEmulatorPubkey)(base.network, base.emulatorPubkey);
2645
2719
  }
2646
2720
  try {
2647
- return (0, import_sdk11.defaultEmulatorPubkey)(base.network);
2721
+ return (0, import_sdk12.defaultEmulatorPubkey)(base.network);
2648
2722
  } catch {
2649
2723
  throw new MissingCorridorDep(
2650
2724
  "arkade",
@@ -2680,6 +2754,11 @@ function resolveCorridorDeps(corridor, overrides, base) {
2680
2754
  case "onchain": {
2681
2755
  const chain = refusedIfNull(overrides?.onchain?.chain, "onchain", "chain source");
2682
2756
  const claim = refusedIfNull(overrides?.onchain?.claim, "onchain", "L1 claim callback");
2757
+ const refund = refusedIfNull(
2758
+ overrides?.onchain?.refund,
2759
+ "onchain",
2760
+ "L1 refund callback"
2761
+ );
2683
2762
  const feeRateOverride = refusedIfMalformed(
2684
2763
  overrides?.onchain?.claimFeeRateSatVb,
2685
2764
  "L1 claim fee rate"
@@ -2689,11 +2768,12 @@ function resolveCorridorDeps(corridor, overrides, base) {
2689
2768
  return {
2690
2769
  networkName: base.networkName,
2691
2770
  chain: esploraChainSource({
2692
- esploraUrl: chain?.esploraUrl ?? import_sdk11.ESPLORA_URL[base.networkName],
2771
+ esploraUrl: chain?.esploraUrl ?? import_sdk12.ESPLORA_URL[base.networkName],
2693
2772
  network: L1_NETWORKS[l1NetworkFromArk(base.networkName)],
2694
2773
  fetchImpl: base.fetchImpl
2695
2774
  }),
2696
2775
  ...claim === void 0 ? {} : { claim },
2776
+ ...refund === void 0 ? {} : { refund },
2697
2777
  ...claimFeeRateSatVb === void 0 ? {} : { claimFeeRateSatVb },
2698
2778
  claimVsize
2699
2779
  };
@@ -2718,8 +2798,8 @@ var resolveCorridorBase = async (input) => {
2718
2798
  wallet: input.wallet,
2719
2799
  operator: input.operator,
2720
2800
  networkName,
2721
- network: (0, import_sdk11.getNetwork)(networkName),
2722
- signerSet: (0, import_sdk11.signerSetFromInfo)(info),
2801
+ network: (0, import_sdk12.getNetwork)(networkName),
2802
+ signerSet: (0, import_sdk12.signerSetFromInfo)(info),
2723
2803
  emulatorPubkey: input.emulatorPubkey,
2724
2804
  fetchImpl: input.fetchImpl,
2725
2805
  repository: input.repository
@@ -2727,7 +2807,7 @@ var resolveCorridorBase = async (input) => {
2727
2807
  };
2728
2808
 
2729
2809
  // src/client/corridors/onchain.ts
2730
- var import_sdk12 = require("@arkade-os/sdk");
2810
+ var import_sdk13 = require("@arkade-os/sdk");
2731
2811
  var btc3 = __toESM(require("@scure/btc-signer"), 1);
2732
2812
  init_onchainHtlc();
2733
2813
  init_rfq();
@@ -2739,6 +2819,14 @@ var ONCHAIN_DRIVE = {
2739
2819
  ],
2740
2820
  actions: ["claimOnchain", "refundArkade"],
2741
2821
  seams: ["indexer", "chain"]
2822
+ },
2823
+ give: {
2824
+ lockups: [
2825
+ { covenant: "arkade_lockup", owner: "solver", deadline: "refund_locktime" },
2826
+ { covenant: "onchain_htlc", owner: "trader", deadline: "htlc_refund_locktime" }
2827
+ ],
2828
+ actions: ["claimLockup", "refundOnchain"],
2829
+ seams: ["indexer", "chain"]
2742
2830
  }
2743
2831
  };
2744
2832
  var onchainCorridor = Object.assign(
@@ -2749,14 +2837,14 @@ var onchainCorridor = Object.assign(
2749
2837
  deps,
2750
2838
  drive: ONCHAIN_DRIVE,
2751
2839
  matches(raw) {
2752
- const target = (0, import_sdk12.btcTarget)(raw);
2840
+ const target = (0, import_sdk13.btcTarget)(raw);
2753
2841
  if (target === void 0) return void 0;
2754
2842
  try {
2755
2843
  btc3.Address(L1_NETWORKS[l1]).decode(target);
2756
2844
  } catch {
2757
2845
  return { refused: `this is not a ${l1} address` };
2758
2846
  }
2759
- const amount = import_sdk12.BIP21.amountSats(raw);
2847
+ const amount = import_sdk13.BIP21.amountSats(raw);
2760
2848
  return {
2761
2849
  claimed: {
2762
2850
  kind: "address",
@@ -2767,7 +2855,7 @@ var onchainCorridor = Object.assign(
2767
2855
  }
2768
2856
  };
2769
2857
  },
2770
- { target: import_sdk12.btcTarget }
2858
+ { target: import_sdk13.btcTarget }
2771
2859
  );
2772
2860
 
2773
2861
  // src/client/corridors/registry.ts
@@ -2793,7 +2881,7 @@ var corridorSet = (base, overrides) => {
2793
2881
  (corridor) => CORRIDOR_FACTORIES[corridor].target(raw) !== void 0
2794
2882
  );
2795
2883
  if (owners.length === 0) {
2796
- if ((0, import_sdk13.isLnurl)(raw)) return void 0;
2884
+ if ((0, import_sdk14.isLnurl)(raw)) return void 0;
2797
2885
  throw new AmbiguousDestination(raw, "no corridor recognises this destination");
2798
2886
  }
2799
2887
  const claims = [];
@@ -2821,7 +2909,7 @@ var import_solver_discovery4 = require("@arkade-os/solver-discovery");
2821
2909
 
2822
2910
  // src/markets.ts
2823
2911
  var import_solver_discovery2 = require("@arkade-os/solver-discovery");
2824
- var import_sdk14 = require("@arkade-os/sdk");
2912
+ var import_sdk15 = require("@arkade-os/sdk");
2825
2913
 
2826
2914
  // src/marketShape.ts
2827
2915
  var MARKET_CORRIDORS = ["arkade", "bolt11", "bitcoin", "eip155"];
@@ -2863,6 +2951,7 @@ var marketPairLabel = (market) => `${sideLabel(market, "base")}/${sideLabel(mark
2863
2951
  init_store();
2864
2952
  var QUOTE_OPTIONS = { safetyBps: 0 };
2865
2953
  var makeCachedFeedFetch = (ttlMs = 3e4, fetchImpl = fetch) => {
2954
+ (0, import_sdk15.assertNonNegativeMs)("ttlMs", ttlMs);
2866
2955
  const cache = /* @__PURE__ */ new Map();
2867
2956
  const inflight = /* @__PURE__ */ new Map();
2868
2957
  return async (input, init) => {
@@ -2913,7 +3002,7 @@ var import_solver_discovery3 = require("@arkade-os/solver-discovery");
2913
3002
  init_store();
2914
3003
 
2915
3004
  // src/client/assetId.ts
2916
- var import_sdk15 = require("@arkade-os/sdk");
3005
+ var import_sdk16 = require("@arkade-os/sdk");
2917
3006
  var RAILS = ["arkade", "bitcoin", "bolt11", "eip155"];
2918
3007
  var BITCOIN_RAILS = ["arkade", "bitcoin", "bolt11"];
2919
3008
  var BTC_ASSET_PART = "slip44:0";
@@ -2942,7 +3031,7 @@ var CHAIN_REFERENCE = /^[-_a-z0-9]{1,32}$/;
2942
3031
  var CHAIN_ID = /^(0|[1-9][0-9]*)$/;
2943
3032
  var ASSET_REFERENCE = /^[-.%a-z0-9]{1,128}$/;
2944
3033
  var isRail = (value) => RAILS.includes(value);
2945
- var isNetworkRef = (value) => Object.hasOwn(import_sdk15.networks, value);
3034
+ var isNetworkRef = (value) => Object.hasOwn(import_sdk16.networks, value);
2946
3035
  var parseAssetId = (value) => {
2947
3036
  if (/[A-Z]/.test(value)) {
2948
3037
  throw new AssetIdError(
@@ -3007,7 +3096,7 @@ var parseAssetId = (value) => {
3007
3096
  }
3008
3097
  if (namespace === ARKADE_ASSET_NAMESPACE) {
3009
3098
  try {
3010
- import_sdk15.asset.AssetId.fromString(assetReference);
3099
+ import_sdk16.asset.AssetId.fromString(assetReference);
3011
3100
  } catch (cause) {
3012
3101
  throw new AssetIdError(
3013
3102
  "invalid_asset_reference",
@@ -3063,7 +3152,7 @@ var isBtcAssetLenient = (id) => {
3063
3152
  var arkadeAsset = (network, id) => `arkade:${network}/${ARKADE_ASSET_NAMESPACE}:${id.toString()}`;
3064
3153
  var issuanceOf = (id) => {
3065
3154
  const { assetNamespace, assetReference } = parseAssetId(id);
3066
- return assetNamespace === ARKADE_ASSET_NAMESPACE ? import_sdk15.asset.AssetId.fromString(assetReference) : void 0;
3155
+ return assetNamespace === ARKADE_ASSET_NAMESPACE ? import_sdk16.asset.AssetId.fromString(assetReference) : void 0;
3067
3156
  };
3068
3157
 
3069
3158
  // src/client/aliases.ts
@@ -3250,7 +3339,7 @@ var discoveryIndex = (input) => {
3250
3339
 
3251
3340
  // src/client/accept.ts
3252
3341
  var import_base10 = require("@scure/base");
3253
- var import_sdk16 = require("@arkade-os/sdk");
3342
+ var import_sdk17 = require("@arkade-os/sdk");
3254
3343
  init_offer();
3255
3344
  init_lockupContract();
3256
3345
 
@@ -3485,9 +3574,80 @@ var OnchainSendCorridor = {
3485
3574
  // Our own L1 claim only: `funding` is the solver's tx, not a row this wallet made.
3486
3575
  activityTxids: (profile) => profile.claimTxid ? [profile.claimTxid] : []
3487
3576
  };
3577
+ function onchainReceiveProfile(result) {
3578
+ return {
3579
+ claimKey: import_base9.hex.encode(result.htlcParams.claimKey),
3580
+ refundKey: import_base9.hex.encode(result.htlcParams.refundKey),
3581
+ htlcLocktime: result.htlcParams.refundLocktime,
3582
+ network: result.l1Network,
3583
+ htlcAddress: result.htlc.address,
3584
+ minConfirmations: result.minConfirmations,
3585
+ refundPkScript: import_base9.hex.encode(result.refundPkScript),
3586
+ ...result.refundDescriptor === void 0 ? {} : { refundDescriptor: result.refundDescriptor }
3587
+ };
3588
+ }
3589
+ var OnchainReceiveCorridor = {
3590
+ kind: "onchain_receive",
3591
+ project: (swap) => {
3592
+ const receive2 = swap;
3593
+ return {
3594
+ expectedAmount: receive2.expectedAmount,
3595
+ ...receive2.claimTxid ? { claimTxid: receive2.claimTxid } : {},
3596
+ ...receive2.funding ? { funding: receive2.funding } : {}
3597
+ };
3598
+ },
3599
+ hydrate(profile) {
3600
+ const { paymentHash } = hydrateHashlock(profile);
3601
+ if (typeof profile.expectedAmount !== "number" || !Number.isFinite(profile.expectedAmount)) {
3602
+ throw new Error("onchain_receive record carries no expectedAmount; it cannot claim");
3603
+ }
3604
+ if (!profile.claimKey || !profile.refundKey) {
3605
+ throw new Error(
3606
+ "onchain_receive record carries no L1 keys; its HTLC cannot be rebuilt and the trader's own funding could never be taken back"
3607
+ );
3608
+ }
3609
+ if (!Number.isInteger(profile.minConfirmations) || profile.minConfirmations < 1) {
3610
+ throw new Error(
3611
+ `onchain_receive record carries no usable minConfirmations (${String(profile.minConfirmations)}); the confirmation gate cannot be checked`
3612
+ );
3613
+ }
3614
+ if (!profile.refundPkScript) {
3615
+ throw new Error(
3616
+ "onchain_receive record carries no refundPkScript; its L1 refund could not be built, so the trader's funding would be stranded"
3617
+ );
3618
+ }
3619
+ const htlc = onchainHtlcScript(
3620
+ {
3621
+ paymentHash,
3622
+ claimKey: import_base9.hex.decode(profile.claimKey),
3623
+ refundKey: import_base9.hex.decode(profile.refundKey),
3624
+ refundLocktime: profile.htlcLocktime
3625
+ },
3626
+ profile.network
3627
+ );
3628
+ if (htlc.address !== profile.htlcAddress) {
3629
+ throw new Error(
3630
+ `onchain_receive record's L1 inputs derive ${htlc.address}, but the funding went to ${String(profile.htlcAddress)} \u2014 these are not this swap's`
3631
+ );
3632
+ }
3633
+ return {
3634
+ paymentHash,
3635
+ htlc,
3636
+ expectedAmount: profile.expectedAmount,
3637
+ minConfirmations: profile.minConfirmations,
3638
+ refundPkScript: import_base9.hex.decode(profile.refundPkScript),
3639
+ ...profile.claimTxid ? { claimTxid: profile.claimTxid } : {},
3640
+ ...profile.funding ? { funding: profile.funding } : {}
3641
+ };
3642
+ },
3643
+ claimSecret: (profile) => ({ ...profile.signer, ...profile.hashlock }),
3644
+ // The L1 refund is the record's own `refundTxid`, read by the activity resolver directly.
3645
+ activityTxids: (profile) => profile.claimTxid ? [profile.claimTxid] : []
3646
+ };
3488
3647
  rfqCorridorHandlers.register(LightningSendCorridor);
3489
3648
  rfqCorridorHandlers.register(LightningReceiveCorridor);
3490
3649
  rfqCorridorHandlers.register(OnchainSendCorridor);
3650
+ rfqCorridorHandlers.register(OnchainReceiveCorridor);
3491
3651
 
3492
3652
  // src/client/accept.ts
3493
3653
  init_store();
@@ -3496,12 +3656,14 @@ init_store();
3496
3656
  var CORRIDOR_PASS = {
3497
3657
  lightning_send: LIGHTNING_DRIVE.take,
3498
3658
  lightning_receive: LIGHTNING_DRIVE.give,
3499
- onchain_send: ONCHAIN_DRIVE.take
3659
+ onchain_send: ONCHAIN_DRIVE.take,
3660
+ onchain_receive: ONCHAIN_DRIVE.give
3500
3661
  };
3501
3662
  var LOCKUP_OWNER = {
3502
3663
  lightning_send: CORRIDOR_PASS.lightning_send.lockups[0].owner,
3503
3664
  lightning_receive: CORRIDOR_PASS.lightning_receive.lockups[0].owner,
3504
- onchain_send: CORRIDOR_PASS.onchain_send.lockups[0].owner
3665
+ onchain_send: CORRIDOR_PASS.onchain_send.lockups[0].owner,
3666
+ onchain_receive: CORRIDOR_PASS.onchain_receive.lockups[0].owner
3505
3667
  };
3506
3668
  var readsChain = (kind) => CORRIDOR_PASS[kind].seams.includes("chain");
3507
3669
  var at = (outcome) => () => outcome;
@@ -3523,8 +3685,9 @@ var CORRIDOR_OUTCOME = {
3523
3685
  needs_counterparty: at("needs_recovery"),
3524
3686
  // Matched by the hash, not our txid, so a claim that lands without us counts.
3525
3687
  settled: at("claimed"),
3526
- // The inversion: a receive lockup's non-claim leaves are all the solver's.
3527
- refunded: at("lapsed"),
3688
+ // The inversion: a receive lockup's non-claim leaves are all the solver's. On
3689
+ // `onchain_receive` the swap is `refunded` only once the trader's own L1 half is.
3690
+ refunded: (kind) => kind === "onchain_receive" ? "refunded" : "lapsed",
3528
3691
  failed: at("failed")
3529
3692
  }
3530
3693
  };
@@ -3907,7 +4070,8 @@ var corridorRecord = (quote, preparation, now) => {
3907
4070
  var KIND_OF = {
3908
4071
  "arkade->lightning": "lightning_send",
3909
4072
  "lightning->arkade": "lightning_receive",
3910
- "arkade->onchain": "onchain_send"
4073
+ "arkade->onchain": "onchain_send",
4074
+ "onchain->arkade": "onchain_receive"
3911
4075
  };
3912
4076
  var profileOf = (preparation, paymentHash) => {
3913
4077
  const secrets = rfqSecretsProfile(preparation.secrets, paymentHash);
@@ -3932,6 +4096,20 @@ var profileOf = (preparation, paymentHash) => {
3932
4096
  payoutPkScript: preparation.payoutPkScript
3933
4097
  })
3934
4098
  };
4099
+ case "onchain->arkade":
4100
+ return {
4101
+ ...secrets,
4102
+ expectedAmount: toSafeNumber(preparation.expectedAmount, "expectedAmount"),
4103
+ payoutAddress: preparation.payoutAddress,
4104
+ ...onchainReceiveProfile({
4105
+ htlc: preparation.htlc,
4106
+ htlcParams: preparation.htlcParams,
4107
+ l1Network: preparation.l1Network,
4108
+ minConfirmations: preparation.minConfirmations,
4109
+ refundPkScript: preparation.refundPkScript,
4110
+ refundDescriptor: preparation.refundKey.descriptor
4111
+ })
4112
+ };
3935
4113
  }
3936
4114
  };
3937
4115
  var acceptQuote = async (input) => runSerialized(input.quote.id, () => acceptQuoteBody(input));
@@ -3977,7 +4155,7 @@ var registeredOfferRecord = async (input, preparation) => {
3977
4155
  const offer = await createOffer(wallet, {
3978
4156
  // Keyed on the receive side: the covenant binds what the fill delivers.
3979
4157
  wantAmount: plan.receive.atomic,
3980
- ...receiveIsBtc ? { offerAsset: import_sdk16.asset.AssetId.fromString(plan.deposit.asset.id) } : { wantAsset: import_sdk16.asset.AssetId.fromString(plan.receive.asset.id) },
4158
+ ...receiveIsBtc ? { offerAsset: import_sdk17.asset.AssetId.fromString(plan.deposit.asset.id) } : { wantAsset: import_sdk17.asset.AssetId.fromString(plan.receive.asset.id) },
3981
4159
  emulatorPubkey: arkade2.emulatorPubkey
3982
4160
  });
3983
4161
  return {
@@ -4037,7 +4215,7 @@ var fund = async (input, record) => {
4037
4215
  extensions: [offerExtensionOf(record)]
4038
4216
  });
4039
4217
  }
4040
- if (record.kind === "lightning_receive") {
4218
+ if (record.kind === "lightning_receive" || record.kind === "onchain_receive") {
4041
4219
  throw new Error(`receive swap ${record.id} funds nothing from this wallet`);
4042
4220
  }
4043
4221
  return wallet.send({
@@ -4053,7 +4231,7 @@ var reconcileFunding = async (input, record) => {
4053
4231
  const script = record.family === "offer" ? record.swapPkScript : record.lockupPkScript;
4054
4232
  const expected = BigInt(record.give.amount);
4055
4233
  const reader = await input.wallet.getArkadeReader();
4056
- const vtxos = await (0, import_sdk16.getAllNormalizedVtxos)(reader, [script]);
4234
+ const vtxos = await (0, import_sdk17.getAllNormalizedVtxos)(reader, [script]);
4057
4235
  const deposit = vtxos.find((vtxo) => depositMatches(vtxo, record, expected));
4058
4236
  return deposit?.txid;
4059
4237
  };
@@ -4069,13 +4247,13 @@ var depositMatches = (vtxo, record, expected) => {
4069
4247
 
4070
4248
  // src/client/cancel.ts
4071
4249
  var import_base14 = require("@scure/base");
4072
- var import_sdk20 = require("@arkade-os/sdk");
4250
+ var import_sdk21 = require("@arkade-os/sdk");
4073
4251
  init_coverage();
4074
4252
  init_offer();
4075
4253
 
4076
4254
  // src/restore.ts
4077
4255
  var import_base11 = require("@scure/base");
4078
- var import_sdk17 = require("@arkade-os/sdk");
4256
+ var import_sdk18 = require("@arkade-os/sdk");
4079
4257
  init_offer();
4080
4258
  init_store();
4081
4259
  var TXS_PER_REQUEST = 50;
@@ -4100,7 +4278,7 @@ async function fetchParsedTxs(indexer, txids) {
4100
4278
  if (result.status !== "fulfilled") continue;
4101
4279
  for (const psbt of result.value) {
4102
4280
  try {
4103
- const parsed = import_sdk17.Transaction.fromPSBT(import_base11.base64.decode(psbt));
4281
+ const parsed = import_sdk18.Transaction.fromPSBT(import_base11.base64.decode(psbt));
4104
4282
  parsedByTxid.set(parsed.id, parsed);
4105
4283
  } catch {
4106
4284
  }
@@ -4129,7 +4307,7 @@ function classifySpend(offer, operatorPubkey, spendTx, deposit) {
4129
4307
  if (!input.txid || input.index !== deposit.vout) continue;
4130
4308
  if (import_base11.hex.encode(input.txid) !== deposit.txid) continue;
4131
4309
  for (const leaf of input.tapLeafScript ?? []) {
4132
- const spent = import_base11.hex.encode((0, import_sdk17.scriptFromTapLeafScript)(leaf));
4310
+ const spent = import_base11.hex.encode((0, import_sdk18.scriptFromTapLeafScript)(leaf));
4133
4311
  if (leaves.returned.some((back) => spent === import_base11.hex.encode(back))) return "cancelled";
4134
4312
  if (leaves.fulfill && spent === import_base11.hex.encode(leaves.fulfill)) return "fulfilled";
4135
4313
  }
@@ -4183,7 +4361,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
4183
4361
  if (!fundingTx) continue;
4184
4362
  fetchedTxids.push(txid);
4185
4363
  try {
4186
- const packet = import_sdk17.Extension.fromTx(parsed).getPacketByType(OFFER_PACKET_TYPE);
4364
+ const packet = import_sdk18.Extension.fromTx(parsed).getPacketByType(OFFER_PACKET_TYPE);
4187
4365
  if (!packet) continue;
4188
4366
  const payload = packet.serialize();
4189
4367
  found.push({
@@ -4300,7 +4478,7 @@ init_repository();
4300
4478
  init_repository();
4301
4479
 
4302
4480
  // src/rfqRecord.ts
4303
- var import_sdk18 = require("@arkade-os/sdk");
4481
+ var import_sdk19 = require("@arkade-os/sdk");
4304
4482
  var import_base12 = require("@scure/base");
4305
4483
 
4306
4484
  // src/rfqSwapState.ts
@@ -4355,7 +4533,7 @@ function assertSameSwap(origin, swap) {
4355
4533
  `rfq swap record is a ${origin.kind} origin paired with a ${swap.kind} swap`
4356
4534
  );
4357
4535
  }
4358
- const funded = import_base12.hex.encode(import_sdk18.ArkAddress.decode(origin.lockupAddress).pkScript);
4536
+ const funded = import_base12.hex.encode(import_sdk19.ArkAddress.decode(origin.lockupAddress).pkScript);
4359
4537
  const watched = import_base12.hex.encode(swap.lockupPkScript);
4360
4538
  if (funded !== watched) {
4361
4539
  throw new Error(
@@ -4402,8 +4580,8 @@ function rfqSwapOriginOf(record) {
4402
4580
  };
4403
4581
  }
4404
4582
  function lockupScript(params, lockupAddress) {
4405
- const script = import_sdk18.VHTLCV2ContractHandler.createScript(params);
4406
- const funded = import_sdk18.ArkAddress.decode(lockupAddress).pkScript;
4583
+ const script = import_sdk19.VHTLCV2ContractHandler.createScript(params);
4584
+ const funded = import_sdk19.ArkAddress.decode(lockupAddress).pkScript;
4407
4585
  if (import_base12.hex.encode(funded) !== import_base12.hex.encode(script.pkScript)) {
4408
4586
  throw new Error(
4409
4587
  `rfq swap covenant params derive ${import_base12.hex.encode(script.pkScript)}, but the record's lockup address holds ${import_base12.hex.encode(funded)} \u2014 these params are not this swap's`
@@ -4440,7 +4618,7 @@ function shouldRetainRfqSwap(record, now) {
4440
4618
 
4441
4619
  // src/client/driveRecords.ts
4442
4620
  init_store();
4443
- var import_sdk19 = require("@arkade-os/sdk");
4621
+ var import_sdk20 = require("@arkade-os/sdk");
4444
4622
  var import_sha25 = require("@noble/hashes/sha2.js");
4445
4623
  var import_base13 = require("@scure/base");
4446
4624
  var splitRecords = (records) => {
@@ -4495,7 +4673,7 @@ var pageRfqRecords = (records, filter, page) => {
4495
4673
  ).sort(
4496
4674
  (a, b) => a.updatedAt - b.updatedAt || (a.rfqId < b.rfqId ? -1 : a.rfqId > b.rfqId ? 1 : 0)
4497
4675
  ).slice(0, page.limit + 1);
4498
- return (0, import_sdk19.pageResult)(rows, page.limit, (record) => ({
4676
+ return (0, import_sdk20.pageResult)(rows, page.limit, (record) => ({
4499
4677
  updatedAt: record.updatedAt,
4500
4678
  rfqId: record.rfqId
4501
4679
  }));
@@ -4521,7 +4699,7 @@ var corridorRecordStore = (repository, onRecord = () => {
4521
4699
  index,
4522
4700
  quoteIdOf: (rfqId) => byRfqId.get(rfqId),
4523
4701
  async getRfqSwapsPage(filter, page) {
4524
- (0, import_sdk19.assertPageRequest)(page);
4702
+ (0, import_sdk20.assertPageRequest)(page);
4525
4703
  assertRfqSwapPageFilter(filter);
4526
4704
  const { corridor } = splitRecords(await collectSwapRecords(repository));
4527
4705
  for (const record of corridor) index(record);
@@ -4630,11 +4808,12 @@ var restoredOfferRecord = (swap, network, now) => {
4630
4808
  now
4631
4809
  );
4632
4810
  };
4633
- var restoredAssetId = (network, id) => id === BTC_ASSET_ID ? btcOn("arkade", network) : arkadeAsset(network, import_sdk19.asset.AssetId.fromString(id));
4811
+ var restoredAssetId = (network, id) => id === BTC_ASSET_ID ? btcOn("arkade", network) : arkadeAsset(network, import_sdk20.asset.AssetId.fromString(id));
4634
4812
  var RESTORED_CORRIDORS = {
4635
4813
  lightning_send: ["arkade", "lightning"],
4636
4814
  lightning_receive: ["lightning", "arkade"],
4637
- onchain_send: ["arkade", "onchain"]
4815
+ onchain_send: ["arkade", "onchain"],
4816
+ onchain_receive: ["onchain", "arkade"]
4638
4817
  };
4639
4818
  var restoredCorridorRecord = (stored, network, refundLocktime) => {
4640
4819
  const v1 = normalizeRfqSwapRecord(stored);
@@ -4661,7 +4840,7 @@ var restoredCorridorRecord = (stored, network, refundLocktime) => {
4661
4840
  kind: v1.kind,
4662
4841
  rfqId: v1.rfqId,
4663
4842
  lockupAddress: v1.lockupAddress,
4664
- lockupPkScript: import_base13.hex.encode(import_sdk19.ArkAddress.decode(v1.lockupAddress).pkScript),
4843
+ lockupPkScript: import_base13.hex.encode(import_sdk20.ArkAddress.decode(v1.lockupAddress).pkScript),
4665
4844
  lock: { hash },
4666
4845
  refundLocktime,
4667
4846
  profile: v1.profile,
@@ -4757,12 +4936,12 @@ var reconcileDepositSpend = async (record, indexer) => {
4757
4936
  const { txs } = await indexer.getVirtualTxs(candidates);
4758
4937
  const parsed = txs.map((psbt) => {
4759
4938
  try {
4760
- return import_sdk20.Transaction.fromPSBT(import_base14.base64.decode(psbt));
4939
+ return import_sdk21.Transaction.fromPSBT(import_base14.base64.decode(psbt));
4761
4940
  } catch {
4762
4941
  return void 0;
4763
4942
  }
4764
4943
  }).filter((tx) => tx !== void 0);
4765
- const operatorPubkey = import_sdk20.ArkAddress.decode(record.swapAddress).serverPubKey;
4944
+ const operatorPubkey = import_sdk21.ArkAddress.decode(record.swapAddress).serverPubKey;
4766
4945
  const kind = classifyDepositSpend(offer, operatorPubkey, parsed, {
4767
4946
  txid: deposit.txid,
4768
4947
  vout: deposit.vout
@@ -4800,11 +4979,11 @@ var retireOfferScripts = async (wallet, repository, record) => {
4800
4979
  };
4801
4980
 
4802
4981
  // src/client/drive.ts
4803
- var import_sdk26 = require("@arkade-os/sdk");
4982
+ var import_sdk27 = require("@arkade-os/sdk");
4804
4983
  var import_base17 = require("@scure/base");
4805
4984
 
4806
4985
  // src/claim.ts
4807
- var import_sdk21 = require("@arkade-os/sdk");
4986
+ var import_sdk22 = require("@arkade-os/sdk");
4808
4987
  init_onchainHtlc();
4809
4988
  var LockupAmountMismatchError = class extends Error {
4810
4989
  name = "LockupAmountMismatchError";
@@ -4837,8 +5016,8 @@ async function pushClaim(operator, input) {
4837
5016
  assertPreimageMatches(input.preimage, input.contract.options.preimageHash);
4838
5017
  const serverUnrollScript = await operatorUnrollScript(operator, input.network);
4839
5018
  const leaf = input.contract.claim();
4840
- const txid = await (0, import_sdk21.signAndSubmitOffchainTx)({
4841
- identity: (0, import_sdk21.claimWithPreimageIdentity)(input.receiver, input.preimage),
5019
+ const txid = await (0, import_sdk22.signAndSubmitOffchainTx)({
5020
+ identity: (0, import_sdk22.claimWithPreimageIdentity)(input.receiver, input.preimage),
4842
5021
  provider: operator,
4843
5022
  inputs: lockupInputs(input.vtxos, input.contract, leaf),
4844
5023
  // One aggregate output: this leaf inspects nothing about the output set.
@@ -4856,7 +5035,7 @@ init_offer();
4856
5035
  init_lockupContract();
4857
5036
 
4858
5037
  // src/refundBlocked.ts
4859
- var import_sdk22 = require("@arkade-os/sdk");
5038
+ var import_sdk23 = require("@arkade-os/sdk");
4860
5039
  var RefundNotLocallyPossibleError = class extends Error {
4861
5040
  constructor(reason, message, options) {
4862
5041
  super(message, options);
@@ -4873,16 +5052,16 @@ async function senderIdentityForSwapRecord(wallet, record) {
4873
5052
  );
4874
5053
  }
4875
5054
  try {
4876
- return await (0, import_sdk22.contractSigner)(wallet, record.signingDescriptor);
5055
+ return await (0, import_sdk23.contractSigner)(wallet, record.signingDescriptor);
4877
5056
  } catch (cause) {
4878
- if (cause instanceof import_sdk22.WalletCannotSignError) {
5057
+ if (cause instanceof import_sdk23.WalletCannotSignError) {
4879
5058
  throw new RefundNotLocallyPossibleError(
4880
5059
  "unsignable-wallet",
4881
5060
  `this wallet holds ${record.signingDescriptor} but cannot sign with it; attach its signer`,
4882
5061
  { cause }
4883
5062
  );
4884
5063
  }
4885
- if (cause instanceof import_sdk22.ForeignDescriptorError) {
5064
+ if (cause instanceof import_sdk23.ForeignDescriptorError) {
4886
5065
  throw new RefundNotLocallyPossibleError(
4887
5066
  "foreign-descriptor",
4888
5067
  `this wallet cannot derive ${record.signingDescriptor}; the swap was created on another wallet`,
@@ -4927,7 +5106,7 @@ init_repository();
4927
5106
 
4928
5107
  // src/swapManager.ts
4929
5108
  var import_base15 = require("@scure/base");
4930
- var import_sdk23 = require("@arkade-os/sdk");
5109
+ var import_sdk24 = require("@arkade-os/sdk");
4931
5110
  init_onchainHtlc();
4932
5111
  init_lockupContract();
4933
5112
  init_repository();
@@ -4947,12 +5126,29 @@ function nextOnchainAction(input) {
4947
5126
  return input.htlcLocktime - input.now >= ONCHAIN_CLAIM_MARGIN_SECONDS ? "claim" : "claim_window_closed";
4948
5127
  }
4949
5128
  }
5129
+ function nextOnchainReceiveAction(input) {
5130
+ switch (input.phase.phase) {
5131
+ case "unfunded":
5132
+ case "awaiting_confirmations":
5133
+ case "claimable":
5134
+ return "wait";
5135
+ case "claimed":
5136
+ return "taken";
5137
+ case "swept":
5138
+ return "refunded";
5139
+ case "refundable":
5140
+ return input.settled ? "taken" : "refund";
5141
+ }
5142
+ }
4950
5143
  var RFQ_CONFIGURATION_REFUSAL = {
4951
5144
  noClaimLockupCallback: "no claimLockup callback is wired, so this wallet cannot claim the lockup",
4952
5145
  noCallbacksForClaim: "no callbacks are wired, so this wallet cannot claim the lockup",
4953
5146
  noClaimOnchainCallback: "no claimOnchain callback is wired, so this wallet cannot claim the L1 fill",
4954
5147
  autoActionsDisabled: "automatic actions are disabled, so this wallet will not push the refund",
4955
- noCallbacksForRefund: "no callbacks are wired, so this wallet cannot push the refund"
5148
+ noCallbacksForRefund: "no callbacks are wired, so this wallet cannot push the refund",
5149
+ noRefundOnchainCallback: "no refundOnchain callback is wired, so this wallet cannot take the L1 funding back",
5150
+ noCallbacksForL1Refund: "no callbacks are wired, so this wallet cannot take the L1 funding back",
5151
+ autoActionsDisabledForL1Refund: "automatic actions are disabled, so this wallet will not push the L1 refund"
4956
5152
  };
4957
5153
  var RFQ_CONFIGURATION_REFUSALS = Object.values(RFQ_CONFIGURATION_REFUSAL);
4958
5154
  var isRfqConfigurationRefusal = (reason) => reason !== void 0 && RFQ_CONFIGURATION_REFUSALS.includes(reason);
@@ -4967,6 +5163,16 @@ var RfqSwapOriginRequired = class extends Error {
4967
5163
  this.rfqId = rfqId;
4968
5164
  }
4969
5165
  };
5166
+ var OnchainReceiveNeedsChainSource = class extends Error {
5167
+ rfqId;
5168
+ constructor(rfqId) {
5169
+ super(
5170
+ `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`
5171
+ );
5172
+ this.name = "OnchainReceiveNeedsChainSource";
5173
+ this.rfqId = rfqId;
5174
+ }
5175
+ };
4970
5176
  var notify = (listeners, call) => {
4971
5177
  for (const listener of listeners) {
4972
5178
  try {
@@ -5031,6 +5237,7 @@ var RfqSwapManager = class _RfqSwapManager {
5031
5237
  timer = null;
5032
5238
  running = false;
5033
5239
  constructor(deps, config = {}) {
5240
+ (0, import_sdk24.assertTimerMs)("pollIntervalMs", config.pollIntervalMs);
5034
5241
  this.deps = deps;
5035
5242
  this.config = {
5036
5243
  enableAutoActions: config.enableAutoActions ?? true,
@@ -5086,6 +5293,9 @@ var RfqSwapManager = class _RfqSwapManager {
5086
5293
  let swap;
5087
5294
  try {
5088
5295
  swap = rebuildRfqSwap(record, await params(record));
5296
+ if (swap.kind === "onchain_receive" && !this.deps.chain) {
5297
+ throw new OnchainReceiveNeedsChainSource(swap.rfqId);
5298
+ }
5089
5299
  } catch (error) {
5090
5300
  failed.push({
5091
5301
  rfqId: record.rfqId,
@@ -5220,6 +5430,9 @@ var RfqSwapManager = class _RfqSwapManager {
5220
5430
  * origin, one remembered from an earlier `addSwap`, or the stored record (one read).
5221
5431
  */
5222
5432
  async admit(swap, origin) {
5433
+ if (swap.kind === "onchain_receive" && !this.deps.chain) {
5434
+ throw new OnchainReceiveNeedsChainSource(swap.rfqId);
5435
+ }
5223
5436
  if (origin) {
5224
5437
  assertSameSwap(origin, swap);
5225
5438
  this.origins.set(swap.rfqId, origin);
@@ -5368,7 +5581,7 @@ var RfqSwapManager = class _RfqSwapManager {
5368
5581
  });
5369
5582
  return;
5370
5583
  }
5371
- if (!(0, import_sdk23.isContractVtxoEvent)(event)) return;
5584
+ if (!(0, import_sdk24.isContractVtxoEvent)(event)) return;
5372
5585
  const swap = this.byLockupScript.get(event.contractScript);
5373
5586
  if (!swap) return;
5374
5587
  void this.pollSwap(swap).catch(() => {
@@ -5486,6 +5699,7 @@ var RfqSwapManager = class _RfqSwapManager {
5486
5699
  } catch {
5487
5700
  fate = { fate: "unknown" };
5488
5701
  }
5702
+ if (swap.kind === "onchain_receive") return this.driveOnchainReceive(swap, fate);
5489
5703
  if (fate.fate === "claimed" || fate.fate === "returned") {
5490
5704
  this.stampLockupSpends(swap, fate.spends);
5491
5705
  if (fate.fate === "claimed") this.stampSettlementPreimage(swap, fate.preimage);
@@ -5595,8 +5809,8 @@ var RfqSwapManager = class _RfqSwapManager {
5595
5809
  this.setState(swap, "claimed");
5596
5810
  this.emitAction(swap, "claimLockup");
5597
5811
  } catch (error) {
5598
- const ark = (0, import_sdk23.isArkError)(error) ? error : (0, import_sdk23.maybeArkError)(error);
5599
- if ((0, import_sdk23.isArkError)(ark, import_sdk23.ArkErrorName.VTXO_ALREADY_SPENT)) {
5812
+ const ark = (0, import_sdk24.isArkError)(error) ? error : (0, import_sdk24.maybeArkError)(error);
5813
+ if ((0, import_sdk24.isArkError)(ark, import_sdk24.ArkErrorName.VTXO_ALREADY_SPENT)) {
5600
5814
  if (swap.claimFailure !== void 0) {
5601
5815
  delete swap.claimFailure;
5602
5816
  this.touch(swap);
@@ -5608,6 +5822,94 @@ var RfqSwapManager = class _RfqSwapManager {
5608
5822
  this.emitFailed(swap, error);
5609
5823
  }
5610
5824
  }
5825
+ /** `settled` ends the swap; `returned` does NOT, signalling their L1
5826
+ * funding is stranded. */
5827
+ async driveOnchainReceive(swap, fate) {
5828
+ const settled = fate.fate === "claimed";
5829
+ if (settled || fate.fate === "returned") this.stampLockupSpends(swap, fate.spends);
5830
+ if (settled) {
5831
+ this.setState(swap, "settled");
5832
+ return;
5833
+ }
5834
+ const l1 = await this.driveOnchainRefund(swap, swap.claimTxid !== void 0);
5835
+ if (fate.fate === "returned") {
5836
+ if (l1.verdict === "resolved") this.setState(swap, "refunded");
5837
+ else if (l1.blocked) this.block(swap, l1.blocked);
5838
+ return;
5839
+ }
5840
+ if (fate.fate === "exited") return this.blockExitedLockup(swap, fate);
5841
+ if (l1.verdict === "live" && this.config.now() >= swap.refundLocktime + REFUND_MTP_LAG_SECONDS) {
5842
+ return this.block(
5843
+ swap,
5844
+ 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"
5845
+ );
5846
+ }
5847
+ if (swap.refundTxid || l1.attempted) {
5848
+ return this.block(
5849
+ swap,
5850
+ "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"
5851
+ );
5852
+ }
5853
+ await this.driveReceiveClaim(swap);
5854
+ if (l1.blocked && !isRfqSwapTerminal(swap.state)) this.block(swap, l1.blocked);
5855
+ }
5856
+ /** `resolved`: the HTLC can hold nothing more. `blocked` is a refusal the
5857
+ * caller applies once the Arkade arm has run. No give-up branch. */
5858
+ async driveOnchainRefund(swap, claimSubmitted) {
5859
+ if (!this.deps.chain) return { verdict: "live" };
5860
+ let phase;
5861
+ try {
5862
+ phase = await classifyOnchainHtlc(this.deps.chain, {
5863
+ htlc: swap.htlc,
5864
+ minConfirmations: swap.minConfirmations,
5865
+ funding: swap.funding
5866
+ });
5867
+ } catch {
5868
+ return { verdict: "live" };
5869
+ }
5870
+ if ("utxo" in phase && !swap.funding) {
5871
+ swap.funding = { txid: phase.utxo.txid, vout: phase.utxo.vout };
5872
+ this.touch(swap);
5873
+ }
5874
+ if (phase.phase === "unfunded" && !swap.funding) return { verdict: "resolved" };
5875
+ switch (nextOnchainReceiveAction({ phase, settled: claimSubmitted })) {
5876
+ case "taken":
5877
+ return { verdict: "resolved" };
5878
+ case "refunded":
5879
+ if (phase.phase === "swept" && !swap.refundTxid) {
5880
+ swap.refundTxid = phase.txid;
5881
+ this.touch(swap);
5882
+ }
5883
+ return { verdict: "resolved" };
5884
+ case "wait":
5885
+ return { verdict: "live" };
5886
+ case "refund":
5887
+ break;
5888
+ }
5889
+ if (phase.phase !== "refundable") return { verdict: "live" };
5890
+ if (swap.refundTxid) return { verdict: "live" };
5891
+ if (!this.callbacks?.refundOnchain) {
5892
+ return {
5893
+ verdict: "live",
5894
+ blocked: this.callbacks ? RFQ_CONFIGURATION_REFUSAL.noRefundOnchainCallback : RFQ_CONFIGURATION_REFUSAL.noCallbacksForL1Refund
5895
+ };
5896
+ }
5897
+ if (!this.config.enableAutoActions) {
5898
+ return {
5899
+ verdict: "live",
5900
+ blocked: RFQ_CONFIGURATION_REFUSAL.autoActionsDisabledForL1Refund
5901
+ };
5902
+ }
5903
+ try {
5904
+ const { txid } = await this.callbacks.refundOnchain(swap, phase.utxo);
5905
+ swap.refundTxid = txid;
5906
+ this.touch(swap);
5907
+ this.emitAction(swap, "refundOnchain");
5908
+ } catch (error) {
5909
+ this.emitFailed(swap, error);
5910
+ }
5911
+ return { verdict: "live", attempted: true };
5912
+ }
5611
5913
  /** `handled` ends the pass; `continue` falls through to the refund gate. */
5612
5914
  async driveOnchain(swap) {
5613
5915
  if (!this.deps.chain) {
@@ -5886,10 +6188,10 @@ var RfqSwapManager = class _RfqSwapManager {
5886
6188
  this.waiters.delete(swap.rfqId);
5887
6189
  }
5888
6190
  };
5889
- var traderClaimTxid = (swap) => swap.kind === "onchain_send" || swap.kind === "lightning_receive" ? swap.claimTxid : void 0;
6191
+ var traderClaimTxid = (swap) => swap.kind === "lightning_send" ? void 0 : swap.claimTxid;
5890
6192
  var isPayoutDecided = (swap) => swap.state === "settled" || swap.state === "refunded" || swap.kind === "onchain_send" && swap.claimTxid !== void 0;
5891
6193
  var outcomeOf = (swap) => {
5892
- const lostReceive = swap.kind === "lightning_receive" && swap.state === "refunded";
6194
+ const lostReceive = (swap.kind === "lightning_receive" || swap.kind === "onchain_receive") && swap.state === "refunded";
5893
6195
  return {
5894
6196
  state: swap.state,
5895
6197
  txid: lostReceive ? swap.refundTxid : traderClaimTxid(swap) ?? swap.refundTxid
@@ -5897,11 +6199,11 @@ var outcomeOf = (swap) => {
5897
6199
  };
5898
6200
  var outcomeOfRecord = (stored) => {
5899
6201
  const record = normalizeRfqSwapRecord(stored);
5900
- const profileClaim = record.kind === "onchain_send" || record.kind === "lightning_receive" ? record.profile.claimTxid : void 0;
6202
+ const profileClaim = record.kind === "lightning_send" ? void 0 : record.profile.claimTxid;
5901
6203
  const claimTxid = typeof profileClaim === "string" ? profileClaim : void 0;
5902
6204
  return {
5903
6205
  state: record.state,
5904
- txid: record.kind === "lightning_receive" && record.state === "refunded" ? record.refundTxid : claimTxid ?? record.refundTxid
6206
+ txid: (record.kind === "lightning_receive" || record.kind === "onchain_receive") && record.state === "refunded" ? record.refundTxid : claimTxid ?? record.refundTxid
5905
6207
  };
5906
6208
  };
5907
6209
  var errorMessage = (error) => error instanceof Error ? error.message : String(error);
@@ -5909,7 +6211,7 @@ var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
5909
6211
 
5910
6212
  // src/watch.ts
5911
6213
  var import_base16 = require("@scure/base");
5912
- var import_sdk24 = require("@arkade-os/sdk");
6214
+ var import_sdk25 = require("@arkade-os/sdk");
5913
6215
  init_coverage();
5914
6216
  init_offer();
5915
6217
  init_store();
@@ -5944,7 +6246,7 @@ async function watchOfferSwaps({
5944
6246
  wallet.getAddress(),
5945
6247
  wallet.getArkadeReader()
5946
6248
  ]);
5947
- const operatorPubkey = import_sdk24.ArkAddress.decode(address).serverPubKey;
6249
+ const operatorPubkey = import_sdk25.ArkAddress.decode(address).serverPubKey;
5948
6250
  let queue = Promise.resolve();
5949
6251
  const enqueue = (task) => {
5950
6252
  queue = queue.then(task).catch(() => {
@@ -5959,7 +6261,7 @@ async function watchOfferSwaps({
5959
6261
  return classifyDepositSpend(
5960
6262
  decodeOffer(import_base16.hex.decode(swap.offerHex)),
5961
6263
  operatorPubkey,
5962
- txs.map((psbt) => import_sdk24.Transaction.fromPSBT(import_base16.base64.decode(psbt))),
6264
+ txs.map((psbt) => import_sdk25.Transaction.fromPSBT(import_base16.base64.decode(psbt))),
5963
6265
  { txid: vtxo.txid, vout: vtxo.vout }
5964
6266
  );
5965
6267
  } catch {
@@ -5987,7 +6289,7 @@ async function watchOfferSwaps({
5987
6289
  }
5988
6290
  };
5989
6291
  const unsubscribe = manager.onContractEvent((event) => {
5990
- if (!(0, import_sdk24.isContractVtxoEvent)(event) || event.type !== "vtxo_spent") return;
6292
+ if (!(0, import_sdk25.isContractVtxoEvent)(event) || event.type !== "vtxo_spent") return;
5991
6293
  enqueue(() => handleSpend(event));
5992
6294
  });
5993
6295
  return {
@@ -5997,7 +6299,7 @@ async function watchOfferSwaps({
5997
6299
  }
5998
6300
 
5999
6301
  // src/client/legacyRecords.ts
6000
- var import_sdk25 = require("@arkade-os/sdk");
6302
+ var import_sdk26 = require("@arkade-os/sdk");
6001
6303
  init_repository();
6002
6304
  var readLegacyRfqSwaps = async (repository, filter = {}) => {
6003
6305
  try {
@@ -6014,7 +6316,7 @@ var withLegacyRfqSwaps = (bridge, repository, admits) => {
6014
6316
  index: bridge.index,
6015
6317
  quoteIdOf: bridge.quoteIdOf,
6016
6318
  async getRfqSwapsPage(filter, page) {
6017
- (0, import_sdk25.assertPageRequest)(page);
6319
+ (0, import_sdk26.assertPageRequest)(page);
6018
6320
  assertRfqSwapPageFilter(filter);
6019
6321
  const v2 = await collectRfqSwaps(bridge, filter);
6020
6322
  const held = new Set(
@@ -6253,7 +6555,7 @@ var createSwapDrive = (config) => {
6253
6555
  const secret = rfqClaimSecretOf(record);
6254
6556
  if (!secret) throw new Error(`rfq swap ${swap.rfqId} carries no claim secret`);
6255
6557
  const preimage = await preimageForSwapRecord(wallet, secret);
6256
- const signer = await (0, import_sdk26.contractSigner)(wallet, await (0, import_sdk26.identityDescriptor)(wallet.identity));
6558
+ const signer = await (0, import_sdk27.contractSigner)(wallet, await (0, import_sdk27.identityDescriptor)(wallet.identity));
6257
6559
  const claimKey = record.profile.claimKey;
6258
6560
  if (typeof claimKey === "string") {
6259
6561
  const held = import_base17.hex.encode(await signer.xOnlyPublicKey());
@@ -6279,12 +6581,46 @@ var createSwapDrive = (config) => {
6279
6581
  return { txid };
6280
6582
  };
6281
6583
  };
6584
+ const defaultOnchainRefund = (chain, feeRateSatVb) => {
6585
+ return async (swap, utxo) => {
6586
+ const record = await corridorStore().getRfqSwap(swap.rfqId);
6587
+ if (!record) {
6588
+ throw new Error(`rfq swap ${swap.rfqId} has no stored record to refund from`);
6589
+ }
6590
+ const descriptor = record.profile.refundDescriptor;
6591
+ if (typeof descriptor !== "string") {
6592
+ throw new Error(
6593
+ `rfq swap ${swap.rfqId} carries no refund descriptor; wire the onchain corridor's refund callback to take its L1 funding back`
6594
+ );
6595
+ }
6596
+ const signer = await (0, import_sdk27.contractSigner)(wallet, descriptor);
6597
+ const held = import_base17.hex.encode(await signer.xOnlyPublicKey());
6598
+ if (held !== record.profile.refundKey) {
6599
+ throw new Error(
6600
+ `the key behind ${descriptor} is ${held}, not the refund key ${String(record.profile.refundKey)} rfq swap ${swap.rfqId}'s HTLC was derived with`
6601
+ );
6602
+ }
6603
+ const { txHex } = await buildHtlcRefund({
6604
+ htlc: swap.htlc,
6605
+ utxo,
6606
+ payoutPkScript: swap.refundPkScript,
6607
+ feeRateSatVb,
6608
+ sign: (sighash) => signer.signMessage(sighash, "schnorr")
6609
+ });
6610
+ return { txid: await track(chain.broadcast(txHex)) };
6611
+ };
6612
+ };
6282
6613
  const resolveOnchain = async () => {
6283
6614
  if (onchainSeams !== void 0) return onchainSeams !== null;
6284
6615
  try {
6285
6616
  const deps = (await corridors()).get("onchain").deps;
6286
6617
  const claim = deps.claim ?? (deps.claimFeeRateSatVb === void 0 ? void 0 : defaultOnchainClaim(deps.chain, deps.claimFeeRateSatVb));
6287
- onchainSeams = { chain: deps.chain, ...claim ? { claim } : {} };
6618
+ const refund = deps.refund ?? (deps.claimFeeRateSatVb === void 0 ? void 0 : defaultOnchainRefund(deps.chain, deps.claimFeeRateSatVb));
6619
+ onchainSeams = {
6620
+ chain: deps.chain,
6621
+ ...claim ? { claim } : {},
6622
+ ...refund ? { refund } : {}
6623
+ };
6288
6624
  managerDeps.chain = deps.chain;
6289
6625
  return true;
6290
6626
  } catch (error) {
@@ -6297,7 +6633,7 @@ var createSwapDrive = (config) => {
6297
6633
  }
6298
6634
  };
6299
6635
  const drivable = async (record) => !readsChain(record.kind) || await resolveOnchain();
6300
- const pinnedNetwork = async () => (0, import_sdk26.getNetwork)(await config.network());
6636
+ const pinnedNetwork = async () => (0, import_sdk27.getNetwork)(await config.network());
6301
6637
  const claimLockup = async (swap, vtxos, { partiallyClaimed }) => {
6302
6638
  const record = await corridorStore().getRfqSwap(swap.rfqId);
6303
6639
  if (!record) throw new Error(`rfq swap ${swap.rfqId} has no stored record to claim from`);
@@ -6312,10 +6648,10 @@ var createSwapDrive = (config) => {
6312
6648
  return track(
6313
6649
  pushClaim(operator, {
6314
6650
  contract: script,
6315
- receiver: await (0, import_sdk26.contractSigner)(wallet, secret.signingDescriptor),
6651
+ receiver: await (0, import_sdk27.contractSigner)(wallet, secret.signingDescriptor),
6316
6652
  preimage: await preimageForSwapRecord(wallet, secret),
6317
6653
  vtxos,
6318
- destinationPkScript: import_sdk26.ArkAddress.decode(payoutAddress).pkScript,
6654
+ destinationPkScript: import_sdk27.ArkAddress.decode(payoutAddress).pkScript,
6319
6655
  // Passed through: `pushClaim`'s own value check decides whether `P` is published.
6320
6656
  expectedAmount: swap.expectedAmount,
6321
6657
  partiallyClaimed,
@@ -6368,7 +6704,8 @@ var createSwapDrive = (config) => {
6368
6704
  },
6369
6705
  canRefundArkade,
6370
6706
  claimLockup,
6371
- ...onchainSeams?.claim ? { claimOnchain: onchainSeams.claim } : {}
6707
+ ...onchainSeams?.claim ? { claimOnchain: onchainSeams.claim } : {},
6708
+ ...onchainSeams?.refund ? { refundOnchain: onchainSeams.refund } : {}
6372
6709
  });
6373
6710
  };
6374
6711
  let offerSource;
@@ -6382,7 +6719,7 @@ var createSwapDrive = (config) => {
6382
6719
  config.network()
6383
6720
  ]);
6384
6721
  const txs = history.map(toRestoreTx);
6385
- const { hrp, serverPubKey: operatorPubkey } = import_sdk26.ArkAddress.decode(address);
6722
+ const { hrp, serverPubKey: operatorPubkey } = import_sdk27.ArkAddress.decode(address);
6386
6723
  const reopened = await legacyOfferDepositsToAdopt(store);
6387
6724
  for (const txid of reopen) reopened.add(txid);
6388
6725
  const cursor = reopened.size === 0 ? scanned : new Set([...scanned].filter((txid) => !reopened.has(txid)));
@@ -6852,7 +7189,8 @@ var SUPPORTED_PAIRS = [
6852
7189
  "arkade->arkade",
6853
7190
  "arkade->lightning",
6854
7191
  "lightning->arkade",
6855
- "arkade->onchain"
7192
+ "arkade->onchain",
7193
+ "onchain->arkade"
6856
7194
  ];
6857
7195
  var isSupportedPair = (pair) => SUPPORTED_PAIRS.includes(pair);
6858
7196
  var assembleRoute = (give, take) => {
@@ -6913,10 +7251,10 @@ var resolveRoute = async (input, deps) => {
6913
7251
  }
6914
7252
  const pair = `${giveLeg.corridor}->${takeLeg.corridor}`;
6915
7253
  if (!isSupportedPair(pair)) {
6916
- throw new UnsupportedRoute(
6917
- pair === "onchain->arkade" ? "onchain -> arkade is not served until the client owns the trader's L1 refund path end to end" : `${pair} is not an implemented route`,
6918
- { give: giveLeg.corridor, take: takeLeg.corridor }
6919
- );
7254
+ throw new UnsupportedRoute(`${pair} is not an implemented route`, {
7255
+ give: giveLeg.corridor,
7256
+ take: takeLeg.corridor
7257
+ });
6920
7258
  }
6921
7259
  const give = endpoint(
6922
7260
  giveLeg.corridor,
@@ -6982,6 +7320,11 @@ var pinAmount = (input, takeInstrument) => {
6982
7320
 
6983
7321
  // src/client/verify.ts
6984
7322
  init_rfq();
7323
+
7324
+ // src/client/policy.ts
7325
+ var DEFAULT_MAX_REFUND_WINDOW_SECONDS = 30 * 24 * 3600;
7326
+
7327
+ // src/client/verify.ts
6985
7328
  var reasonOf = (error) => error instanceof Error && typeof error.reason === "string" ? error.reason : void 0;
6986
7329
  var CHECK_BY_REASON = {
6987
7330
  invoice_expired: "invoice",
@@ -7132,6 +7475,22 @@ var verifyQuoteTtl = (input) => {
7132
7475
  throw new QuoteExpired(input.quoteId, input.expiresAt, input.now);
7133
7476
  }
7134
7477
  };
7478
+ var CSV_GRANULARITY_SECONDS = 512;
7479
+ var verifyRefundWindow = (input) => {
7480
+ const max = input.maxSeconds ?? DEFAULT_MAX_REFUND_WINDOW_SECONDS;
7481
+ const window = input.refundLocktime - input.now;
7482
+ if (!(window <= max)) {
7483
+ throw new QuoteVerificationFailed("refund_window", `at most ${max}s`, `${window}s`);
7484
+ }
7485
+ const delay = input.refundWithoutReceiverDelay;
7486
+ if (delay !== void 0 && !(delay < max + CSV_GRANULARITY_SECONDS)) {
7487
+ throw new QuoteVerificationFailed(
7488
+ "refund_window",
7489
+ `a solo-refund delay of at most ${max}s`,
7490
+ `${delay}s`
7491
+ );
7492
+ }
7493
+ };
7135
7494
  var verifyQuotedAmount = (input) => {
7136
7495
  verifyPinnedAmount(input);
7137
7496
  if (input.take > input.give) {
@@ -7266,7 +7625,7 @@ var verifyPlanLegs = (plan, legs, give) => {
7266
7625
 
7267
7626
  // src/client/quoteRfq.ts
7268
7627
  var import_base18 = require("@scure/base");
7269
- var import_sdk29 = require("@arkade-os/sdk");
7628
+ var import_sdk30 = require("@arkade-os/sdk");
7270
7629
  var import_solver_discovery9 = require("@arkade-os/solver-discovery");
7271
7630
  init_claimPacket();
7272
7631
  init_offer();
@@ -7275,11 +7634,11 @@ init_onchainHtlc();
7275
7634
  init_onchainHtlc();
7276
7635
 
7277
7636
  // src/payment/onchainSwap.ts
7278
- var import_sdk28 = require("@arkade-os/sdk");
7637
+ var import_sdk29 = require("@arkade-os/sdk");
7279
7638
  init_onchainHtlc();
7280
7639
 
7281
7640
  // src/payment/swapRail.ts
7282
- var import_sdk27 = require("@arkade-os/sdk");
7641
+ var import_sdk28 = require("@arkade-os/sdk");
7283
7642
 
7284
7643
  // src/client/sats.ts
7285
7644
  var satsOf = (value, field) => {
@@ -7376,7 +7735,7 @@ var resultOf = (railId, swap) => ({
7376
7735
  // the tx that left THIS wallet, as on every other rail; later legs are the client's to report
7377
7736
  ...swap.fundingTxid === void 0 ? {} : { txid: swap.fundingTxid }
7378
7737
  });
7379
- var swapHandle = async (railId, client, quote) => (0, import_sdk27.makeHandle)(railId, async (emit) => {
7738
+ var swapHandle = async (railId, client, quote) => (0, import_sdk28.makeHandle)(railId, async (emit) => {
7380
7739
  const accepted = await client.accept(quote);
7381
7740
  return await new Promise((resolve, reject) => {
7382
7741
  let finished = false;
@@ -7420,23 +7779,23 @@ function onchainSwapRail(client, deps) {
7420
7779
  });
7421
7780
  return {
7422
7781
  id: ONCHAIN_SWAP_RAIL,
7423
- match: (req) => (0, import_sdk28.btcTarget)(req.raw) !== void 0,
7782
+ match: (req) => (0, import_sdk29.btcTarget)(req.raw) !== void 0,
7424
7783
  available: async (req) => {
7425
- if ((0, import_sdk28.assetsOf)(req).length > 0) return false;
7426
- const address = (0, import_sdk28.btcTarget)(req.raw);
7784
+ if ((0, import_sdk29.assetsOf)(req).length > 0) return false;
7785
+ const address = (0, import_sdk29.btcTarget)(req.raw);
7427
7786
  if (address === void 0) return false;
7428
- const amount = (0, import_sdk28.tryResolveSendAmount)(req.raw, req.amount);
7787
+ const amount = (0, import_sdk29.tryResolveSendAmount)(req.raw, req.amount);
7429
7788
  if (amount === void 0) return false;
7430
7789
  if (BigInt(amount) < ONCHAIN_DUST_SATS) return false;
7431
7790
  return railAvailable(client, inputFor2(address, amount));
7432
7791
  },
7433
7792
  quote: async (req) => {
7434
- const address = (0, import_sdk28.btcTarget)(req.raw);
7793
+ const address = (0, import_sdk29.btcTarget)(req.raw);
7435
7794
  if (address === void 0) {
7436
7795
  throw new Error(`${ONCHAIN_SWAP_RAIL}: the request carries no bitcoin address`);
7437
7796
  }
7438
- (0, import_sdk28.assertNoAssets)(ONCHAIN_SWAP_RAIL, req);
7439
- const amount = (0, import_sdk28.resolveSendAmount)(ONCHAIN_SWAP_RAIL, req.raw, req.amount);
7797
+ (0, import_sdk29.assertNoAssets)(ONCHAIN_SWAP_RAIL, req);
7798
+ const amount = (0, import_sdk29.resolveSendAmount)(ONCHAIN_SWAP_RAIL, req.raw, req.amount);
7440
7799
  const quote = await client.quote(inputFor2(address, amount));
7441
7800
  const payout = quote.take.amount - claimFee;
7442
7801
  if (payout < ONCHAIN_DUST_SATS) {
@@ -7505,13 +7864,13 @@ var lockupOf = (derived) => ({
7505
7864
  pkScript: derived.swapPkScript
7506
7865
  });
7507
7866
  var covenantInputs = (input) => {
7508
- const network = (0, import_sdk29.networkFromArkadeInfo)(input.info);
7867
+ const network = (0, import_sdk30.networkFromArkadeInfo)(input.info);
7509
7868
  const arkade2 = input.corridors.get("arkade").deps;
7510
7869
  return {
7511
- operatorPubkey: (0, import_sdk29.toXOnly)(import_base18.hex.decode(input.info.signerPubkey), "ark signer key"),
7870
+ operatorPubkey: (0, import_sdk30.toXOnly)(import_base18.hex.decode(input.info.signerPubkey), "ark signer key"),
7512
7871
  // The resolved per-network pin, never operator-reported: it lands in a covenant leaf
7513
7872
  // that decides who can move the funds.
7514
- emulatorPubkey: (0, import_sdk29.toXOnly)(import_base18.hex.decode(arkade2.emulatorPubkey), "emulator signer key"),
7873
+ emulatorPubkey: (0, import_sdk30.toXOnly)(import_base18.hex.decode(arkade2.emulatorPubkey), "emulator signer key"),
7515
7874
  claimDelay: unilateralClaimDelay(Number(input.info.unilateralExitDelay)),
7516
7875
  hrp: network.hrp
7517
7876
  };
@@ -7548,6 +7907,8 @@ var quoteViaRfq = async (input) => {
7548
7907
  return quoteLightningReceive(input);
7549
7908
  case "arkade->onchain":
7550
7909
  return quoteOnchainSend(input);
7910
+ case "onchain->arkade":
7911
+ return quoteOnchainReceive(input);
7551
7912
  }
7552
7913
  };
7553
7914
  var quoteArkadeAsset = async (input) => {
@@ -7648,14 +8009,14 @@ var assetSidesOf = (legs) => {
7648
8009
  { give: "arkade", take: "arkade" }
7649
8010
  );
7650
8011
  }
7651
- return giveIsBtc ? { wantAsset: import_sdk29.asset.AssetId.fromString(legs.take.assetId) } : { offerAsset: import_sdk29.asset.AssetId.fromString(legs.give.assetId) };
8012
+ return giveIsBtc ? { wantAsset: import_sdk30.asset.AssetId.fromString(legs.take.assetId) } : { offerAsset: import_sdk30.asset.AssetId.fromString(legs.give.assetId) };
7652
8013
  };
7653
8014
  var makerPosition = async (wallet) => {
7654
8015
  const [address, publicKey] = await Promise.all([
7655
8016
  wallet.getAddress(),
7656
8017
  wallet.identity.xOnlyPublicKey()
7657
8018
  ]);
7658
- return { pkScript: import_sdk29.ArkAddress.decode(address).pkScript, publicKey };
8019
+ return { pkScript: import_sdk30.ArkAddress.decode(address).pkScript, publicKey };
7659
8020
  };
7660
8021
  var quoteLightningSend = async (input) => {
7661
8022
  const invoice = input.endpoints.take.instrument;
@@ -7664,7 +8025,7 @@ var quoteLightningSend = async (input) => {
7664
8025
  }
7665
8026
  const pair = rfqPairFor(input.legs.give, input.legs.take);
7666
8027
  const rfqId = newRfqId();
7667
- const secrets = await (0, import_sdk29.provisionRefundKey)(input.wallet);
8028
+ const secrets = await (0, import_sdk30.provisionRefundKey)(input.wallet);
7668
8029
  const wire = await input.transport.requestQuote(
7669
8030
  lightningSendRequest({
7670
8031
  rfqId,
@@ -7693,6 +8054,12 @@ var quoteLightningSend = async (input) => {
7693
8054
  now: input.now,
7694
8055
  invoiceExpiresAt: invoice.expiresAt
7695
8056
  });
8057
+ verifyRefundWindow({
8058
+ refundLocktime: derived.refundLocktime,
8059
+ refundWithoutReceiverDelay: derived.contractParams.refundWithoutReceiverDelay,
8060
+ now: input.now,
8061
+ maxSeconds: input.policy?.maxRefundWindowSeconds
8062
+ });
7696
8063
  verifyQuoteTtl({
7697
8064
  quoteId: input.quoteId,
7698
8065
  expiresAt: parsed.validUntil,
@@ -7733,7 +8100,7 @@ var quoteLightningReceive = async (input) => {
7733
8100
  const pinned = pinnedFor(input);
7734
8101
  const pair = rfqPairFor(input.legs.give, input.legs.take);
7735
8102
  const rfqId = newRfqId();
7736
- const secrets = await (0, import_sdk29.provisionClaimSecret)(input.wallet);
8103
+ const secrets = await (0, import_sdk30.provisionClaimSecret)(input.wallet);
7737
8104
  const paymentHash = import_base18.hex.encode(secrets.paymentHash);
7738
8105
  const payoutAddress = await input.wallet.getAddress();
7739
8106
  const lightning = input.corridors.get("lightning").deps;
@@ -7845,8 +8212,8 @@ var quoteOnchainSend = async (input) => {
7845
8212
  claimVsize: onchain.claimVsize
7846
8213
  }) : void 0;
7847
8214
  const quoted = claimFee === void 0 ? pinned : { on: pinned.on, value: pinned.value + claimFee, source: pinned.source };
7848
- const secrets = await (0, import_sdk29.provisionClaimSecret)(input.wallet);
7849
- const payoutKey = await (0, import_sdk29.provisionRefundKey)(input.wallet);
8215
+ const secrets = await (0, import_sdk30.provisionClaimSecret)(input.wallet);
8216
+ const payoutKey = await (0, import_sdk30.provisionRefundKey)(input.wallet);
7850
8217
  const paymentHash = import_base18.hex.encode(secrets.paymentHash);
7851
8218
  const wire = await input.transport.requestQuote(
7852
8219
  withCanonicalAmount(
@@ -7895,6 +8262,11 @@ var quoteOnchainSend = async (input) => {
7895
8262
  direction: "send"
7896
8263
  }
7897
8264
  });
8265
+ verifyRefundWindow({
8266
+ refundLocktime: derived.refundLocktime,
8267
+ now: input.now,
8268
+ maxSeconds: input.policy?.maxRefundWindowSeconds
8269
+ });
7898
8270
  verifyQuoteTtl({
7899
8271
  quoteId: input.quoteId,
7900
8272
  expiresAt: parsed.validUntil,
@@ -7941,9 +8313,121 @@ var quoteOnchainSend = async (input) => {
7941
8313
  }
7942
8314
  };
7943
8315
  };
8316
+ var quoteOnchainReceive = async (input) => {
8317
+ const pinned = pinnedFor(input);
8318
+ const pair = rfqPairFor(input.legs.give, input.legs.take);
8319
+ const rfqId = newRfqId();
8320
+ const l1Network = l1NetworkFromArk(input.info.network);
8321
+ const secrets = await (0, import_sdk30.provisionClaimSecret)(input.wallet);
8322
+ const refundKey = await (0, import_sdk30.provisionRefundKey)(input.wallet);
8323
+ const paymentHash = import_base18.hex.encode(secrets.paymentHash);
8324
+ const payoutAddress = await input.wallet.getAddress();
8325
+ const refundPkScript = l1ScriptForAddress(await input.wallet.getBoardingAddress(), l1Network);
8326
+ const wire = await input.transport.requestQuote(
8327
+ withCanonicalAmount(
8328
+ onchainReceiveRequest({
8329
+ rfqId,
8330
+ paymentHash,
8331
+ payoutAddress,
8332
+ payoutPubkey: secrets.pubkey,
8333
+ refundPubkey: refundKey.pubkey,
8334
+ // Placeholder: `withCanonicalAmount` writes the canonical decimal string.
8335
+ amount: 0,
8336
+ amountSide: toRfqAmountSide(pinned.on)
8337
+ }),
8338
+ pinned.value
8339
+ )
8340
+ );
8341
+ verifyPair(wire.pair, pair);
8342
+ const parsed = parseRfqQuote(wire);
8343
+ verifyQuotedAmount({ pair, pinned, give: parsed.give, take: parsed.take });
8344
+ const covenant = covenantInputs(input);
8345
+ const derived = verifyingDerivation(
8346
+ () => deriveOnchainReceive({
8347
+ quote: wire,
8348
+ paymentHash,
8349
+ payoutPubkey: secrets.pubkey,
8350
+ payoutAddress,
8351
+ refundPubkey: refundKey.pubkey,
8352
+ ...covenant,
8353
+ l1Network
8354
+ })
8355
+ );
8356
+ verifySendWindow({
8357
+ quote: wire,
8358
+ quoteId: input.quoteId,
8359
+ now: input.now,
8360
+ onchain: {
8361
+ htlcLocktime: derived.htlcLocktime,
8362
+ minConfirmations: derived.minConfirmations,
8363
+ direction: "receive"
8364
+ }
8365
+ });
8366
+ verifyRefundWindow({
8367
+ refundLocktime: derived.htlcLocktime,
8368
+ now: input.now,
8369
+ maxSeconds: input.policy?.maxRefundWindowSeconds
8370
+ });
8371
+ verifyQuoteTtl({
8372
+ quoteId: input.quoteId,
8373
+ expiresAt: parsed.validUntil,
8374
+ now: input.now,
8375
+ floorSeconds: input.policy?.quoteTtlFloorSeconds
8376
+ });
8377
+ const artifact = {
8378
+ kind: "deposit",
8379
+ corridor: "onchain",
8380
+ address: derived.htlc.address,
8381
+ asset: input.endpoints.give.asset,
8382
+ amount: parsed.give,
8383
+ expiresAt: parsed.validUntil
8384
+ };
8385
+ return {
8386
+ quote: {
8387
+ id: input.quoteId,
8388
+ route: assembleRoute(
8389
+ {
8390
+ ...input.endpoints.give,
8391
+ instrument: {
8392
+ kind: "address",
8393
+ address: derived.htlc.address,
8394
+ amount: parsed.give
8395
+ }
8396
+ },
8397
+ { ...input.endpoints.take, instrument: { kind: "wallet" } }
8398
+ ),
8399
+ give: { asset: input.endpoints.give.asset, amount: parsed.give },
8400
+ take: { asset: input.endpoints.take.asset, amount: parsed.take },
8401
+ lock: { hash: paymentHash },
8402
+ market: input.market,
8403
+ solver: parsed.solver,
8404
+ expiresAt: parsed.validUntil,
8405
+ refundLocktime: derived.refundLocktime,
8406
+ artifact,
8407
+ fee: { amount: parsed.give - parsed.take, asset: input.endpoints.give.asset }
8408
+ },
8409
+ preparation: {
8410
+ backend: "rfq",
8411
+ route: "onchain->arkade",
8412
+ card: input.candidate.card,
8413
+ rfqId,
8414
+ wire: parsed,
8415
+ lockup: lockupOf(derived),
8416
+ secrets,
8417
+ payoutAddress,
8418
+ expectedAmount: parsed.take,
8419
+ refundKey,
8420
+ refundPkScript,
8421
+ htlc: derived.htlc,
8422
+ htlcParams: derived.htlcParams,
8423
+ l1Network,
8424
+ minConfirmations: derived.minConfirmations
8425
+ }
8426
+ };
8427
+ };
7944
8428
 
7945
8429
  // src/client/verbs.ts
7946
- var import_sdk30 = require("@arkade-os/sdk");
8430
+ var import_sdk31 = require("@arkade-os/sdk");
7947
8431
  var enforceFeeCeiling = (quote, call, policy) => {
7948
8432
  let ceiling;
7949
8433
  for (const [source, limit] of [
@@ -7968,9 +8452,9 @@ var settle = async (deps, input, maxFee) => {
7968
8452
  return deps.accept(quote);
7969
8453
  };
7970
8454
  var pay = async (deps, destination, options = {}) => {
7971
- const arkade2 = (0, import_sdk30.arkTarget)(destination);
8455
+ const arkade2 = (0, import_sdk31.arkTarget)(destination);
7972
8456
  if (arkade2 !== void 0) {
7973
- const amount = (0, import_sdk30.resolveSendAmount)(
8457
+ const amount = (0, import_sdk31.resolveSendAmount)(
7974
8458
  "ark",
7975
8459
  destination,
7976
8460
  options.amount === void 0 ? void 0 : satsOf(options.amount, "amount")
@@ -8286,7 +8770,7 @@ init_rfq();
8286
8770
  init_repository();
8287
8771
 
8288
8772
  // src/indexedDbRepository.ts
8289
- var import_sdk31 = require("@arkade-os/sdk");
8773
+ var import_sdk33 = require("@arkade-os/sdk");
8290
8774
  init_repository();
8291
8775
  var DEFAULT_DB_NAME = "arkade-intents";
8292
8776
  var DB_VERSION = 5;
@@ -8329,7 +8813,7 @@ var IndexedDbAssetSwapRepository = class {
8329
8813
  version = 5;
8330
8814
  connection;
8331
8815
  constructor(dbName = DEFAULT_DB_NAME) {
8332
- this.connection = (0, import_sdk31.createManagedConnection)(dbName, DB_VERSION, initDatabase);
8816
+ this.connection = (0, import_sdk33.createManagedConnection)(dbName, DB_VERSION, initDatabase);
8333
8817
  }
8334
8818
  ensureDb() {
8335
8819
  return this.connection.get();
@@ -8342,7 +8826,7 @@ var IndexedDbAssetSwapRepository = class {
8342
8826
  * transaction, which `awaitTransaction` reports. */
8343
8827
  async write(name, apply) {
8344
8828
  const tx = (await this.ensureDb()).transaction([name], "readwrite");
8345
- const done = (0, import_sdk31.awaitTransaction)(tx);
8829
+ const done = (0, import_sdk33.awaitTransaction)(tx);
8346
8830
  apply(tx.objectStore(name));
8347
8831
  await done;
8348
8832
  }
@@ -8360,10 +8844,10 @@ var IndexedDbAssetSwapRepository = class {
8360
8844
  });
8361
8845
  }
8362
8846
  async getRfqSwap(rfqId) {
8363
- return (0, import_sdk31.promisifyRequest)((await this.readStore(STORE_RFQ_SWAPS)).get(rfqId));
8847
+ return (0, import_sdk33.promisifyRequest)((await this.readStore(STORE_RFQ_SWAPS)).get(rfqId));
8364
8848
  }
8365
8849
  async getRfqSwapsPage(filter, page) {
8366
- (0, import_sdk31.assertPageRequest)(page);
8850
+ (0, import_sdk33.assertPageRequest)(page);
8367
8851
  assertRfqSwapPageFilter(filter);
8368
8852
  const store = await this.readStore(STORE_RFQ_SWAPS);
8369
8853
  const state = filter.state;
@@ -8380,7 +8864,7 @@ var IndexedDbAssetSwapRepository = class {
8380
8864
  const cursor = request.result;
8381
8865
  if (!cursor || state !== void 0 && cursor.key[0] !== state) {
8382
8866
  resolve(
8383
- (0, import_sdk31.pageResult)(rows, page.limit, (row) => ({
8867
+ (0, import_sdk33.pageResult)(rows, page.limit, (row) => ({
8384
8868
  updatedAt: row.updatedAt,
8385
8869
  rfqId: row.rfqId
8386
8870
  }))
@@ -8390,7 +8874,7 @@ var IndexedDbAssetSwapRepository = class {
8390
8874
  rows.push(cursor.value);
8391
8875
  if (rows.length > page.limit) {
8392
8876
  resolve(
8393
- (0, import_sdk31.pageResult)(rows, page.limit, (row) => ({
8877
+ (0, import_sdk33.pageResult)(rows, page.limit, (row) => ({
8394
8878
  updatedAt: row.updatedAt,
8395
8879
  rfqId: row.rfqId
8396
8880
  }))
@@ -8412,13 +8896,13 @@ var IndexedDbAssetSwapRepository = class {
8412
8896
  });
8413
8897
  }
8414
8898
  async getSwapRecord(id) {
8415
- return (0, import_sdk31.promisifyRequest)((await this.readStore(STORE_SWAP_RECORDS)).get(id));
8899
+ return (0, import_sdk33.promisifyRequest)((await this.readStore(STORE_SWAP_RECORDS)).get(id));
8416
8900
  }
8417
8901
  async getSwapRecordsPage(page) {
8418
8902
  return this.pageStore(STORE_SWAP_RECORDS, page);
8419
8903
  }
8420
8904
  async pageStore(name, page) {
8421
- (0, import_sdk31.assertPageRequest)(page);
8905
+ (0, import_sdk33.assertPageRequest)(page);
8422
8906
  const store = await this.readStore(name);
8423
8907
  const range = page.after === void 0 ? void 0 : IDBKeyRange.lowerBound(page.after, true);
8424
8908
  const request = store.openCursor(range);
@@ -8441,7 +8925,7 @@ var IndexedDbAssetSwapRepository = class {
8441
8925
  });
8442
8926
  }
8443
8927
  resultOfPage(rows, limit) {
8444
- const result = (0, import_sdk31.pageResult)(rows, limit, (row) => row.key);
8928
+ const result = (0, import_sdk33.pageResult)(rows, limit, (row) => row.key);
8445
8929
  return {
8446
8930
  items: result.items.map((row) => row.value),
8447
8931
  ...result.nextCursor === void 0 ? {} : { nextCursor: result.nextCursor }
@@ -8453,7 +8937,7 @@ var IndexedDbAssetSwapRepository = class {
8453
8937
  });
8454
8938
  }
8455
8939
  async getScannedTxids() {
8456
- const keys = await (0, import_sdk31.promisifyRequest)((await this.readStore(STORE_SCANNED)).getAllKeys());
8940
+ const keys = await (0, import_sdk33.promisifyRequest)((await this.readStore(STORE_SCANNED)).getAllKeys());
8457
8941
  return new Set(keys);
8458
8942
  }
8459
8943
  async markTxidsScanned(txids) {
@@ -8463,7 +8947,7 @@ var IndexedDbAssetSwapRepository = class {
8463
8947
  }
8464
8948
  async getCachedMarkets(network, registry) {
8465
8949
  const store = await this.readStore(STORE_MARKETS);
8466
- return (0, import_sdk31.promisifyRequest)(store.get(marketsCacheKey(network, registry)));
8950
+ return (0, import_sdk33.promisifyRequest)(store.get(marketsCacheKey(network, registry)));
8467
8951
  }
8468
8952
  async saveCachedMarkets(network, registry, entry) {
8469
8953
  await this.write(STORE_MARKETS, (store) => {
@@ -8476,7 +8960,7 @@ var IndexedDbAssetSwapRepository = class {
8476
8960
  async clear() {
8477
8961
  const stores = STORES.map(([name]) => name);
8478
8962
  const tx = (await this.ensureDb()).transaction(stores, "readwrite");
8479
- const done = (0, import_sdk31.awaitTransaction)(tx);
8963
+ const done = (0, import_sdk33.awaitTransaction)(tx);
8480
8964
  for (const name of stores) tx.objectStore(name).clear();
8481
8965
  await done;
8482
8966
  }
@@ -8490,7 +8974,7 @@ init_claimPacket();
8490
8974
  init_lockupContract();
8491
8975
 
8492
8976
  // src/payment/lightning.ts
8493
- var import_sdk32 = require("@arkade-os/sdk");
8977
+ var import_sdk34 = require("@arkade-os/sdk");
8494
8978
  var LIGHTNING_RAIL = "lightning";
8495
8979
  var inputFor = (invoice, amount) => ({
8496
8980
  to: invoice,
@@ -8500,19 +8984,19 @@ function lightningRail(client) {
8500
8984
  return {
8501
8985
  id: LIGHTNING_RAIL,
8502
8986
  // classification only, so `match` is not a second gate on top of `available`
8503
- match: (req) => (0, import_sdk32.invoiceTarget)(req.raw) !== void 0,
8987
+ match: (req) => (0, import_sdk34.invoiceTarget)(req.raw) !== void 0,
8504
8988
  available: async (req) => {
8505
- if ((0, import_sdk32.assetsOf)(req).length > 0) return false;
8506
- const invoice = (0, import_sdk32.invoiceTarget)(req.raw);
8989
+ if ((0, import_sdk34.assetsOf)(req).length > 0) return false;
8990
+ const invoice = (0, import_sdk34.invoiceTarget)(req.raw);
8507
8991
  if (invoice === void 0) return false;
8508
8992
  return railAvailable(client, inputFor(invoice, req.amount));
8509
8993
  },
8510
8994
  quote: async (req) => {
8511
- const invoice = (0, import_sdk32.invoiceTarget)(req.raw);
8995
+ const invoice = (0, import_sdk34.invoiceTarget)(req.raw);
8512
8996
  if (invoice === void 0) {
8513
8997
  throw new Error(`${LIGHTNING_RAIL}: the request carries no BOLT11 invoice`);
8514
8998
  }
8515
- (0, import_sdk32.assertNoAssets)(LIGHTNING_RAIL, req);
8999
+ (0, import_sdk34.assertNoAssets)(LIGHTNING_RAIL, req);
8516
9000
  const quote = await client.quote(inputFor(invoice, req.amount));
8517
9001
  const amounts = receiverExact(LIGHTNING_RAIL, {
8518
9002
  amount: quote.take.amount,
@@ -8530,7 +9014,7 @@ function lightningRail(client) {
8530
9014
  }
8531
9015
 
8532
9016
  // src/payment/router.ts
8533
- var import_sdk33 = require("@arkade-os/sdk");
9017
+ var import_sdk35 = require("@arkade-os/sdk");
8534
9018
  var SWAP_ROUTER_PRIORITY = [
8535
9019
  "ark",
8536
9020
  LIGHTNING_RAIL,
@@ -8538,10 +9022,10 @@ var SWAP_ROUTER_PRIORITY = [
8538
9022
  "onchain"
8539
9023
  ];
8540
9024
  function createSwapPaymentRouter(wallet, client, config) {
8541
- return new import_sdk33.PaymentRouter({
9025
+ return new import_sdk35.PaymentRouter({
8542
9026
  wallet,
8543
9027
  prefs: { priority: [...SWAP_ROUTER_PRIORITY], ...config.prefs }
8544
- }).use((0, import_sdk33.arkRail)()).use((0, import_sdk33.onchainRail)({ feeInfo: (0, import_sdk33.walletFeeSource)(wallet) })).use(lightningRail(client)).use(onchainSwapRail(client, config));
9028
+ }).use((0, import_sdk35.arkRail)()).use((0, import_sdk35.onchainRail)({ feeInfo: (0, import_sdk35.walletFeeSource)(wallet) })).use(lightningRail(client)).use(onchainSwapRail(client, config));
8545
9029
  }
8546
9030
  // Annotate the CommonJS export names for ESM import in node:
8547
9031
  0 && (module.exports = {
@@ -8557,6 +9041,7 @@ function createSwapPaymentRouter(wallet, client, config) {
8557
9041
  BTC_ASSET_PART,
8558
9042
  CLAIM_PACKET_TYPE,
8559
9043
  ClientDisposed,
9044
+ DEFAULT_MAX_REFUND_WINDOW_SECONDS,
8560
9045
  DiscoverySnapshotUnavailable,
8561
9046
  InMemoryAssetSwapRepository,
8562
9047
  InconsistentRoute,