@arkade-os/swap 0.1.0-rc.8 → 0.1.0

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 (59) hide show
  1. package/README.md +45 -10
  2. package/dist/advanced.cjs +6429 -3083
  3. package/dist/advanced.d.cts +325 -282
  4. package/dist/advanced.d.ts +325 -282
  5. package/dist/advanced.js +343 -34
  6. package/dist/chunk-A3SHHRX4.js +104 -0
  7. package/dist/chunk-FMRAV77W.js +3065 -0
  8. package/dist/{chunk-HV7EIUE2.js → chunk-HRMWBULL.js} +1773 -634
  9. package/dist/chunk-WKJFXXSR.js +3382 -0
  10. package/dist/index.cjs +6868 -3837
  11. package/dist/index.d.cts +71 -243
  12. package/dist/index.d.ts +71 -243
  13. package/dist/index.js +139 -167
  14. package/dist/lockupContract-D7BNjksX.d.ts +148 -0
  15. package/dist/lockupContract-G-9CNRMq.d.cts +148 -0
  16. package/dist/node/index.cjs +61 -10
  17. package/dist/node/index.d.cts +310 -639
  18. package/dist/node/index.d.ts +310 -639
  19. package/dist/node/index.js +65 -10
  20. package/dist/nostr.cjs +428 -49
  21. package/dist/nostr.d.cts +59 -70
  22. package/dist/nostr.d.ts +59 -70
  23. package/dist/nostr.js +268 -36
  24. package/dist/offer-CcJfx5Fj.d.cts +269 -0
  25. package/dist/offer-DdB1M6FZ.d.ts +269 -0
  26. package/dist/offerFillPlan-BII0PW92.d.cts +1642 -0
  27. package/dist/offerFillPlan-CNTLVD7j.d.ts +1642 -0
  28. package/dist/protocol.cjs +5591 -4064
  29. package/dist/protocol.d.cts +258 -355
  30. package/dist/protocol.d.ts +258 -355
  31. package/dist/protocol.js +209 -228
  32. package/dist/repositories/realm/index.cjs +55 -11
  33. package/dist/repositories/realm/index.d.cts +18 -30
  34. package/dist/repositories/realm/index.d.ts +18 -30
  35. package/dist/repositories/realm/index.js +49 -12
  36. package/dist/repositories/sqlite/index.cjs +61 -10
  37. package/dist/repositories/sqlite/index.d.cts +7 -6
  38. package/dist/repositories/sqlite/index.d.ts +7 -6
  39. package/dist/repositories/sqlite/index.js +57 -11
  40. package/dist/repository-DmPzpbd7.d.ts +2342 -0
  41. package/dist/repository-DqdLVrVv.d.cts +2342 -0
  42. package/dist/rfq-C0tHOvn6.d.cts +983 -0
  43. package/dist/rfq-C0tHOvn6.d.ts +983 -0
  44. package/dist/watch-BonYT9af.d.cts +74 -0
  45. package/dist/watch-CmJQDtsy.d.ts +74 -0
  46. package/package.json +12 -12
  47. package/dist/chunk-4PATNGYQ.js +0 -3297
  48. package/dist/chunk-ARYFNDJY.js +0 -1432
  49. package/dist/chunk-U7VWWTL6.js +0 -66
  50. package/dist/errors-CSpOUdCN.d.ts +0 -2216
  51. package/dist/errors-DVn92LQd.d.cts +0 -2216
  52. package/dist/lockupContract-6TYZOBbn.d.ts +0 -490
  53. package/dist/lockupContract-aLCQQiSu.d.cts +0 -490
  54. package/dist/repository-D0gFF_GA.d.cts +0 -3491
  55. package/dist/repository-tDT8p-Nx.d.ts +0 -3491
  56. package/dist/rfq-DhkgiwQ7.d.cts +0 -1126
  57. package/dist/rfq-DhkgiwQ7.d.ts +0 -1126
  58. package/dist/watch-C4cMEeZT.d.cts +0 -96
  59. package/dist/watch-DbWXdpzm.d.ts +0 -96
@@ -1,62 +1,96 @@
1
1
  import {
2
- BTC_ASSET_ID,
2
+ DEGRADED_RETRY_MS,
3
3
  LOCKUP_OWNER,
4
4
  LockupNeedsRecoveryError,
5
5
  MARKETS_CACHE_TTL_MS,
6
- NoSpendableDepositError,
7
- OFFER_PACKET_TYPE,
8
- OfferCovenantMismatchError,
6
+ PAYMENT_HASH,
9
7
  QUOTE_OPTIONS,
10
- RETIRABLE,
11
8
  RefundNotLocallyPossibleError,
12
9
  RfqSwapManager,
13
10
  arkadeRefunder,
11
+ assertReceiverPaidEchoMatchesExpected,
12
+ assetPaymentFacts,
13
+ assetPaymentOf,
14
+ captureAssetPayment,
15
+ chainSourceFrom,
14
16
  classifyDepositSpend,
15
17
  corridorOutcome,
16
- createOffer,
17
- decodeOffer,
18
+ encodeCarrierRequest,
19
+ familyOfSwapId,
18
20
  findLockupVtxos,
21
+ fromAtomicDecimal,
22
+ fundingWasNotSubmitted,
23
+ fundsFromWallet,
19
24
  isRfqConfigurationRefusal,
20
25
  isRfqSwapTerminal,
21
26
  lightningCorridor,
22
27
  makeCachedFeedFetch,
28
+ marketAssetId,
29
+ marketCorridor,
30
+ marketPairLabel,
31
+ normalizeRfqSwapRecord,
23
32
  offerOutcome,
24
33
  onchainCorridor,
34
+ onchainReceiveProfile,
25
35
  onchainSendProfile,
26
- preimageForSwapRecord,
27
- prepareOfferCancel,
36
+ parseCarrierEcho,
37
+ parseTopLevelCarrierSats,
28
38
  pushClaim,
39
+ quoteIdOfSwapId,
29
40
  readsChain,
30
41
  rebuildRfqSwap,
42
+ recordArtifact,
43
+ recordAssetPayment,
44
+ recordEndpoint,
45
+ recordLeg,
31
46
  recordOutcome,
47
+ registryAnswered,
32
48
  restoreAssetSwaps,
33
- retireOfferContract,
34
- retireSettledOfferContracts,
35
- rfqClaimDestinationOf,
36
- rfqClaimSecretOf,
37
- rfqSecretsProfile,
38
- rfqSignerOf,
39
49
  rfqSwapOriginOf,
40
50
  senderIdentityForSwapRecord,
41
51
  spendTxidsOf,
52
+ storedFundingBounds,
53
+ swapOf,
54
+ toAtomicDecimal,
55
+ toRestoreTx,
56
+ trackDelivery,
57
+ transportCardsOf,
58
+ undeliveredCarry,
42
59
  walletOperator,
43
60
  watchOfferSwaps
44
- } from "./chunk-4PATNGYQ.js";
61
+ } from "./chunk-WKJFXXSR.js";
45
62
  import {
46
63
  ARKADE_BTC,
64
+ ASSET_CARRIER_SATS,
47
65
  AddressMismatch,
66
+ BTC_ASSET_ID,
48
67
  L1_NETWORKS,
49
68
  LIGHTNING_BTC,
69
+ LockupContractMissing,
70
+ NoSpendableDepositError,
71
+ OFFER_CONTRACT_KIND,
72
+ OFFER_PACKET_TYPE,
50
73
  ONCHAIN_BTC,
51
74
  ONCHAIN_CLAIM_VSIZE,
52
75
  ONCHAIN_DUST_SATS,
76
+ OfferCovenantMismatchError,
77
+ RETIRABLE,
53
78
  SwapRefusal,
79
+ arkadeSwapRequest,
80
+ assembleOfferFill,
54
81
  assertFundable,
55
82
  assertPairLength,
56
83
  assertReceivable,
84
+ bindsClaimAmount,
85
+ buildHtlcRefund,
57
86
  claimOnchainFill,
87
+ connectFillContract,
88
+ createOffer,
89
+ decodeOffer,
58
90
  deriveLightningReceive,
59
91
  deriveLightningSend,
92
+ deriveOffer,
93
+ deriveOnchainReceive,
60
94
  deriveOnchainSend,
61
95
  l1NetworkFromArk,
62
96
  l1ScriptForAddress,
@@ -64,12 +98,38 @@ import {
64
98
  lightningSendRequest,
65
99
  lockupContractParams,
66
100
  newRfqId,
101
+ nextClaimFeeRate,
102
+ offerTermsFromQuote,
103
+ onchainReceiveRequest,
67
104
  onchainSendRequest,
105
+ preimageForSwapRecord,
106
+ prepareOfferCancel,
107
+ promoteOfferContract,
108
+ quoteCarrierSats,
109
+ registerDerivedOffer,
68
110
  registerLockupContract,
111
+ resolveDeposit,
112
+ resolveReceivePkScript,
113
+ restoreOfferCoverage,
114
+ retireOfferContract,
115
+ retireSettledOfferContracts,
116
+ rfqClaimDestinationOf,
117
+ rfqClaimSecretOf,
69
118
  rfqPair,
119
+ rfqSecretsProfile,
120
+ rfqSignerOf,
70
121
  sealClaimPacket,
71
- unilateralClaimDelay
72
- } from "./chunk-ARYFNDJY.js";
122
+ swapPrograms,
123
+ unilateralClaimDelay,
124
+ verifyOfferAddress,
125
+ withExitClosure
126
+ } from "./chunk-FMRAV77W.js";
127
+ import {
128
+ assertRfqSwapPageFilter,
129
+ collectAssetSwaps,
130
+ collectRfqSwaps,
131
+ collectSwapRecords
132
+ } from "./chunk-A3SHHRX4.js";
73
133
 
74
134
  // src/client/assetId.ts
75
135
  import { asset, networks } from "@arkade-os/sdk";
@@ -92,10 +152,8 @@ var REFERENCE_RULE = {
92
152
  /** The 68-lowercase-hex identity form; `asset.AssetId` then re-validates it. */
93
153
  asset: /^[0-9a-f]{68}$/,
94
154
  /**
95
- * Reserved for §9. Lowercase, never EIP-55: a checksum belongs on an
96
- * address a human types, and an id here comes out of the alias table or a
97
- * market card. Mixed case would be two spellings of one asset comparing
98
- * unequal in a pair string, a record and a cache key.
155
+ * Reserved for §9. Lowercase, never EIP-55: mixed case would be two spellings of one asset
156
+ * comparing unequal in a pair string, a record and a cache key.
99
157
  */
100
158
  erc20: /^0x[0-9a-f]{40}$/
101
159
  };
@@ -207,11 +265,20 @@ var sameAsset = (a, b) => {
207
265
  const right = parseAssetId(b);
208
266
  return left.reference === right.reference && left.assetNamespace === right.assetNamespace && left.assetReference === right.assetReference;
209
267
  };
268
+ var btcAssetPart = (network) => network === "bitcoin" ? "slip44:0" : "slip44:1";
210
269
  var btcOn = (rail, network) => (
211
- // The checker will not resolve the conditional against an unbound `R`; the
212
- // assertion is confined to this expression and never reaches a call site.
213
- `${rail}:${network}/${BTC_ASSET_PART}`
270
+ // TS won't resolve the conditional against an unbound `R`; the cast stays in this expression.
271
+ `${rail}:${network}/${btcAssetPart(network)}`
214
272
  );
273
+ var isBtcAsset = (id) => {
274
+ const { rail, reference, assetNamespace, assetReference } = parseAssetId(id);
275
+ return rail !== "eip155" && `${assetNamespace}:${assetReference}` === btcAssetPart(reference);
276
+ };
277
+ var isBtcAssetLenient = (id) => {
278
+ if (isBtcAsset(id)) return true;
279
+ const { rail, assetNamespace, assetReference } = parseAssetId(id);
280
+ return rail !== "eip155" && assetNamespace === "slip44" && assetReference === "0";
281
+ };
215
282
  var arkadeAsset = (network, id) => `arkade:${network}/${ARKADE_ASSET_NAMESPACE}:${id.toString()}`;
216
283
  var issuanceOf = (id) => {
217
284
  const { assetNamespace, assetReference } = parseAssetId(id);
@@ -288,10 +355,10 @@ var QuoteExpired = class extends Error {
288
355
  name = "QuoteExpired";
289
356
  };
290
357
  var MaxFeeExceeded = class extends Error {
291
- constructor(quoteId, asset3, fee, maxFee) {
292
- super(`fee ${fee} of ${asset3} exceeds the ${maxFee} ceiling`);
358
+ constructor(quoteId, asset5, fee, maxFee) {
359
+ super(`fee ${fee} of ${asset5} exceeds the ${maxFee} ceiling`);
293
360
  this.quoteId = quoteId;
294
- this.asset = asset3;
361
+ this.asset = asset5;
295
362
  this.fee = fee;
296
363
  this.maxFee = maxFee;
297
364
  }
@@ -302,11 +369,11 @@ var MaxFeeExceeded = class extends Error {
302
369
  name = "MaxFeeExceeded";
303
370
  };
304
371
  var InsufficientFunds = class extends Error {
305
- constructor(asset3, required, available) {
372
+ constructor(asset5, required, available) {
306
373
  super(
307
- `funding needs ${required} of ${asset3}` + (available === void 0 ? "" : `, wallet holds ${available}`)
374
+ `funding needs ${required} of ${asset5}` + (available === void 0 ? "" : `, wallet holds ${available}`)
308
375
  );
309
- this.asset = asset3;
376
+ this.asset = asset5;
310
377
  this.required = required;
311
378
  this.available = available;
312
379
  }
@@ -344,9 +411,9 @@ var NotCancellable = class extends Error {
344
411
  name = "NotCancellable";
345
412
  };
346
413
  var InconsistentRoute = class extends Error {
347
- constructor(asset3, destination) {
348
- super(`destination ${JSON.stringify(destination)} is not on ${asset3}'s chain`);
349
- this.asset = asset3;
414
+ constructor(asset5, destination) {
415
+ super(`destination ${JSON.stringify(destination)} is not on ${asset5}'s chain`);
416
+ this.asset = asset5;
350
417
  this.destination = destination;
351
418
  }
352
419
  asset;
@@ -399,22 +466,27 @@ function isSwapError(e, name) {
399
466
  // src/client/aliases.ts
400
467
  import { NETWORKS, isNetwork } from "@arkade-os/solver-discovery";
401
468
  var toDiscoveryLeg = (id) => {
402
- const { rail, assetNamespace, assetReference } = parseAssetId(id);
403
- const asset3 = `${assetNamespace}:${assetReference}`;
469
+ const { rail, reference, assetNamespace, assetReference } = parseAssetId(id);
470
+ const asset5 = `${assetNamespace}:${assetReference}`;
471
+ const isBtc = isBtcAsset(id);
472
+ if (!isBtc && rail !== "eip155" && (asset5 === "slip44:0" || asset5 === "slip44:1")) {
473
+ const expected = btcOn(rail, reference);
474
+ throw new UnsupportedRoute(`${id} is not BTC on ${reference}: BTC there is ${expected}`);
475
+ }
404
476
  if (rail === "arkade") {
405
- if (asset3 === BTC_ASSET_PART) return { corridor: "arkade", assetId: BTC_ASSET_ID };
477
+ if (isBtc) return { corridor: "arkade", assetId: BTC_ASSET_ID, marketId: id };
406
478
  if (assetNamespace === ARKADE_ASSET_NAMESPACE) {
407
- return { corridor: "arkade", assetId: assetReference };
479
+ return { corridor: "arkade", assetId: assetReference, marketId: id };
408
480
  }
409
- throw new UnsupportedRoute(`the arkade corridor has no ${asset3}`);
481
+ throw new UnsupportedRoute(`the arkade corridor has no ${asset5}`);
410
482
  }
411
483
  if (rail === "bolt11") {
412
- if (asset3 === BTC_ASSET_PART) return { corridor: "lightning", assetId: BTC_ASSET_ID };
413
- throw new UnsupportedRoute(`the lightning corridor carries BTC only, not ${asset3}`);
484
+ if (isBtc) return { corridor: "lightning", assetId: BTC_ASSET_ID, marketId: id };
485
+ throw new UnsupportedRoute(`the lightning corridor carries BTC only, not ${asset5}`);
414
486
  }
415
487
  if (rail === "bitcoin") {
416
- if (asset3 === BTC_ASSET_PART) return { corridor: "onchain", assetId: BTC_ASSET_ID };
417
- throw new UnsupportedRoute(`the onchain corridor carries BTC only, not ${asset3}`);
488
+ if (isBtc) return { corridor: "onchain", assetId: BTC_ASSET_ID, marketId: id };
489
+ throw new UnsupportedRoute(`the onchain corridor carries BTC only, not ${asset5}`);
418
490
  }
419
491
  throw new UnsupportedRoute(`no corridor serves ${id}`);
420
492
  };
@@ -445,115 +517,8 @@ var canonicalAssetId = (input, table) => {
445
517
  return matches[0].id;
446
518
  };
447
519
 
448
- // src/client/amount.ts
449
- import {
450
- AMOUNT_PATTERN,
451
- MAX_ASSET_DECIMALS,
452
- fromAtomic,
453
- isAmount,
454
- toAtomic
455
- } from "@arkade-os/solver-discovery";
456
- var AmountFormatError = class extends Error {
457
- constructor(reason, message) {
458
- super(message);
459
- this.reason = reason;
460
- }
461
- reason;
462
- name = "AmountFormatError";
463
- };
464
- var SCALED_DECIMAL = /^([0-9]+)(?:\.([0-9]+))?$/;
465
- var ATOMIC_CEILING = 10n ** 30n;
466
- var MAX_SIGNIFICANT_DIGITS = 64;
467
- var assertDecimals = (decimals) => {
468
- if (!Number.isInteger(decimals) || decimals < 0 || decimals > MAX_ASSET_DECIMALS) {
469
- throw new AmountFormatError(
470
- "invalid_decimals",
471
- `decimals must be an integer in [0, ${MAX_ASSET_DECIMALS}], got ${decimals}`
472
- );
473
- }
474
- };
475
- var assertRepresentable = (value, what) => {
476
- if (value >= ATOMIC_CEILING) {
477
- throw new AmountFormatError(
478
- "too_large",
479
- `${what} does not fit the canonical 30-digit encoding`
480
- );
481
- }
482
- };
483
- var Amount = {
484
- /**
485
- * A human decimal into atomic units.
486
- *
487
- * `string` only, and no exponent. Accepting a `number` is the whole v1
488
- * footgun: it makes `100000` ambiguous between sats and whole BTC, and by
489
- * the time the ambiguity resolves the offer is funded. Exponent form goes
490
- * for the same reason — a UI never produces `1e-4`, so accepting it only
491
- * widens what a mistake can look like.
492
- *
493
- * Refuses rather than rounds when the input is finer than the asset: a
494
- * silently truncated amount is a swap for the wrong size, and nothing
495
- * downstream can tell it was ever a different number. Refuses too when the
496
- * result would not survive the record boundary, so one law holds in both
497
- * directions.
498
- */
499
- parse(display, asset3) {
500
- assertDecimals(asset3.decimals);
501
- const parts = SCALED_DECIMAL.exec(display);
502
- if (!parts) {
503
- throw new AmountFormatError(
504
- "not_decimal",
505
- `not an unsigned decimal amount: ${JSON.stringify(display)} (write 0.5, not .5; no sign, exponent, separator or space)`
506
- );
507
- }
508
- const [, whole, fraction = ""] = parts;
509
- if (fraction.length > asset3.decimals) {
510
- throw new AmountFormatError(
511
- "too_precise",
512
- `${display} has more precision than ${asset3.decimals} decimals allow`
513
- );
514
- }
515
- if (whole.length + fraction.length > MAX_SIGNIFICANT_DIGITS) {
516
- throw new AmountFormatError("too_large", `${display} has too many digits`);
517
- }
518
- const value = toAtomic(display, asset3.decimals);
519
- assertRepresentable(value, `${display} at ${asset3.decimals} decimals`);
520
- return value;
521
- },
522
- /**
523
- * Atomic units into a human decimal, trailing zeros trimmed.
524
- *
525
- * Refuses a negative: every amount on this surface is an obligation, and a
526
- * negative one is a defect upstream rather than a number to render.
527
- */
528
- format(value, asset3) {
529
- assertDecimals(asset3.decimals);
530
- if (value < 0n) {
531
- throw new AmountFormatError("negative", `amount must be non-negative, got ${value}`);
532
- }
533
- assertRepresentable(value, `${value}`);
534
- return fromAtomic(value, asset3.decimals);
535
- }
536
- };
537
- var toAtomicDecimal = (value) => {
538
- if (value < 0n) {
539
- throw new AmountFormatError("negative", `amount must be non-negative, got ${value}`);
540
- }
541
- assertRepresentable(value, `${value}`);
542
- return value.toString();
543
- };
544
- var fromAtomicDecimal = (text) => {
545
- if (!isAmount(text)) {
546
- throw new AmountFormatError(
547
- "not_canonical",
548
- `not a canonical atomic amount: ${JSON.stringify(text)}`
549
- );
550
- }
551
- return BigInt(text);
552
- };
553
- var isAtomicDecimal = (value) => typeof value === "string" && AMOUNT_PATTERN.test(value);
554
-
555
520
  // src/client/rfqAmount.ts
556
- import { isAmount as isAmount2 } from "@arkade-os/solver-discovery";
521
+ import { isAmount } from "@arkade-os/solver-discovery";
557
522
  var toRfqAmountSide = (on) => on === "give" ? "from" : "to";
558
523
  var fromRfqAmountSide = (side) => side === "from" ? "give" : "take";
559
524
  var encodeRfqAmount = (value, field) => {
@@ -570,7 +535,7 @@ var encodeRfqAmount = (value, field) => {
570
535
  };
571
536
  var decodeRfqAmount = (raw, field) => {
572
537
  if (typeof raw === "string") {
573
- if (!isAmount2(raw)) {
538
+ if (!isAmount(raw)) {
574
539
  throw new AmountEncodingUnsupported(
575
540
  field,
576
541
  raw,
@@ -584,8 +549,6 @@ var decodeRfqAmount = (raw, field) => {
584
549
  throw new AmountEncodingUnsupported(
585
550
  field,
586
551
  `${raw}`,
587
- // Past 2^53 the number arrived already rounded — there is no
588
- // "narrow carefully" branch, only a wrong amount.
589
552
  "a JSON number amount is only readable as a non-negative safe integer"
590
553
  );
591
554
  }
@@ -608,109 +571,48 @@ var toSafeNumber = (value, field) => {
608
571
  return Number(value);
609
572
  };
610
573
 
611
- // src/client/record.ts
612
- var assetSwapIdOf = (family, quoteId) => `${family}:${quoteId}`;
613
- var OFFER_SWAP_ID_PREFIX = "offer:";
614
- var RFQ_SWAP_ID_PREFIX = "rfq:";
615
- var familyOfSwapId = (swapId) => swapId.startsWith(OFFER_SWAP_ID_PREFIX) ? "offer" : swapId.startsWith(RFQ_SWAP_ID_PREFIX) ? "rfq" : void 0;
616
- var quoteIdOfSwapId = (swapId) => swapId.startsWith(OFFER_SWAP_ID_PREFIX) ? swapId.slice(OFFER_SWAP_ID_PREFIX.length) : swapId.startsWith(RFQ_SWAP_ID_PREFIX) ? swapId.slice(RFQ_SWAP_ID_PREFIX.length) : swapId;
617
- var recordEndpoint = (endpoint2) => ({
618
- corridor: endpoint2.corridor,
619
- asset: endpoint2.asset,
620
- instrument: recordInstrument(endpoint2.instrument)
621
- });
622
- var recordInstrument = (instrument) => {
623
- switch (instrument.kind) {
624
- case "wallet":
625
- return { kind: "wallet" };
626
- case "address":
627
- return { kind: "address", address: instrument.address };
628
- case "invoice":
629
- return {
630
- kind: "invoice",
631
- bolt11: instrument.bolt11,
632
- paymentHash: instrument.paymentHash,
633
- ...instrument.amount === void 0 ? {} : { amount: toAtomicDecimal(instrument.amount) },
634
- expiresAt: instrument.expiresAt
635
- };
636
- }
637
- };
638
- var instrumentOf = (instrument) => {
639
- switch (instrument.kind) {
640
- case "wallet":
641
- return { kind: "wallet" };
642
- case "address":
643
- return { kind: "address", address: instrument.address };
644
- case "invoice":
645
- return {
646
- kind: "invoice",
647
- bolt11: instrument.bolt11,
648
- paymentHash: instrument.paymentHash,
649
- ...instrument.amount === void 0 ? {} : { amount: fromAtomicDecimal(instrument.amount) },
650
- expiresAt: instrument.expiresAt
651
- };
574
+ // src/client/accept.ts
575
+ import { hex as hex2 } from "@scure/base";
576
+ import { stableStringify } from "@arkade-os/solver-discovery";
577
+ import {
578
+ asset as asset2,
579
+ getAllNormalizedVtxos,
580
+ SendDeadlineExceededError
581
+ } from "@arkade-os/sdk";
582
+
583
+ // src/client/fundingNotSubmitted.ts
584
+ import { ArkAddress } from "@arkade-os/sdk";
585
+ import { hex } from "@scure/base";
586
+ var retireUnsubmittedFunding = async (wallet, repository, record, contracts) => {
587
+ if (!fundingWasNotSubmitted(record)) return;
588
+ const script = record.family === "offer" ? record.swapPkScript : record.lockupPkScript;
589
+ try {
590
+ await retireOfferContract(
591
+ contracts ?? await wallet.getContractManager(),
592
+ async () => {
593
+ const records = await collectSwapRecords(repository);
594
+ const native = records.map((row) => ({
595
+ id: row.id,
596
+ swapPkScript: row.family === "offer" ? row.swapPkScript : row.lockupPkScript,
597
+ createdAt: row.createdAt * 1e3,
598
+ status: row.family === "offer" ? row.status : fundingWasNotSubmitted(row) ? "cancelled" : row.state === "settled" || row.state === "refunded" ? "fulfilled" : "pending"
599
+ }));
600
+ const legacy = (await collectRfqSwaps(repository)).map((row) => ({
601
+ swapPkScript: hex.encode(ArkAddress.decode(row.lockupAddress).pkScript),
602
+ createdAt: row.createdAt * 1e3,
603
+ status: row.state === "settled" || row.state === "refunded" ? "fulfilled" : "pending"
604
+ }));
605
+ return [...native, ...legacy];
606
+ },
607
+ script,
608
+ { scope: wallet }
609
+ );
610
+ } catch (error) {
611
+ console.warn(`[swap] could not retire unsent funding for ${record.id}`, error);
652
612
  }
653
613
  };
654
- var recordArtifact = (artifact) => artifact.kind === "invoice" ? { kind: "invoice", bolt11: artifact.bolt11 } : {
655
- kind: "deposit",
656
- corridor: artifact.corridor,
657
- address: artifact.address,
658
- asset: artifact.asset,
659
- amount: toAtomicDecimal(artifact.amount),
660
- ...artifact.expiresAt === void 0 ? {} : { expiresAt: artifact.expiresAt }
661
- };
662
- var artifactOf = (artifact) => artifact.kind === "invoice" ? { kind: "invoice", bolt11: artifact.bolt11 } : {
663
- kind: "deposit",
664
- corridor: artifact.corridor,
665
- address: artifact.address,
666
- asset: artifact.asset,
667
- amount: fromAtomicDecimal(artifact.amount),
668
- ...artifact.expiresAt === void 0 ? {} : { expiresAt: artifact.expiresAt }
669
- };
670
- var recordLeg = (leg) => ({
671
- asset: leg.asset,
672
- amount: toAtomicDecimal(leg.amount)
673
- });
674
- var legOf = (leg) => ({
675
- asset: leg.asset,
676
- amount: fromAtomicDecimal(leg.amount)
677
- });
678
- var swapOf = (record, outcome) => ({
679
- id: assetSwapIdOf(record.family, record.id),
680
- family: record.family,
681
- outcome,
682
- route: {
683
- give: {
684
- corridor: record.route.give.corridor,
685
- asset: record.route.give.asset,
686
- instrument: instrumentOf(record.route.give.instrument)
687
- },
688
- take: {
689
- corridor: record.route.take.corridor,
690
- asset: record.route.take.asset,
691
- instrument: instrumentOf(record.route.take.instrument)
692
- }
693
- },
694
- give: legOf(record.give),
695
- take: legOf(record.take),
696
- fee: legOf(record.fee),
697
- market: record.market,
698
- ...record.solver === void 0 ? {} : { solver: record.solver },
699
- ...record.family === "rfq" ? { lock: record.lock } : {},
700
- ...record.family === "rfq" ? { refundLocktime: record.refundLocktime } : {},
701
- ...record.artifact === void 0 ? {} : { artifact: artifactOf(record.artifact) },
702
- expiresAt: record.expiresAt,
703
- ...record.fundingTxid === void 0 ? {} : { fundingTxid: record.fundingTxid },
704
- ...record.failure === void 0 ? {} : { failure: record.failure },
705
- ...record.blockedReason === void 0 ? {} : { blockedReason: record.blockedReason },
706
- createdAt: record.createdAt,
707
- updatedAt: record.updatedAt
708
- });
709
- var fundsFromWallet = (route) => route.give.instrument.kind === "wallet";
710
614
 
711
615
  // src/client/accept.ts
712
- import { hex } from "@scure/base";
713
- import { asset as asset2, getAllNormalizedVtxos } from "@arkade-os/sdk";
714
616
  var acceptLocks = /* @__PURE__ */ new Map();
715
617
  var runSerialized = (id, body) => {
716
618
  const tail = acceptLocks.get(id) ?? Promise.resolve();
@@ -745,6 +647,7 @@ var conflictingFields = (record, quote) => {
745
647
  const incoming = recordedFacts(quote);
746
648
  const stored = {
747
649
  "route.pair": `${record.route.give.corridor}->${record.route.take.corridor}`,
650
+ assetPayment: assetPaymentFacts(record.assetPayment),
748
651
  "give.asset": record.route.give.asset,
749
652
  "take.asset": record.route.take.asset,
750
653
  "give.amount": record.give.amount,
@@ -768,6 +671,9 @@ var conflictingFields = (record, quote) => {
768
671
  };
769
672
  var recordedFacts = (quote) => ({
770
673
  "route.pair": `${quote.route.give.corridor}->${quote.route.take.corridor}`,
674
+ assetPayment: assetPaymentFacts(
675
+ quote.assetPayment === void 0 ? void 0 : recordAssetPayment(quote.assetPayment)
676
+ ),
771
677
  "give.asset": quote.route.give.asset,
772
678
  "take.asset": quote.route.take.asset,
773
679
  "give.amount": recordLeg(quote.give).amount,
@@ -783,21 +689,14 @@ var marketSourceOf = (market) => market.kind === "card" ? market.source : void 0
783
689
  var assertFundable2 = async (wallet, quote) => {
784
690
  const give = quote.give;
785
691
  const balance = await wallet.getBalance();
786
- if (assetPartOf(give.asset) === BTC_ASSET_PART) {
787
- const available2 = BigInt(balance.available);
788
- if (available2 < give.amount) {
789
- throw new InsufficientFunds(give.asset, give.amount, available2);
790
- }
791
- return;
792
- }
793
- const held = balance.availableAssets.find((a) => give.asset.endsWith(a.assetId));
794
- const available = held?.amount ?? 0n;
692
+ const available = isBtcAsset(give.asset) ? BigInt(balance.available) : balance.availableAssets.find((a) => give.asset.endsWith(a.assetId))?.amount ?? 0n;
795
693
  if (available < give.amount) {
796
694
  throw new InsufficientFunds(give.asset, give.amount, available);
797
695
  }
798
696
  };
799
697
  var commonOf = (quote, now) => ({
800
698
  id: quote.id,
699
+ ...quote.assetPayment === void 0 ? {} : { assetPayment: recordAssetPayment(quote.assetPayment) },
801
700
  route: {
802
701
  give: recordEndpoint(quote.route.give),
803
702
  take: recordEndpoint(quote.route.take)
@@ -820,24 +719,20 @@ var corridorRecord = (quote, preparation, now) => {
820
719
  ...commonOf(quote, now),
821
720
  family: "rfq",
822
721
  state: "pending",
823
- kind: kindOf(preparation),
722
+ kind: KIND_OF[preparation.route],
824
723
  rfqId: preparation.rfqId,
825
724
  lockupAddress: preparation.lockup.address,
826
- lockupPkScript: hex.encode(preparation.lockup.pkScript),
725
+ lockupPkScript: hex2.encode(preparation.lockup.pkScript),
827
726
  lock: { hash: quote.lock.hash },
828
727
  refundLocktime: quote.refundLocktime,
829
728
  profile: profileOf(preparation, quote.lock.hash)
830
729
  };
831
730
  };
832
- var kindOf = (preparation) => {
833
- switch (preparation.route) {
834
- case "arkade->lightning":
835
- return "lightning_send";
836
- case "lightning->arkade":
837
- return "lightning_receive";
838
- case "arkade->onchain":
839
- return "onchain_send";
840
- }
731
+ var KIND_OF = {
732
+ "arkade->lightning": "lightning_send",
733
+ "lightning->arkade": "lightning_receive",
734
+ "arkade->onchain": "onchain_send",
735
+ "onchain->arkade": "onchain_receive"
841
736
  };
842
737
  var profileOf = (preparation, paymentHash) => {
843
738
  const secrets = rfqSecretsProfile(preparation.secrets, paymentHash);
@@ -858,9 +753,24 @@ var profileOf = (preparation, paymentHash) => {
858
753
  htlcParams: preparation.htlcParams,
859
754
  l1Network: preparation.l1Network,
860
755
  minConfirmations: preparation.minConfirmations,
756
+ expectedAmount: toSafeNumber(preparation.expectedAmount, "expectedAmount"),
861
757
  payoutPkScript: preparation.payoutPkScript
862
758
  })
863
759
  };
760
+ case "onchain->arkade":
761
+ return {
762
+ ...secrets,
763
+ expectedAmount: toSafeNumber(preparation.expectedAmount, "expectedAmount"),
764
+ payoutAddress: preparation.payoutAddress,
765
+ ...onchainReceiveProfile({
766
+ htlc: preparation.htlc,
767
+ htlcParams: preparation.htlcParams,
768
+ l1Network: preparation.l1Network,
769
+ minConfirmations: preparation.minConfirmations,
770
+ refundPkScript: preparation.refundPkScript,
771
+ refundDescriptor: preparation.refundKey.descriptor
772
+ })
773
+ };
864
774
  }
865
775
  };
866
776
  var acceptQuote = async (input) => runSerialized(input.quote.id, () => acceptQuoteBody(input));
@@ -875,6 +785,7 @@ var acceptQuoteBody = async (input) => {
875
785
  if (fields.length > 0) {
876
786
  throw new AcceptConflict(quote.id, stored.id, fields);
877
787
  }
788
+ if (fundingWasNotSubmitted(stored)) return answer(stored);
878
789
  if (stored.fundingTxid !== void 0) return answer(stored);
879
790
  if (!fundsFromWallet(stored.route)) return answer(stored);
880
791
  const found = await reconcileFunding({ wallet }, stored);
@@ -882,7 +793,13 @@ var acceptQuoteBody = async (input) => {
882
793
  return answer(await stampFunding(repository, stored, found, now));
883
794
  }
884
795
  if (expired) throw new QuoteExpired(quote.id, quote.expiresAt, now);
885
- return answer(await fundAndStamp({ wallet, now }, stored, repository));
796
+ return answer(
797
+ await fundAndStamp(
798
+ { wallet, now, validUntil: input.validUntil, drive: input.drive },
799
+ stored,
800
+ repository
801
+ )
802
+ );
886
803
  }
887
804
  if (expired) throw new QuoteExpired(quote.id, quote.expiresAt, now);
888
805
  const preparation = input.preparation;
@@ -893,39 +810,117 @@ var acceptQuoteBody = async (input) => {
893
810
  }
894
811
  const funds = fundsFromWallet(quote.route);
895
812
  if (funds) await assertFundable2(wallet, quote);
896
- const record = preparation.backend === "feed" ? await registeredOfferRecord(input, preparation) : await registeredCorridorRecord(input, preparation);
813
+ const record = preparation.backend === "feed" ? await registeredOfferRecord(input, preparation) : preparation.route === "arkade->arkade" ? await registeredAssetRecord(input, preparation) : await registeredCorridorRecord(input, preparation);
897
814
  await repository.saveSwapRecord(record);
898
815
  if (!funds) return answer(record);
899
- return answer(await fundAndStamp({ wallet, now }, record, repository));
816
+ return answer(
817
+ await fundAndStamp(
818
+ {
819
+ wallet,
820
+ now,
821
+ validUntil: input.validUntil,
822
+ drive: input.drive,
823
+ firstFundingAttempt: true
824
+ },
825
+ record,
826
+ repository
827
+ )
828
+ );
900
829
  };
901
830
  var registeredOfferRecord = async (input, preparation) => {
902
831
  const { quote, wallet, corridors, now } = input;
903
832
  const { plan } = preparation;
904
- const arkade = corridors.get("arkade").deps;
833
+ const arkade2 = corridors.get("arkade").deps;
905
834
  const receiveIsBtc = plan.receive.asset.id === BTC_ASSET_ID;
906
- const offer = await createOffer(wallet, {
907
- // Keyed on the receive side: the covenant binds what the fill delivers.
908
- wantAmount: plan.receive.atomic,
909
- ...receiveIsBtc ? { offerAsset: asset2.AssetId.fromString(plan.deposit.asset.id) } : { wantAsset: asset2.AssetId.fromString(plan.receive.asset.id) },
910
- emulatorPubkey: arkade.emulatorPubkey
911
- });
835
+ const offer = await createOffer(
836
+ wallet,
837
+ {
838
+ // Keyed on the receive side: the covenant binds what the fill delivers.
839
+ wantAmount: plan.receive.atomic,
840
+ ...receiveIsBtc ? { offerAsset: asset2.AssetId.fromString(plan.deposit.asset.id) } : { wantAsset: asset2.AssetId.fromString(plan.receive.asset.id) },
841
+ emulatorPubkey: arkade2.emulatorPubkey
842
+ },
843
+ { coverageId: quote.id }
844
+ );
912
845
  return {
913
846
  ...commonOf(quote, now),
914
847
  family: "offer",
915
848
  status: "pending",
916
849
  offerHex: offer.offerHex,
917
850
  swapAddress: offer.address,
918
- swapPkScript: hex.encode(offer.swapPkScript)
851
+ swapPkScript: hex2.encode(offer.swapPkScript)
852
+ };
853
+ };
854
+ var registeredAssetRecord = async (input, preparation) => {
855
+ if (stableStringify(
856
+ input.quote.assetPayment === void 0 ? void 0 : recordAssetPayment(input.quote.assetPayment)
857
+ ) !== stableStringify(
858
+ preparation.assetPayment === void 0 ? void 0 : recordAssetPayment(preparation.assetPayment)
859
+ ))
860
+ throw new Error("asset payment differs from verified quote preparation");
861
+ if (preparation.assetPaymentRecipient !== void 0 && stableStringify(input.quote.route.take.instrument) !== stableStringify(preparation.assetPaymentRecipient))
862
+ throw new Error("asset payment recipient differs from verified quote preparation");
863
+ await registerDerivedOffer(input.wallet, preparation.offer, { coverageId: input.quote.id });
864
+ return {
865
+ ...commonOf(input.quote, input.now),
866
+ ...preparation.assetPayment === void 0 ? {} : { assetPayment: recordAssetPayment(preparation.assetPayment) },
867
+ family: "offer",
868
+ status: "pending",
869
+ offerHex: preparation.offer.offerHex,
870
+ swapAddress: preparation.offer.address,
871
+ swapPkScript: hex2.encode(preparation.offer.swapPkScript),
872
+ ...preparation.carrierSats === void 0 ? {} : { carrierSats: preparation.carrierSats.toString() }
919
873
  };
920
874
  };
921
875
  var registeredCorridorRecord = async (input, preparation) => {
922
876
  const contracts = await input.wallet.getContractManager();
923
- await registerLockupContract(contracts, preparation.lockup.script, preparation.lockup.address);
877
+ await registerLockupContract(contracts, preparation.lockup.script, preparation.lockup.address, {
878
+ coverageId: input.quote.id,
879
+ scope: input.wallet
880
+ });
881
+ await promoteOfferContract(
882
+ contracts,
883
+ hex2.encode(preparation.lockup.script.pkScript),
884
+ void 0,
885
+ {
886
+ coverageId: input.quote.id,
887
+ scope: input.wallet
888
+ }
889
+ );
924
890
  return corridorRecord(input.quote, preparation, input.now);
925
891
  };
926
892
  var fundAndStamp = async (input, record, repository) => {
927
- const txid = await fund(input, record);
928
- return stampFunding(repository, record, txid, input.now);
893
+ const bounds = storedFundingBounds(record.assetPayment, record.expiresAt);
894
+ const cap = input.validUntil === void 0 ? bounds.validUntil : Math.min(input.validUntil, bounds.validUntil ?? record.expiresAt);
895
+ const validUntil = cap === void 0 ? void 0 : Math.min(cap, record.expiresAt);
896
+ if (input.firstFundingAttempt && record.assetPayment !== void 0 && validUntil !== void 0 && validUntil < record.assetPayment.validUntil) {
897
+ record = { ...record, assetPayment: { ...record.assetPayment, validUntil } };
898
+ await repository.saveSwapRecord(record);
899
+ }
900
+ try {
901
+ const txid = await fund({ ...input, ...bounds, validUntil }, record);
902
+ return stampFunding(repository, record, txid, input.now);
903
+ } catch (error) {
904
+ if (input.firstFundingAttempt && validUntil !== void 0 && error instanceof SendDeadlineExceededError) {
905
+ const stopped = {
906
+ ...record,
907
+ ...record.family === "offer" ? { status: "cancelled" } : { state: "failed" },
908
+ fundingNotSubmitted: { reason: "send_deadline", validUntil },
909
+ updatedAt: Math.floor(Date.now() / 1e3)
910
+ };
911
+ try {
912
+ await repository.saveSwapRecord(stopped);
913
+ input.drive?.ingest(stopped);
914
+ await retireUnsubmittedFunding(input.wallet, repository, stopped);
915
+ } catch (cause) {
916
+ console.warn(
917
+ `[swap] could not finish unsent funding cleanup for ${record.id}`,
918
+ cause
919
+ );
920
+ }
921
+ }
922
+ throw error;
923
+ }
929
924
  };
930
925
  var stampFunding = async (repository, record, fundingTxid, now) => {
931
926
  const stamped = { ...record, fundingTxid, updatedAt: now };
@@ -938,14 +933,20 @@ var stampFunding = async (repository, record, fundingTxid, now) => {
938
933
  };
939
934
  var fund = async (input, record) => {
940
935
  const { wallet } = input;
936
+ const send = (recipient) => input.validUntil === void 0 && input.inputExpiryFloor === void 0 ? wallet.send(recipient) : wallet.send({
937
+ recipients: [recipient],
938
+ ...input.validUntil === void 0 ? {} : { validUntil: input.validUntil },
939
+ ...input.inputExpiryFloor === void 0 ? {} : { inputExpiryFloor: input.inputExpiryFloor }
940
+ });
941
941
  if (record.family === "offer") {
942
942
  const amount = fromAtomicDecimal(record.give.amount);
943
- const depositIsBtc = assetPartOf(record.route.give.asset) === BTC_ASSET_PART;
944
- return wallet.send({
943
+ const depositIsBtc = isBtcAssetLenient(record.route.give.asset);
944
+ return send({
945
945
  address: record.swapAddress,
946
- // An asset deposit rides the SDK's dust-sat carrier, so the sats
947
- // amount is left to the default rather than set here.
946
+ // An asset deposit rides a dust-sat carrier: the solver's published one when the record
947
+ // names it (the fill is priced against it), else the SDK default.
948
948
  ...depositIsBtc ? { amount: toSafeNumber(amount, "give.amount") } : {
949
+ ...record.carrierSats === void 0 ? {} : { amount: toSafeNumber(BigInt(record.carrierSats), "carrierSats") },
949
950
  assets: [
950
951
  { assetId: toDiscoveryLeg(record.route.give.asset).assetId, amount }
951
952
  ]
@@ -953,17 +954,17 @@ var fund = async (input, record) => {
953
954
  extensions: [offerExtensionOf(record)]
954
955
  });
955
956
  }
956
- if (record.kind === "lightning_receive") {
957
+ if (record.kind === "lightning_receive" || record.kind === "onchain_receive") {
957
958
  throw new Error(`receive swap ${record.id} funds nothing from this wallet`);
958
959
  }
959
- return wallet.send({
960
+ return send({
960
961
  address: record.lockupAddress,
961
962
  amount: toSafeNumber(fromAtomicDecimal(record.give.amount), "give.amount")
962
963
  });
963
964
  };
964
965
  var offerExtensionOf = (record) => ({
965
966
  type: OFFER_PACKET_TYPE,
966
- payload: hex.decode(record.offerHex)
967
+ payload: hex2.decode(record.offerHex)
967
968
  });
968
969
  var reconcileFunding = async (input, record) => {
969
970
  const script = record.family === "offer" ? record.swapPkScript : record.lockupPkScript;
@@ -975,7 +976,7 @@ var reconcileFunding = async (input, record) => {
975
976
  };
976
977
  var depositMatches = (vtxo, record, expected) => {
977
978
  const giveAsset = record.route.give.asset;
978
- if (assetPartOf(giveAsset) === BTC_ASSET_PART) {
979
+ if (isBtcAssetLenient(giveAsset)) {
979
980
  return BigInt(vtxo.value) === expected;
980
981
  }
981
982
  return (vtxo.assets ?? []).some(
@@ -985,10 +986,7 @@ var depositMatches = (vtxo, record, expected) => {
985
986
  var swapRecordOf = async (repository, id) => storageOf(repository).getSwapRecord(id);
986
987
 
987
988
  // src/client/corridor.ts
988
- import {
989
- CORRIDORS as DISCOVERY_CORRIDORS
990
- } from "@arkade-os/solver-discovery";
991
- var CORRIDORS = DISCOVERY_CORRIDORS;
989
+ var CORRIDORS = ["arkade", "lightning", "onchain"];
992
990
  var RAIL_BY_CORRIDOR = {
993
991
  arkade: "arkade",
994
992
  lightning: "bolt11",
@@ -1003,7 +1001,6 @@ var railOfCorridor = (corridor) => corridor in RAIL_BY_CORRIDOR ? RAIL_BY_CORRID
1003
1001
  var corridorOfRail = (rail) => rail === "eip155" ? void 0 : CORRIDOR_BY_RAIL[rail];
1004
1002
 
1005
1003
  // src/client/aliasTable.ts
1006
- import { marketCorridor } from "@arkade-os/solver-discovery";
1007
1004
  var ARKADE_ASSET_IDENTITY = /^[0-9a-f]{68}$/;
1008
1005
  var publicAssetId = (corridor, assetId, network) => {
1009
1006
  const rail = railOfCorridor(corridor);
@@ -1016,7 +1013,10 @@ var aliasTableFrom = (markets, network) => {
1016
1013
  const rows = /* @__PURE__ */ new Map();
1017
1014
  const add = (card, side) => {
1018
1015
  const info = side === "base" ? card.base_asset : card.quote_asset;
1019
- const id = publicAssetId(marketCorridor(card, side), info.id, network);
1016
+ const corridor = corridorOfRail(marketCorridor(card, side));
1017
+ if (corridor === void 0) return;
1018
+ const canonical = marketAssetId(card, side);
1019
+ const id = canonical !== void 0 && isAssetId(canonical) ? canonical : publicAssetId(corridor, info.id, network);
1020
1020
  if (id === void 0 || typeof info.ticker !== "string" || info.ticker === "") return;
1021
1021
  rows.set(`${id} ${info.ticker.toLowerCase()}`, { id, ticker: info.ticker });
1022
1022
  };
@@ -1032,7 +1032,7 @@ var scopedToRail = (table, rail) => ({
1032
1032
  });
1033
1033
 
1034
1034
  // src/client/corridors/arkade.ts
1035
- import { ArkAddress, arkTarget, assertRecipientArkadeAddress } from "@arkade-os/sdk";
1035
+ import { ArkAddress as ArkAddress2, arkTarget, assertRecipientArkadeAddress } from "@arkade-os/sdk";
1036
1036
  var ARKADE_DRIVE = {};
1037
1037
  var messageOf = (error) => error instanceof Error ? error.message : String(error);
1038
1038
  var arkadeCorridor = Object.assign(
@@ -1044,7 +1044,7 @@ var arkadeCorridor = Object.assign(
1044
1044
  const target = arkTarget(raw);
1045
1045
  if (target === void 0) return void 0;
1046
1046
  try {
1047
- const address = ArkAddress.decode(target);
1047
+ const address = ArkAddress2.decode(target);
1048
1048
  assertRecipientArkadeAddress(target, address, {
1049
1049
  hrp: deps.network.hrp,
1050
1050
  signerSet: deps.signerSet
@@ -1064,7 +1064,6 @@ var DEFAULT_INVOICE_EXPIRY_SECONDS = 3600;
1064
1064
  var valueOf = (decoded, name) => decoded.sections.find(
1065
1065
  (section) => section.name === name
1066
1066
  )?.value;
1067
- var PAYMENT_HASH = /^[0-9a-f]{64}$/;
1068
1067
  var decodeBolt11 = (invoice) => {
1069
1068
  const decoded = bolt11.decode(invoice);
1070
1069
  const timestamp = valueOf(decoded, "timestamp");
@@ -1086,7 +1085,7 @@ var decodeBolt11 = (invoice) => {
1086
1085
  };
1087
1086
 
1088
1087
  // src/client/corridors/chainSource.ts
1089
- import { hex as hex2 } from "@scure/base";
1088
+ import { hex as hex3 } from "@scure/base";
1090
1089
  import * as btc from "@scure/btc-signer";
1091
1090
  import { EsploraProvider } from "@arkade-os/sdk";
1092
1091
  var addressOfScript = (script, network) => btc.Address(network).encode(btc.OutScript.decode(script));
@@ -1115,11 +1114,8 @@ var chainSourceOver = (backend, network) => {
1115
1114
  return coins.map((coin) => ({
1116
1115
  txid: coin.txid,
1117
1116
  vout: coin.vout,
1118
- // `Coin.value` is `number` sats; the HTLC's is `bigint`.
1119
1117
  amount: BigInt(coin.value),
1120
- // `Coin` carries a height, never a depth, so the tip is the
1121
- // second half of the answer. A confirmed coin is one deep, not
1122
- // zero — the block it landed in counts.
1118
+ // A confirmed coin is one deep, not zero: its own block counts.
1123
1119
  confirmations: coin.status.confirmed && coin.status.block_height !== void 0 ? Math.max(0, tip.height - coin.status.block_height + 1) : 0
1124
1120
  }));
1125
1121
  },
@@ -1129,13 +1125,19 @@ var chainSourceOver = (backend, network) => {
1129
1125
  if (!outspend?.spent) return null;
1130
1126
  const spender = outspend.txid || await spenderFromVins(txid, vout, pkScript);
1131
1127
  if (!spender) return null;
1132
- return { txHex: hex2.encode(await backend.provider.getRawTransaction(spender)) };
1128
+ return { txHex: hex3.encode(await backend.provider.getRawTransaction(spender)) };
1133
1129
  },
1134
1130
  broadcast(txHex) {
1135
1131
  return backend.provider.broadcastTransaction(txHex);
1136
1132
  },
1137
1133
  async getMtp() {
1138
1134
  return (await backend.tip()).mtp;
1135
+ },
1136
+ async getTxStatus(txid) {
1137
+ return (await backend.provider.getTxStatus(txid)).confirmed ? "confirmed" : "unconfirmed";
1138
+ },
1139
+ getFeeRate() {
1140
+ return backend.provider.getFeeRate();
1139
1141
  }
1140
1142
  };
1141
1143
  };
@@ -1178,6 +1180,12 @@ var refusedIfNull = (value, corridor, dep) => {
1178
1180
  if (value === null) throw new MissingCorridorDep(corridor, dep);
1179
1181
  return value;
1180
1182
  };
1183
+ var refusedIfMalformed = (value, dep) => {
1184
+ if (value !== void 0 && value !== null && !(Number.isFinite(value) && value > 0)) {
1185
+ throw new MissingCorridorDep("onchain", dep);
1186
+ }
1187
+ return value;
1188
+ };
1181
1189
  var emulatorPubkeyFor = (base) => {
1182
1190
  if (base.emulatorPubkey !== void 0) {
1183
1191
  return resolveEmulatorPubkey(base.network, base.emulatorPubkey);
@@ -1219,26 +1227,27 @@ function resolveCorridorDeps(corridor, overrides, base) {
1219
1227
  case "onchain": {
1220
1228
  const chain = refusedIfNull(overrides?.onchain?.chain, "onchain", "chain source");
1221
1229
  const claim = refusedIfNull(overrides?.onchain?.claim, "onchain", "L1 claim callback");
1222
- const feeRateOverride = overrides?.onchain?.claimFeeRateSatVb;
1223
- if (feeRateOverride !== void 0 && feeRateOverride !== null && !(Number.isFinite(feeRateOverride) && feeRateOverride > 0)) {
1224
- throw new MissingCorridorDep("onchain", "L1 claim fee rate");
1225
- }
1230
+ const refund = refusedIfNull(
1231
+ overrides?.onchain?.refund,
1232
+ "onchain",
1233
+ "L1 refund callback"
1234
+ );
1235
+ const feeRateOverride = refusedIfMalformed(
1236
+ overrides?.onchain?.claimFeeRateSatVb,
1237
+ "L1 claim fee rate"
1238
+ );
1226
1239
  const claimFeeRateSatVb = feeRateOverride === null ? void 0 : feeRateOverride ?? ONCHAIN_CLAIM_FEE_RATE_SATVB[base.networkName];
1227
- const vsizeOverride = overrides?.onchain?.claimVsize;
1228
- if (vsizeOverride !== void 0 && vsizeOverride !== null && !(Number.isFinite(vsizeOverride) && vsizeOverride > 0)) {
1229
- throw new MissingCorridorDep("onchain", "L1 claim vsize");
1230
- }
1231
- const claimVsize = vsizeOverride === null ? ONCHAIN_CLAIM_VSIZE : vsizeOverride ?? ONCHAIN_CLAIM_VSIZE;
1240
+ const claimVsize = refusedIfMalformed(overrides?.onchain?.claimVsize, "L1 claim vsize") ?? ONCHAIN_CLAIM_VSIZE;
1241
+ const l1Network = l1NetworkFromArk(base.networkName);
1232
1242
  return {
1233
1243
  networkName: base.networkName,
1234
- chain: esploraChainSource({
1244
+ chain: chain && "provider" in chain ? chainSourceFrom(chain.provider, l1Network) : esploraChainSource({
1235
1245
  esploraUrl: chain?.esploraUrl ?? ESPLORA_URL[base.networkName],
1236
- network: L1_NETWORKS[l1NetworkFromArk(base.networkName)],
1246
+ network: L1_NETWORKS[l1Network],
1237
1247
  fetchImpl: base.fetchImpl
1238
1248
  }),
1239
1249
  ...claim === void 0 ? {} : { claim },
1240
- // Absent-on-an-unknown-network and explicitly-off read the
1241
- // same: no default claim path, manual mode.
1250
+ ...refund === void 0 ? {} : { refund },
1242
1251
  ...claimFeeRateSatVb === void 0 ? {} : { claimFeeRateSatVb },
1243
1252
  claimVsize
1244
1253
  };
@@ -1331,13 +1340,19 @@ var REGISTRY_URL = {
1331
1340
  regtest: "https://arkade-os.github.io/solver-registry/regtest.json"
1332
1341
  };
1333
1342
  var HEX_64 = /^[0-9a-f]{64}$/;
1343
+ var LEGACY_ASSET_ID = /^(?:btc|[0-9a-f]{68})$/;
1334
1344
  var isRelayList = (value) => Array.isArray(value) && value.length > 0 && value.length <= MAX_RELAYS && value.every((relay) => typeof relay === "string" && relay.startsWith("wss://"));
1335
1345
  var isCorridorField = (value) => value === void 0 || CORRIDORS.includes(value);
1336
1346
  var isUsableCard = (value) => {
1337
1347
  const card = value;
1338
- if (typeof card?.pair !== "string" || typeof card.solver !== "string" || typeof card.source !== "string" || card.sourceType !== "registry" && card.sourceType !== "local" || typeof card.base_asset?.id !== "string" || typeof card.quote_asset?.id !== "string" || typeof card.base_asset.decimals !== "number" || typeof card.quote_asset.decimals !== "number" || !isCorridorField(card.base_corridor) || !isCorridorField(card.quote_corridor)) {
1348
+ if (!card) return false;
1349
+ if (card.pair !== void 0 && typeof card.pair !== "string" || typeof card.solver !== "string" || typeof card.source !== "string" || card.sourceType !== "registry" && card.sourceType !== "local" || typeof card.base_asset?.id !== "string" || typeof card.quote_asset?.id !== "string" || typeof card.base_asset.decimals !== "number" || typeof card.quote_asset.decimals !== "number" || !isCorridorField(card.base_corridor) || !isCorridorField(card.quote_corridor)) {
1339
1350
  return false;
1340
1351
  }
1352
+ for (const side of ["base", "quote"]) {
1353
+ const id = marketAssetId(card, side);
1354
+ if (id === void 0 || !isAssetId(id) && !LEGACY_ASSET_ID.test(id)) return false;
1355
+ }
1341
1356
  if (isRfqMarket(card)) {
1342
1357
  if (typeof card.discovery_pubkey !== "string" || !HEX_64.test(card.discovery_pubkey)) {
1343
1358
  return false;
@@ -1365,6 +1380,7 @@ var discoveryIndex = (input) => {
1365
1380
  ref: { fetchedAt: Date.now(), live: true, source: "injected" }
1366
1381
  };
1367
1382
  let held;
1383
+ let revalidateAt = 0;
1368
1384
  const unavailable = (detail) => {
1369
1385
  throw new DiscoverySnapshotUnavailable(input.network, detail);
1370
1386
  };
@@ -1388,8 +1404,7 @@ var discoveryIndex = (input) => {
1388
1404
  markets: cached.markets,
1389
1405
  ref: {
1390
1406
  fetchedAt: cached.fetchedAt,
1391
- // The cards were read back out of local storage, whatever their
1392
- // age: nothing here can attest that a registry ever served them.
1407
+ // Whatever its age: nothing attests a registry ever served these cards.
1393
1408
  live: false,
1394
1409
  source: "cache",
1395
1410
  registry: url
@@ -1404,30 +1419,50 @@ var discoveryIndex = (input) => {
1404
1419
  held = cached;
1405
1420
  return cached;
1406
1421
  }
1422
+ const { network: indexed, registry: url } = sources();
1423
+ if (indexed && url && config.localCards?.length) {
1424
+ const { markets } = await discover({
1425
+ registries: [],
1426
+ localCards: [...config.localCards],
1427
+ network: indexed
1428
+ });
1429
+ if (markets.length > 0) {
1430
+ return { markets, ref: { fetchedAt: Date.now(), live: true, source: "local" } };
1431
+ }
1432
+ }
1407
1433
  return unavailable(whyUnavailable());
1408
1434
  };
1409
1435
  const load = async (opts = {}) => {
1410
1436
  if (injected) return injected;
1411
- const fresh = held?.ref.live === true && Date.now() - held.ref.fetchedAt < MARKETS_CACHE_TTL_MS;
1437
+ const fresh = held?.ref.live === true && Date.now() < revalidateAt;
1412
1438
  if (fresh && !opts.refresh) return held;
1413
1439
  const { network: indexed, registry: url } = sources();
1414
1440
  if (!indexed || !url) {
1415
1441
  return unavailable(whyUnavailable());
1416
1442
  }
1443
+ const delivery = trackDelivery(transportCardsOf(config.transportCards));
1417
1444
  const result = await discover({
1418
1445
  registries: [url],
1419
1446
  localCards: [...config.localCards ?? []],
1420
1447
  network: indexed,
1421
- fetchImpl: config.fetchImpl
1448
+ fetchImpl: config.fetchImpl,
1449
+ transportCards: delivery.fetcher
1422
1450
  });
1423
1451
  if (result.warnings.length) config.logger?.("solver discovery:", ...result.warnings);
1424
- if (result.sources.some((source) => source.ok)) {
1452
+ if (registryAnswered(result.sources)) {
1425
1453
  const fetchedAt = Date.now();
1426
1454
  held = {
1427
1455
  markets: result.markets,
1428
1456
  ref: { fetchedAt, live: true, source: "live", registry: url }
1429
1457
  };
1430
- if (input.repository) {
1458
+ const undelivered = delivery.undelivered();
1459
+ const keepsCache = undelivered.size > 0 && input.repository !== void 0 && undeliveredCarry(
1460
+ result.markets,
1461
+ undelivered,
1462
+ await readCache(input.repository, indexed, url)
1463
+ ).length > 0;
1464
+ revalidateAt = fetchedAt + (keepsCache ? DEGRADED_RETRY_MS : MARKETS_CACHE_TTL_MS);
1465
+ if (input.repository && !keepsCache) {
1431
1466
  try {
1432
1467
  await input.repository.saveCachedMarkets(indexed, url, {
1433
1468
  markets: result.markets,
@@ -1443,12 +1478,26 @@ var discoveryIndex = (input) => {
1443
1478
  held = cached;
1444
1479
  return cached;
1445
1480
  }
1481
+ if (result.markets.length > 0) {
1482
+ const fetchedAt = Date.now();
1483
+ held = { markets: result.markets, ref: { fetchedAt, live: true, source: "local" } };
1484
+ revalidateAt = fetchedAt + DEGRADED_RETRY_MS;
1485
+ return held;
1486
+ }
1446
1487
  return unavailable(whyUnavailable());
1447
1488
  };
1448
1489
  return { peek, load };
1449
1490
  };
1450
1491
 
1451
1492
  // src/client/driveRecords.ts
1493
+ import {
1494
+ ArkAddress as ArkAddress3,
1495
+ asset as asset3,
1496
+ assertPageRequest,
1497
+ pageResult
1498
+ } from "@arkade-os/sdk";
1499
+ import { sha256 } from "@noble/hashes/sha2.js";
1500
+ import { hex as hex4 } from "@scure/base";
1452
1501
  var splitRecords = (records) => {
1453
1502
  const corridor = [];
1454
1503
  const offer = [];
@@ -1467,12 +1516,15 @@ var rfqRecordOf = (record) => ({
1467
1516
  state: record.state,
1468
1517
  createdAt: record.createdAt,
1469
1518
  updatedAt: record.updatedAt,
1470
- ...record.refundTxid === void 0 ? {} : { refundTxid: record.refundTxid },
1471
- ...record.lockupSpendTxids?.length ? { lockupSpendTxids: [...record.lockupSpendTxids] } : {},
1472
- ...record.settlementPreimageHex === void 0 ? {} : { settlementPreimageHex: record.settlementPreimageHex },
1473
- ...record.failure === void 0 ? {} : { failure: record.failure },
1474
- ...record.claimFailure === void 0 ? {} : { claimFailure: record.claimFailure },
1475
- ...record.blockedReason === void 0 ? {} : { blockedReason: record.blockedReason }
1519
+ ...mutableHalfOf(record)
1520
+ });
1521
+ var mutableHalfOf = (from) => ({
1522
+ ...from.refundTxid === void 0 ? {} : { refundTxid: from.refundTxid },
1523
+ ...from.lockupSpendTxids?.length ? { lockupSpendTxids: [...from.lockupSpendTxids] } : {},
1524
+ ...from.settlementPreimageHex === void 0 ? {} : { settlementPreimageHex: from.settlementPreimageHex },
1525
+ ...from.failure === void 0 ? {} : { failure: from.failure },
1526
+ ...from.claimFailure === void 0 ? {} : { claimFailure: from.claimFailure },
1527
+ ...from.blockedReason === void 0 ? {} : { blockedReason: from.blockedReason }
1476
1528
  });
1477
1529
  var withRfqState = (record, state) => {
1478
1530
  const {
@@ -1489,14 +1541,20 @@ var withRfqState = (record, state) => {
1489
1541
  state: state.state,
1490
1542
  profile: state.profile,
1491
1543
  updatedAt: state.updatedAt,
1492
- ...state.refundTxid === void 0 ? {} : { refundTxid: state.refundTxid },
1493
- ...state.lockupSpendTxids?.length ? { lockupSpendTxids: [...state.lockupSpendTxids] } : {},
1494
- ...state.settlementPreimageHex === void 0 ? {} : { settlementPreimageHex: state.settlementPreimageHex },
1495
- ...state.failure === void 0 ? {} : { failure: state.failure },
1496
- ...state.claimFailure === void 0 ? {} : { claimFailure: state.claimFailure },
1497
- ...state.blockedReason === void 0 ? {} : { blockedReason: state.blockedReason }
1544
+ ...mutableHalfOf(state)
1498
1545
  };
1499
1546
  };
1547
+ var pageRfqRecords = (records, filter, page) => {
1548
+ const rows = records.filter(
1549
+ (record) => (filter.state === void 0 || record.state === filter.state) && (filter.since === void 0 || record.updatedAt >= filter.since) && (!page.after || record.updatedAt > page.after.updatedAt || record.updatedAt === page.after.updatedAt && record.rfqId > page.after.rfqId)
1550
+ ).sort(
1551
+ (a, b) => a.updatedAt - b.updatedAt || (a.rfqId < b.rfqId ? -1 : a.rfqId > b.rfqId ? 1 : 0)
1552
+ ).slice(0, page.limit + 1);
1553
+ return pageResult(rows, page.limit, (record) => ({
1554
+ updatedAt: record.updatedAt,
1555
+ rfqId: record.rfqId
1556
+ }));
1557
+ };
1500
1558
  var corridorRecordStore = (repository, onRecord = () => {
1501
1559
  }, admits = () => true) => {
1502
1560
  const byRfqId = /* @__PURE__ */ new Map();
@@ -1509,7 +1567,7 @@ var corridorRecordStore = (repository, onRecord = () => {
1509
1567
  const record = await repository.getSwapRecord(known);
1510
1568
  if (record?.family === "rfq") return record;
1511
1569
  }
1512
- const { corridor } = splitRecords(await repository.getAllSwapRecords());
1570
+ const { corridor } = splitRecords(await collectSwapRecords(repository));
1513
1571
  for (const record of corridor) index(record);
1514
1572
  const found = byRfqId.get(rfqId);
1515
1573
  return found === void 0 ? void 0 : corridor.find((r) => r.id === found);
@@ -1517,10 +1575,12 @@ var corridorRecordStore = (repository, onRecord = () => {
1517
1575
  return {
1518
1576
  index,
1519
1577
  quoteIdOf: (rfqId) => byRfqId.get(rfqId),
1520
- async getAllRfqSwaps() {
1521
- const { corridor } = splitRecords(await repository.getAllSwapRecords());
1578
+ async getRfqSwapsPage(filter, page) {
1579
+ assertPageRequest(page);
1580
+ assertRfqSwapPageFilter(filter);
1581
+ const { corridor } = splitRecords(await collectSwapRecords(repository));
1522
1582
  for (const record of corridor) index(record);
1523
- return corridor.filter(admits).map(rfqRecordOf);
1583
+ return pageRfqRecords(corridor.filter(admits).map(rfqRecordOf), filter, page);
1524
1584
  },
1525
1585
  async getRfqSwap(rfqId) {
1526
1586
  const record = await recordFor(rfqId);
@@ -1543,20 +1603,18 @@ var corridorRecordStore = (repository, onRecord = () => {
1543
1603
  };
1544
1604
  var offerFactsOf = (record) => ({
1545
1605
  id: record.id,
1606
+ coverageId: record.id,
1546
1607
  status: record.status,
1547
1608
  offerHex: record.offerHex,
1548
1609
  swapPkScript: record.swapPkScript,
1549
1610
  ...record.fundingTxid === void 0 ? {} : { fundingTxid: record.fundingTxid },
1550
1611
  ...record.spentTxid === void 0 ? {} : { spentTxid: record.spentTxid },
1551
- // Milliseconds: `coverage.ts` marks issuance with `Date.now()`, and a
1552
- // seconds value compared against it leaves every issued script outstanding
1553
- // for the life of the process.
1554
1612
  createdAt: record.createdAt * 1e3
1555
1613
  });
1556
1614
  var offerRecordSource = (repository, onRecord = () => {
1557
1615
  }, now = () => Math.floor(Date.now() / 1e3)) => {
1558
1616
  const list = async () => {
1559
- const { offer } = splitRecords(await repository.getAllSwapRecords());
1617
+ const { offer } = splitRecords(await collectSwapRecords(repository));
1560
1618
  return offer.map(offerFactsOf);
1561
1619
  };
1562
1620
  return {
@@ -1585,12 +1643,93 @@ var applyOfferSpend = (record, changes, now) => ({
1585
1643
  ...record,
1586
1644
  status: changes.status,
1587
1645
  spentTxid: changes.spentTxid,
1588
- // The watcher's `completedAt` comes off a contract event's timestamp, in
1589
- // milliseconds; this record's timestamps are unix seconds.
1646
+ // event timestamps are milliseconds; this record's are unix seconds
1590
1647
  ...changes.completedAt === void 0 ? {} : { completedAt: Math.floor(changes.completedAt / 1e3) },
1591
1648
  updatedAt: now
1592
1649
  });
1593
- var withOfferStatus = (record, status, now) => ({ ...record, status, updatedAt: now });
1650
+ var withDepositFate = (record, fate, now) => ({
1651
+ ...record,
1652
+ status: fate.status,
1653
+ ...fate.spentTxid === void 0 ? {} : { spentTxid: fate.spentTxid },
1654
+ ...fate.completedAt === void 0 ? {} : { completedAt: Math.floor(fate.completedAt / 1e3) },
1655
+ updatedAt: now
1656
+ });
1657
+ var DEPOSIT_SPENT = (status) => status === "cancelled" || status === "fulfilled";
1658
+ var fateMoved = (record, fate) => {
1659
+ if (DEPOSIT_SPENT(record.status) && !DEPOSIT_SPENT(fate.status)) return false;
1660
+ return record.status !== fate.status || fate.spentTxid !== void 0 && record.spentTxid !== fate.spentTxid || fate.completedAt !== void 0 && record.completedAt !== Math.floor(fate.completedAt / 1e3);
1661
+ };
1662
+ var restoredOfferRecord = (swap, network, now) => {
1663
+ const give = restoredAssetId(network, swap.fromAsset);
1664
+ const take = restoredAssetId(network, swap.toAsset);
1665
+ const createdAt = Math.floor(swap.createdAt / 1e3);
1666
+ return withDepositFate(
1667
+ {
1668
+ id: swap.fundingTxid,
1669
+ family: "offer",
1670
+ route: {
1671
+ give: { corridor: "arkade", asset: give, instrument: { kind: "wallet" } },
1672
+ take: { corridor: "arkade", asset: take, instrument: { kind: "wallet" } }
1673
+ },
1674
+ give: { asset: give, amount: toAtomicDecimal(BigInt(swap.fromAmount)) },
1675
+ take: { asset: take, amount: toAtomicDecimal(BigInt(swap.toAmount)) },
1676
+ fee: { asset: take, amount: toAtomicDecimal(0n) },
1677
+ market: { kind: "restored", backend: "feed" },
1678
+ expiresAt: createdAt,
1679
+ status: swap.status,
1680
+ offerHex: swap.offerHex,
1681
+ swapAddress: swap.swapAddress,
1682
+ swapPkScript: swap.swapPkScript,
1683
+ fundingTxid: swap.fundingTxid,
1684
+ createdAt,
1685
+ updatedAt: now
1686
+ },
1687
+ swap,
1688
+ now
1689
+ );
1690
+ };
1691
+ var restoredAssetId = (network, id) => id === BTC_ASSET_ID ? btcOn("arkade", network) : arkadeAsset(network, asset3.AssetId.fromString(id));
1692
+ var RESTORED_CORRIDORS = {
1693
+ lightning_send: ["arkade", "lightning"],
1694
+ lightning_receive: ["lightning", "arkade"],
1695
+ onchain_send: ["arkade", "onchain"],
1696
+ onchain_receive: ["onchain", "arkade"]
1697
+ };
1698
+ var restoredCorridorRecord = (stored, network, refundLocktime) => {
1699
+ const v1 = normalizeRfqSwapRecord(stored);
1700
+ const hashlock = v1.profile.hashlock;
1701
+ const hash = typeof hashlock?.paymentHash === "string" ? hashlock.paymentHash : v1.settlementPreimageHex === void 0 ? void 0 : hex4.encode(sha256(hex4.decode(v1.settlementPreimageHex)));
1702
+ if (hash === void 0) throw new Error(`v1 rfq swap ${v1.rfqId} has no payment hash`);
1703
+ const [giveCorridor, takeCorridor] = RESTORED_CORRIDORS[v1.kind];
1704
+ const give = btcOn(railOfCorridor(giveCorridor), network);
1705
+ const take = btcOn(railOfCorridor(takeCorridor), network);
1706
+ const amount = toAtomicDecimal(BigInt(v1.amount ?? 0));
1707
+ return {
1708
+ id: v1.rfqId,
1709
+ family: "rfq",
1710
+ route: {
1711
+ give: { corridor: giveCorridor, asset: give, instrument: { kind: "wallet" } },
1712
+ take: { corridor: takeCorridor, asset: take, instrument: { kind: "wallet" } }
1713
+ },
1714
+ give: { asset: give, amount },
1715
+ take: { asset: take, amount },
1716
+ fee: { asset: give, amount: toAtomicDecimal(0n) },
1717
+ market: { kind: "restored", backend: "rfq" },
1718
+ expiresAt: v1.createdAt,
1719
+ state: v1.state,
1720
+ kind: v1.kind,
1721
+ rfqId: v1.rfqId,
1722
+ lockupAddress: v1.lockupAddress,
1723
+ lockupPkScript: hex4.encode(ArkAddress3.decode(v1.lockupAddress).pkScript),
1724
+ lock: { hash },
1725
+ refundLocktime,
1726
+ profile: v1.profile,
1727
+ ...v1.fundingTxid === void 0 ? {} : { fundingTxid: v1.fundingTxid },
1728
+ ...mutableHalfOf(v1),
1729
+ createdAt: v1.createdAt,
1730
+ updatedAt: v1.updatedAt
1731
+ };
1732
+ };
1594
1733
  var walletLockupIndexer = (wallet) => {
1595
1734
  let reader;
1596
1735
  const reading = () => reader ??= wallet.getArkadeReader();
@@ -1606,17 +1745,14 @@ var walletLockupIndexer = (wallet) => {
1606
1745
  };
1607
1746
 
1608
1747
  // src/client/cancel.ts
1609
- import { base64, hex as hex3 } from "@scure/base";
1610
- import { ArkAddress as ArkAddress2, Transaction } from "@arkade-os/sdk";
1611
- var OFFER_TERMINAL = (record) => record.status === "cancelled" || record.status === "fulfilled";
1748
+ import { base64, hex as hex5 } from "@scure/base";
1749
+ import { ArkAddress as ArkAddress4, Transaction } from "@arkade-os/sdk";
1612
1750
  var cancelSwap = async (input) => {
1613
1751
  const { wallet, repository, record, drive, indexer } = input;
1614
1752
  const now = input.now ?? (() => Math.floor(Date.now() / 1e3));
1615
- if (OFFER_TERMINAL(record)) {
1616
- return { outcome: record.status === "cancelled" ? "cancelled" : "filled" };
1617
- }
1618
- if (offerOutcome(record.status) === "needs_recovery") {
1619
- return { outcome: "needs_recovery" };
1753
+ const outcome = offerOutcome(record.status);
1754
+ if (outcome === "cancelled" || outcome === "filled" || outcome === "needs_recovery") {
1755
+ return { outcome };
1620
1756
  }
1621
1757
  const gated2 = withStatus(record, "cancelling", now());
1622
1758
  await repository.saveSwapRecord(gated2);
@@ -1641,7 +1777,7 @@ var cancelSwap = async (input) => {
1641
1777
  drive.ingest(rolledBack);
1642
1778
  throw error;
1643
1779
  }
1644
- if (isMissingVtxo(error)) {
1780
+ if (error instanceof NoSpendableDepositError) {
1645
1781
  const reconciled = await reconcileDepositSpend(record, indexer);
1646
1782
  if (reconciled === void 0) {
1647
1783
  return { outcome: "needs_recovery" };
@@ -1670,7 +1806,7 @@ var cancelSwap = async (input) => {
1670
1806
  return { outcome: "cancelled" };
1671
1807
  };
1672
1808
  var reconcileDepositSpend = async (record, indexer) => {
1673
- const offer = decodeOffer(hex3.decode(record.offerHex));
1809
+ const offer = decodeOffer(hex5.decode(record.offerHex));
1674
1810
  const { vtxos } = await indexer.getVtxos({ scripts: [record.swapPkScript] });
1675
1811
  const all = vtxos ?? [];
1676
1812
  const deposit = record.fundingTxid === void 0 ? all.length === 1 ? all[0] : void 0 : all.find((vtxo) => vtxo.txid === record.fundingTxid);
@@ -1687,7 +1823,7 @@ var reconcileDepositSpend = async (record, indexer) => {
1687
1823
  return void 0;
1688
1824
  }
1689
1825
  }).filter((tx) => tx !== void 0);
1690
- const operatorPubkey = ArkAddress2.decode(record.swapAddress).serverPubKey;
1826
+ const operatorPubkey = ArkAddress4.decode(record.swapAddress).serverPubKey;
1691
1827
  const kind = classifyDepositSpend(offer, operatorPubkey, parsed, {
1692
1828
  txid: deposit.txid,
1693
1829
  vout: deposit.vout
@@ -1713,68 +1849,290 @@ var persistBestEffort = async (repository, record) => {
1713
1849
  };
1714
1850
  var retireOfferScripts = async (wallet, repository, record) => {
1715
1851
  try {
1716
- const { offer } = splitRecords(await repository.getAllSwapRecords());
1852
+ const { offer } = splitRecords(await collectSwapRecords(repository));
1717
1853
  await retireOfferContract(
1718
1854
  await wallet.getContractManager(),
1719
1855
  offer.map(offerFactsOf),
1720
- record.swapPkScript
1856
+ record.swapPkScript,
1857
+ { scope: wallet }
1721
1858
  );
1722
1859
  } catch (error) {
1723
1860
  console.warn(`[swap] could not retire offer script for ${record.id}`, error);
1724
1861
  }
1725
1862
  };
1726
- var isMissingVtxo = (error) => error instanceof NoSpendableDepositError;
1727
1863
 
1728
1864
  // src/client/drive.ts
1729
1865
  import {
1730
- ArkAddress as ArkAddress3,
1866
+ ArkAddress as ArkAddress5,
1731
1867
  contractSigner,
1868
+ getNetwork as getNetwork2,
1732
1869
  identityDescriptor
1733
1870
  } from "@arkade-os/sdk";
1734
- import { hex as hex4 } from "@scure/base";
1735
- var SwapDriveRefusedError = class extends Error {
1736
- constructor(reason, detail, swapId) {
1737
- super(detail);
1738
- this.reason = reason;
1739
- this.swapId = swapId;
1871
+ import { hex as hex6 } from "@scure/base";
1872
+
1873
+ // src/migrateOfferRows.ts
1874
+ import { arkade } from "@arkade-os/sdk";
1875
+
1876
+ // src/legacy/swap-want-asset.program.v0.json
1877
+ var swap_want_asset_program_v0_default = {
1878
+ version: 0,
1879
+ name: "banco-btc-to-asset",
1880
+ params: [
1881
+ { name: "makerWP", type: "pubkey" },
1882
+ { name: "wantAmount", type: "int" },
1883
+ { name: "wantAssetTxid", type: "hash" },
1884
+ { name: "wantAssetGroupIndex", type: "int" },
1885
+ { name: "server", type: "pubkey" },
1886
+ { name: "user", type: "pubkey" }
1887
+ ],
1888
+ functions: {
1889
+ fulfill: {
1890
+ tapscript: { signers: ["$server"] },
1891
+ arkadeScript: {
1892
+ asm: [
1893
+ 0,
1894
+ "$wantAssetTxid",
1895
+ "$wantAssetGroupIndex",
1896
+ "INSPECTOUTASSETLOOKUP",
1897
+ "VERIFY",
1898
+ "$wantAmount",
1899
+ "GREATERTHANOREQUAL",
1900
+ "VERIFY",
1901
+ 0,
1902
+ "INSPECTOUTPUTSCRIPTPUBKEY",
1903
+ 1,
1904
+ "EQUALVERIFY",
1905
+ "$makerWP",
1906
+ "EQUAL"
1907
+ ]
1908
+ }
1909
+ },
1910
+ cancel: {
1911
+ tapscript: { signers: ["$user", "$server"] }
1912
+ }
1740
1913
  }
1741
- reason;
1742
- swapId;
1743
- name = "SwapDriveRefusedError";
1744
1914
  };
1745
- var OFFER_LIVE = (status) => status === "pending" || status === "cancelling";
1746
- var traderClaimTxid = (swap) => swap.kind === "lightning_send" ? void 0 : swap.claimTxid;
1747
- var readableRecord = (record) => {
1748
- if (typeof record?.id !== "string" || record.route?.give === void 0) return false;
1749
- if (record.family === "rfq") {
1750
- return typeof record.rfqId === "string" && typeof record.lockupAddress === "string";
1915
+
1916
+ // src/legacy/swap-want-btc.program.v0.json
1917
+ var swap_want_btc_program_v0_default = {
1918
+ version: 0,
1919
+ name: "banco-asset-to-btc",
1920
+ params: [
1921
+ { name: "makerWP", type: "pubkey" },
1922
+ { name: "wantAmount", type: "int" },
1923
+ { name: "server", type: "pubkey" },
1924
+ { name: "user", type: "pubkey" }
1925
+ ],
1926
+ functions: {
1927
+ fulfill: {
1928
+ tapscript: { signers: ["$server"] },
1929
+ arkadeScript: {
1930
+ asm: [
1931
+ 0,
1932
+ "INSPECTOUTPUTVALUE",
1933
+ "$wantAmount",
1934
+ "GREATERTHANOREQUAL",
1935
+ "VERIFY",
1936
+ 0,
1937
+ "INSPECTOUTPUTSCRIPTPUBKEY",
1938
+ 1,
1939
+ "EQUALVERIFY",
1940
+ "$makerWP",
1941
+ "EQUAL"
1942
+ ]
1943
+ }
1944
+ },
1945
+ cancel: {
1946
+ tapscript: { signers: ["$user", "$server"] }
1947
+ }
1751
1948
  }
1752
- return record.family === "offer" && typeof record.offerHex === "string";
1753
1949
  };
1754
- var createSwapDrive = (config) => {
1755
- const { wallet, operator, repository, corridors, indexer } = config;
1756
- const mode = config.mode ?? "auto";
1757
- const now = config.now ?? (() => Math.floor(Date.now() / 1e3));
1758
- const records = /* @__PURE__ */ new Map();
1759
- const live = /* @__PURE__ */ new Map();
1760
- const refunding = /* @__PURE__ */ new Set();
1761
- const swept = /* @__PURE__ */ new Map();
1762
- const passed = /* @__PURE__ */ new Set();
1763
- const delivered = /* @__PURE__ */ new Map();
1764
- const listeners = /* @__PURE__ */ new Set();
1765
- let disposed = false;
1766
- let startRequested = mode === "auto";
1767
- let watcher;
1768
- let readyPromise;
1769
- const inFlight = /* @__PURE__ */ new Set();
1770
- let queue = Promise.resolve();
1771
- const track = (work) => {
1772
- inFlight.add(work);
1773
- void work.then(
1774
- () => inFlight.delete(work),
1775
- () => inFlight.delete(work)
1776
- );
1777
- return work;
1950
+
1951
+ // src/migrateOfferRows.ts
1952
+ function withExitV0(program, exit) {
1953
+ if (!exit) return program;
1954
+ return {
1955
+ ...program,
1956
+ params: [...program.params, { name: "exitDelay", type: "int" }],
1957
+ functions: {
1958
+ ...program.functions,
1959
+ exit: { tapscript: { signers: ["$user"], csv: { type: exit, value: "$exitDelay" } } }
1960
+ }
1961
+ };
1962
+ }
1963
+ var V0_TO_V1 = /* @__PURE__ */ new Map();
1964
+ for (const [v0, v1] of [
1965
+ [swap_want_btc_program_v0_default, swapPrograms.wantBtc],
1966
+ [swap_want_asset_program_v0_default, swapPrograms.wantAsset]
1967
+ ]) {
1968
+ for (const exit of [void 0, "blocks", "seconds"]) {
1969
+ const timelock = exit && { type: exit, value: BigInt(0) };
1970
+ V0_TO_V1.set(
1971
+ JSON.stringify(withExitV0(v0, exit)),
1972
+ arkade.stringifyArtifact(withExitClosure(v1, timelock))
1973
+ );
1974
+ }
1975
+ }
1976
+ async function migrateV0OfferRows(contractManager) {
1977
+ const migrated = [];
1978
+ const skipped = [];
1979
+ for (const row of await contractManager.getUnsupportedContracts()) {
1980
+ if (row.type !== "arkade" || row.metadata?.kind !== OFFER_CONTRACT_KIND) continue;
1981
+ const program = V0_TO_V1.get(row.params.program);
1982
+ if (!program) {
1983
+ skipped.push({ script: row.script, reason: "not a bundled Program v0 offer" });
1984
+ continue;
1985
+ }
1986
+ try {
1987
+ await contractManager.createContract({
1988
+ type: row.type,
1989
+ script: row.script,
1990
+ address: row.address,
1991
+ params: { ...row.params, program },
1992
+ label: row.label,
1993
+ metadata: row.metadata
1994
+ });
1995
+ migrated.push(row.script);
1996
+ } catch (error) {
1997
+ skipped.push({
1998
+ script: row.script,
1999
+ reason: error instanceof Error ? error.message : String(error)
2000
+ });
2001
+ }
2002
+ }
2003
+ return { migrated, skipped };
2004
+ }
2005
+
2006
+ // src/client/legacyRecords.ts
2007
+ import { assertPageRequest as assertPageRequest2 } from "@arkade-os/sdk";
2008
+ var readLegacyRfqSwaps = async (repository, filter = {}) => {
2009
+ try {
2010
+ return await collectRfqSwaps(repository, filter);
2011
+ } catch (error) {
2012
+ console.warn("[swap] the v1 rfq swaps could not be read", error);
2013
+ return [];
2014
+ }
2015
+ };
2016
+ var legacyLiveRfqSwaps = async (repository) => (await readLegacyRfqSwaps(repository)).filter((record) => !isRfqSwapTerminal(record.state));
2017
+ var withLegacyRfqSwaps = (bridge, repository, admits) => {
2018
+ const legacy = /* @__PURE__ */ new Set();
2019
+ return {
2020
+ index: bridge.index,
2021
+ quoteIdOf: bridge.quoteIdOf,
2022
+ async getRfqSwapsPage(filter, page) {
2023
+ assertPageRequest2(page);
2024
+ assertRfqSwapPageFilter(filter);
2025
+ const v2 = await collectRfqSwaps(bridge, filter);
2026
+ const held = new Set(
2027
+ splitRecords(await collectSwapRecords(repository)).corridor.map((r) => r.rfqId)
2028
+ );
2029
+ const v1 = (await readLegacyRfqSwaps(repository, filter)).filter(
2030
+ (record) => !held.has(record.rfqId) && admits(record)
2031
+ );
2032
+ for (const record of v1) legacy.add(record.rfqId);
2033
+ return pageRfqRecords([...v2, ...v1], filter, page);
2034
+ },
2035
+ async getRfqSwap(rfqId) {
2036
+ if (!legacy.has(rfqId)) {
2037
+ const record2 = await bridge.getRfqSwap(rfqId);
2038
+ if (record2 !== void 0) return record2;
2039
+ }
2040
+ const record = await repository.getRfqSwap(rfqId);
2041
+ if (record !== void 0) legacy.add(rfqId);
2042
+ return record;
2043
+ },
2044
+ async saveRfqSwap(record) {
2045
+ if (legacy.has(record.rfqId)) await repository.saveRfqSwap(record);
2046
+ else await bridge.saveRfqSwap(record);
2047
+ },
2048
+ removeRfqSwap: (rfqId) => bridge.removeRfqSwap(rfqId)
2049
+ };
2050
+ };
2051
+ var legacyRfqSwapsToAdopt = async (repository) => {
2052
+ const v1 = await readLegacyRfqSwaps(repository);
2053
+ if (v1.length === 0) return [];
2054
+ const records = await collectSwapRecords(repository);
2055
+ const held = new Set(splitRecords(records).corridor.map((record) => record.rfqId));
2056
+ const ids = new Set(records.map((record) => record.id));
2057
+ return v1.filter((record) => {
2058
+ if (held.has(record.rfqId)) return false;
2059
+ if (ids.has(record.rfqId)) {
2060
+ console.warn(`[swap] v1 rfq swap ${record.rfqId} collides with a v2 record id`);
2061
+ return false;
2062
+ }
2063
+ return true;
2064
+ });
2065
+ };
2066
+ var readLegacyAssetSwaps = async (repository) => {
2067
+ try {
2068
+ return await collectAssetSwaps(repository);
2069
+ } catch (error) {
2070
+ console.warn("[swap] the v1 swaps could not be read", error);
2071
+ return [];
2072
+ }
2073
+ };
2074
+ var legacyOfferDepositsToAdopt = async (repository) => {
2075
+ const unadopted = (await readLegacyAssetSwaps(repository)).filter(
2076
+ (swap) => !!swap.offerHex && !!swap.fundingTxid
2077
+ );
2078
+ if (unadopted.length === 0) return /* @__PURE__ */ new Set();
2079
+ const { offer } = splitRecords(await collectSwapRecords(repository));
2080
+ const adopted = new Set(offer.map((record) => record.fundingTxid));
2081
+ return new Set(unadopted.map((swap) => swap.fundingTxid).filter((txid) => !adopted.has(txid)));
2082
+ };
2083
+
2084
+ // src/client/drive.ts
2085
+ var SwapDriveRefusedError = class extends Error {
2086
+ constructor(reason, detail, swapId) {
2087
+ super(detail);
2088
+ this.reason = reason;
2089
+ this.swapId = swapId;
2090
+ }
2091
+ reason;
2092
+ swapId;
2093
+ name = "SwapDriveRefusedError";
2094
+ };
2095
+ var OFFER_LIVE = (status) => status === "pending" || status === "cancelling";
2096
+ var traderClaimTxid = (swap) => swap.kind === "lightning_send" ? void 0 : swap.claimTxid;
2097
+ var readableRecord = (record) => {
2098
+ if (typeof record?.id !== "string" || record.route?.give === void 0) return false;
2099
+ if (record.assetPayment !== void 0) {
2100
+ try {
2101
+ assetPaymentOf(record.assetPayment, record.expiresAt);
2102
+ } catch {
2103
+ return false;
2104
+ }
2105
+ }
2106
+ if (record.family === "rfq") {
2107
+ return typeof record.rfqId === "string" && typeof record.lockupAddress === "string";
2108
+ }
2109
+ return record.family === "offer" && typeof record.offerHex === "string";
2110
+ };
2111
+ var createSwapDrive = (config) => {
2112
+ const { wallet, operator, repository, corridors, indexer } = config;
2113
+ const mode = config.mode ?? "auto";
2114
+ const now = config.now ?? (() => Math.floor(Date.now() / 1e3));
2115
+ const records = /* @__PURE__ */ new Map();
2116
+ const live = /* @__PURE__ */ new Map();
2117
+ const refunding = /* @__PURE__ */ new Set();
2118
+ const swept = /* @__PURE__ */ new Map();
2119
+ const recoveredIn = /* @__PURE__ */ new Set();
2120
+ const passed = /* @__PURE__ */ new Set();
2121
+ const delivered = /* @__PURE__ */ new Map();
2122
+ const listeners = /* @__PURE__ */ new Set();
2123
+ let disposed = false;
2124
+ let startRequested = mode === "auto";
2125
+ let watcher;
2126
+ let readyPromise;
2127
+ const inFlight = /* @__PURE__ */ new Set();
2128
+ let queue = Promise.resolve();
2129
+ const track = (work) => {
2130
+ inFlight.add(work);
2131
+ void work.then(
2132
+ () => inFlight.delete(work),
2133
+ () => inFlight.delete(work)
2134
+ );
2135
+ return work;
1778
2136
  };
1779
2137
  const enqueue = (task) => {
1780
2138
  queue = queue.then(task).catch((error) => {
@@ -1797,20 +2155,23 @@ var createSwapDrive = (config) => {
1797
2155
  return repository;
1798
2156
  };
1799
2157
  const undrivable = /* @__PURE__ */ new Set();
2158
+ const undrivableLegacy = /* @__PURE__ */ new Set();
1800
2159
  let bridge;
1801
- const corridorStore = () => bridge ??= corridorRecordStore(
1802
- storage(),
1803
- remember,
1804
- // Terminal records are readable but never driven: excluding them
1805
- // here is what keeps `restoreFromRepository` from rebuilding each
1806
- // one — a covenant derivation and a contract row lookup per
1807
- // record — only to file it in the manager's `finished` set. The
1808
- // exclusion is on the manager's read, not the record: the drive's
1809
- // own `records` registry keeps every readable record, and the
1810
- // index still learns an excluded record's `rfqId` (see
1811
- // `getAllRfqSwaps`), so a consumer handing its swap to the manager
1812
- // directly keeps resolving.
1813
- (r) => !undrivable.has(r.id) && !isRfqSwapTerminal(r.state)
2160
+ let readThrough;
2161
+ const corridorStore = () => (
2162
+ // LEGACY(v1): unwrap to `bridge` alone once the read-through goes.
2163
+ readThrough ??= withLegacyRfqSwaps(
2164
+ bridge ??= corridorRecordStore(
2165
+ storage(),
2166
+ remember,
2167
+ // Terminal records stay readable but are excluded from the manager's read, sparing
2168
+ // a rebuild per record just to file it `finished`. The index still learns their
2169
+ // `rfqId` (see `getRfqSwapsPage`).
2170
+ (r) => !undrivable.has(r.id) && !isRfqSwapTerminal(r.state)
2171
+ ),
2172
+ storage(),
2173
+ (r) => !undrivableLegacy.has(r.rfqId) && !isRfqSwapTerminal(r.state)
2174
+ )
1814
2175
  );
1815
2176
  const effectiveState = (swap) => {
1816
2177
  if (mode === "auto") return swap.state;
@@ -1819,6 +2180,7 @@ var createSwapDrive = (config) => {
1819
2180
  return traderClaimTxid(swap) ? "claimed" : "pending";
1820
2181
  };
1821
2182
  const outcomeOfEntry = (record, current) => {
2183
+ if (fundingWasNotSubmitted(record)) return "cancelled";
1822
2184
  if (record.family === "offer") return recordOutcome(record);
1823
2185
  if (current === void 0) {
1824
2186
  if (isRfqSwapTerminal(record.state)) return corridorOutcome(record.kind, record.state);
@@ -1846,7 +2208,7 @@ var createSwapDrive = (config) => {
1846
2208
  };
1847
2209
  const updateFor = (id) => {
1848
2210
  const record = records.get(id);
1849
- if (record === void 0) return void 0;
2211
+ if (record === void 0 || !readableRecord(record)) return void 0;
1850
2212
  const current = live.get(id);
1851
2213
  const outcome = outcomeOfEntry(record, current);
1852
2214
  return {
@@ -1896,8 +2258,15 @@ var createSwapDrive = (config) => {
1896
2258
  touch(swap.rfqId, swap);
1897
2259
  });
1898
2260
  let onchainSeams;
2261
+ const liveFeeRate = async (chain) => {
2262
+ try {
2263
+ return await chain.getFeeRate?.();
2264
+ } catch {
2265
+ return void 0;
2266
+ }
2267
+ };
1899
2268
  const defaultOnchainClaim = (chain, feeRateSatVb) => {
1900
- return async (swap, utxo) => {
2269
+ return async (swap, utxo, options) => {
1901
2270
  const record = await corridorStore().getRfqSwap(swap.rfqId);
1902
2271
  if (!record) {
1903
2272
  throw new Error(`rfq swap ${swap.rfqId} has no stored record to claim from`);
@@ -1908,7 +2277,7 @@ var createSwapDrive = (config) => {
1908
2277
  const signer = await contractSigner(wallet, await identityDescriptor(wallet.identity));
1909
2278
  const claimKey = record.profile.claimKey;
1910
2279
  if (typeof claimKey === "string") {
1911
- const held = hex4.encode(await signer.xOnlyPublicKey());
2280
+ const held = hex6.encode(await signer.xOnlyPublicKey());
1912
2281
  if (held !== claimKey) {
1913
2282
  throw new Error(
1914
2283
  `this wallet's identity key ${held} is not the payout key ${claimKey} rfq swap ${swap.rfqId} was quoted against \u2014 a wrong seed, or key provisioning has drifted from the identity key`
@@ -1918,17 +2287,54 @@ var createSwapDrive = (config) => {
1918
2287
  if (!swap.payoutPkScript) {
1919
2288
  throw new Error(`rfq swap ${swap.rfqId} carries no claim payout script`);
1920
2289
  }
2290
+ const rate = nextClaimFeeRate({
2291
+ configuredSatVb: feeRateSatVb,
2292
+ utxoAmount: utxo.amount,
2293
+ estimateSatVb: await liveFeeRate(chain),
2294
+ ...swap.claimFeeRateSatVb === void 0 ? {} : { lastSatVb: swap.claimFeeRateSatVb },
2295
+ ...options?.bump ? { bump: true } : {}
2296
+ });
1921
2297
  const { txid } = await track(
1922
2298
  claimOnchainFill(chain, {
1923
2299
  htlc: swap.htlc,
1924
2300
  utxo,
1925
2301
  preimage,
1926
2302
  payoutPkScript: swap.payoutPkScript,
1927
- feeRateSatVb,
1928
- sign: (sighash) => signer.signMessage(sighash, "schnorr")
2303
+ feeRateSatVb: rate,
2304
+ sign: (sighash) => signer.signMessage(sighash, "schnorr"),
2305
+ ...swap.claimTxid ? { republish: true } : {}
1929
2306
  })
1930
2307
  );
1931
- return { txid };
2308
+ return { txid, feeRateSatVb: rate };
2309
+ };
2310
+ };
2311
+ const defaultOnchainRefund = (chain, feeRateSatVb) => {
2312
+ return async (swap, utxo) => {
2313
+ const record = await corridorStore().getRfqSwap(swap.rfqId);
2314
+ if (!record) {
2315
+ throw new Error(`rfq swap ${swap.rfqId} has no stored record to refund from`);
2316
+ }
2317
+ const descriptor = record.profile.refundDescriptor;
2318
+ if (typeof descriptor !== "string") {
2319
+ throw new Error(
2320
+ `rfq swap ${swap.rfqId} carries no refund descriptor; wire the onchain corridor's refund callback to take its L1 funding back`
2321
+ );
2322
+ }
2323
+ const signer = await contractSigner(wallet, descriptor);
2324
+ const held = hex6.encode(await signer.xOnlyPublicKey());
2325
+ if (held !== record.profile.refundKey) {
2326
+ throw new Error(
2327
+ `the key behind ${descriptor} is ${held}, not the refund key ${String(record.profile.refundKey)} rfq swap ${swap.rfqId}'s HTLC was derived with`
2328
+ );
2329
+ }
2330
+ const { txHex } = await buildHtlcRefund({
2331
+ htlc: swap.htlc,
2332
+ utxo,
2333
+ payoutPkScript: swap.refundPkScript,
2334
+ feeRateSatVb,
2335
+ sign: (sighash) => signer.signMessage(sighash, "schnorr")
2336
+ });
2337
+ return { txid: await track(chain.broadcast(txHex)) };
1932
2338
  };
1933
2339
  };
1934
2340
  const resolveOnchain = async () => {
@@ -1936,7 +2342,12 @@ var createSwapDrive = (config) => {
1936
2342
  try {
1937
2343
  const deps = (await corridors()).get("onchain").deps;
1938
2344
  const claim = deps.claim ?? (deps.claimFeeRateSatVb === void 0 ? void 0 : defaultOnchainClaim(deps.chain, deps.claimFeeRateSatVb));
1939
- onchainSeams = { chain: deps.chain, ...claim ? { claim } : {} };
2345
+ const refund = deps.refund ?? (deps.claimFeeRateSatVb === void 0 ? void 0 : defaultOnchainRefund(deps.chain, deps.claimFeeRateSatVb));
2346
+ onchainSeams = {
2347
+ chain: deps.chain,
2348
+ ...claim ? { claim } : {},
2349
+ ...refund ? { refund } : {}
2350
+ };
1940
2351
  managerDeps.chain = deps.chain;
1941
2352
  return true;
1942
2353
  } catch (error) {
@@ -1949,6 +2360,7 @@ var createSwapDrive = (config) => {
1949
2360
  }
1950
2361
  };
1951
2362
  const drivable = async (record) => !readsChain(record.kind) || await resolveOnchain();
2363
+ const pinnedNetwork = async () => getNetwork2(await config.network());
1952
2364
  const claimLockup = async (swap, vtxos, { partiallyClaimed }) => {
1953
2365
  const record = await corridorStore().getRfqSwap(swap.rfqId);
1954
2366
  if (!record) throw new Error(`rfq swap ${swap.rfqId} has no stored record to claim from`);
@@ -1966,13 +2378,11 @@ var createSwapDrive = (config) => {
1966
2378
  receiver: await contractSigner(wallet, secret.signingDescriptor),
1967
2379
  preimage: await preimageForSwapRecord(wallet, secret),
1968
2380
  vtxos,
1969
- destinationPkScript: ArkAddress3.decode(payoutAddress).pkScript,
1970
- // Passed straight through, both of them: the manager's own value
1971
- // check decides WHEN to act, `pushClaim`'s decides whether `P` is
1972
- // published, and it is the one with nothing between it and the
1973
- // signature.
2381
+ destinationPkScript: ArkAddress5.decode(payoutAddress).pkScript,
2382
+ // Passed through: `pushClaim`'s own value check decides whether `P` is published.
1974
2383
  expectedAmount: swap.expectedAmount,
1975
- partiallyClaimed
2384
+ partiallyClaimed,
2385
+ network: await pinnedNetwork()
1976
2386
  })
1977
2387
  );
1978
2388
  };
@@ -1999,9 +2409,10 @@ var createSwapDrive = (config) => {
1999
2409
  if (mode === "readonly") return;
2000
2410
  const push = arkadeRefunder({
2001
2411
  operator,
2002
- indexer,
2412
+ contracts: lockupSource,
2003
2413
  wallet,
2004
- repository: corridorStore()
2414
+ repository: corridorStore(),
2415
+ network: pinnedNetwork
2005
2416
  });
2006
2417
  manager.setCallbacks({
2007
2418
  refundArkade: async (swap) => {
@@ -2020,56 +2431,83 @@ var createSwapDrive = (config) => {
2020
2431
  },
2021
2432
  canRefundArkade,
2022
2433
  claimLockup,
2023
- ...onchainSeams?.claim ? { claimOnchain: onchainSeams.claim } : {}
2434
+ ...onchainSeams?.claim ? { claimOnchain: onchainSeams.claim } : {},
2435
+ ...onchainSeams?.refund ? { refundOnchain: onchainSeams.refund } : {}
2024
2436
  });
2025
2437
  };
2026
2438
  let offerSource;
2027
2439
  const offers = () => offerSource ??= offerRecordSource(storage(), remember, now);
2028
- const sweepOfferDeposits = async (offer) => {
2029
- const funded = offer.filter(
2030
- (record) => record.fundingTxid !== void 0 && !RETIRABLE.includes(record.status)
2031
- );
2032
- if (funded.length === 0) return;
2440
+ const restoreOfferDeposits = async (reopen = []) => {
2033
2441
  const store = storage();
2034
- const [history, scanned, address] = await Promise.all([
2442
+ const [history, scanned, address, network] = await Promise.all([
2035
2443
  wallet.getTransactionHistory(),
2036
2444
  store.getScannedTxids(),
2037
- wallet.getAddress()
2445
+ wallet.getAddress(),
2446
+ config.network()
2038
2447
  ]);
2039
- const txs = history.map((tx) => ({
2040
- // `TxType` is `"SENT"`/`"RECEIVED"`; the scan filters on `"sent"`.
2041
- type: String(tx.type).toLowerCase(),
2042
- redeemTxid: tx.key.arkTxid,
2043
- ...tx.key.boardingTxid ? { boardingTxid: tx.key.boardingTxid } : {},
2044
- ...tx.key.commitmentTxid ? { roundTxid: tx.key.commitmentTxid } : {},
2045
- // The scan reads unix SECONDS; a wallet transaction carries ms.
2046
- ...tx.createdAt ? { createdAt: Math.floor(tx.createdAt / 1e3) } : {}
2047
- }));
2448
+ const txs = history.map(toRestoreTx);
2449
+ const { hrp, serverPubKey: operatorPubkey } = ArkAddress5.decode(address);
2450
+ const reopened = await legacyOfferDepositsToAdopt(store);
2451
+ for (const txid of reopen) reopened.add(txid);
2452
+ const cursor = reopened.size === 0 ? scanned : new Set([...scanned].filter((txid) => !reopened.has(txid)));
2048
2453
  const { restored, scannedTxids } = await restoreAssetSwaps(indexer, txs, /* @__PURE__ */ new Set(), {
2049
- operatorPubkey: ArkAddress3.decode(address).serverPubKey,
2050
- scanned
2454
+ operatorPubkey,
2455
+ scanned: cursor,
2456
+ hrp,
2457
+ recoveredIn
2051
2458
  });
2052
- const byDeposit = new Map(restored.map((s) => [`${s.swapPkScript}:${s.fundingTxid}`, s]));
2053
- const stillLive = /* @__PURE__ */ new Set();
2054
- for (const record of funded) {
2055
- const found = byDeposit.get(`${record.swapPkScript}:${record.fundingTxid}`);
2056
- const status = found?.status ?? record.status;
2057
- if (status !== record.status) {
2058
- const updated = withOfferStatus(record, status, now());
2059
- await store.saveSwapRecord(updated);
2060
- remember(updated);
2459
+ const { offer } = splitRecords(await collectSwapRecords(store));
2460
+ const current = new Map(offer.map((record) => [record.id, record]));
2461
+ const byDeposit = new Map(
2462
+ offer.filter((record) => record.fundingTxid !== void 0).map((record) => [`${record.swapPkScript}:${record.fundingTxid}`, record])
2463
+ );
2464
+ const unstamped = /* @__PURE__ */ new Map();
2465
+ for (const record of offer) {
2466
+ if (record.fundingTxid !== void 0 || !OFFER_LIVE(record.status)) continue;
2467
+ unstamped.set(record.swapPkScript, [
2468
+ ...unstamped.get(record.swapPkScript) ?? [],
2469
+ record
2470
+ ]);
2471
+ }
2472
+ const write = async (record) => {
2473
+ await store.saveSwapRecord(record);
2474
+ current.set(record.id, record);
2475
+ remember(record);
2476
+ };
2477
+ for (const found of restored) {
2478
+ const known = byDeposit.get(`${found.swapPkScript}:${found.fundingTxid}`);
2479
+ if (known !== void 0) {
2480
+ if (fateMoved(known, found)) await write(withDepositFate(known, found, now()));
2481
+ continue;
2061
2482
  }
2062
- if (OFFER_LIVE(status) && record.fundingTxid) stillLive.add(record.fundingTxid);
2483
+ const orphan = unstamped.get(found.swapPkScript)?.shift();
2484
+ if (orphan !== void 0) {
2485
+ await write(
2486
+ withDepositFate({ ...orphan, fundingTxid: found.fundingTxid }, found, now())
2487
+ );
2488
+ continue;
2489
+ }
2490
+ await write(restoredOfferRecord(found, network, now()));
2491
+ }
2492
+ const stillLive = /* @__PURE__ */ new Set();
2493
+ for (const record of current.values()) {
2494
+ if (OFFER_LIVE(record.status) && record.fundingTxid) stillLive.add(record.fundingTxid);
2063
2495
  }
2064
2496
  await store.markTxidsScanned(scannedTxids.filter((txid) => !stillLive.has(txid)));
2065
2497
  const registry = managerDeps.contracts;
2066
2498
  if (registry) {
2067
- const { offer: current } = splitRecords(await store.getAllSwapRecords());
2068
- await retireSettledOfferContracts(registry, current.map(offerFactsOf));
2499
+ await retireSettledOfferContracts(registry, [...current.values()].map(offerFactsOf), {
2500
+ scope: wallet
2501
+ });
2069
2502
  }
2503
+ return [...current.values()];
2070
2504
  };
2071
2505
  const contractsOf = async () => managerDeps.contracts ??= await wallet.getContractManager();
2506
+ const lockupSource = {
2507
+ getContractsWithVtxos: async (filter) => (await contractsOf()).getContractsWithVtxos(filter)
2508
+ };
2072
2509
  const registerCorridorSwap = async (record) => {
2510
+ if (fundingWasNotSubmitted(record)) return;
2073
2511
  if (mode === "readonly") return;
2074
2512
  if (!await drivable(record)) {
2075
2513
  undrivable.add(record.id);
@@ -2101,7 +2539,7 @@ var createSwapDrive = (config) => {
2101
2539
  wireCallbacks();
2102
2540
  await manager.start();
2103
2541
  await markPassed();
2104
- if (!watcher && repository) {
2542
+ if (!watcher) {
2105
2543
  watcher = await watchOfferSwaps({
2106
2544
  wallet,
2107
2545
  source: offers(),
@@ -2109,20 +2547,90 @@ var createSwapDrive = (config) => {
2109
2547
  });
2110
2548
  }
2111
2549
  };
2550
+ const registerRestoredOffers = async (offers2) => {
2551
+ if (mode === "readonly") return;
2552
+ const live2 = offers2.filter(
2553
+ (record) => record.fundingTxid !== void 0 && !RETIRABLE.includes(record.status)
2554
+ );
2555
+ if (live2.length === 0) return;
2556
+ try {
2557
+ await restoreOfferCoverage(wallet, live2.map(offerFactsOf));
2558
+ } catch (error) {
2559
+ console.warn("[swap] could not register restored offer covenants", error);
2560
+ }
2561
+ };
2562
+ const adoptLegacyRfqSwaps = async (store) => {
2563
+ try {
2564
+ const toAdopt = await legacyRfqSwapsToAdopt(store);
2565
+ if (toAdopt.length === 0) return;
2566
+ const network = await config.network();
2567
+ const contracts = await contractsOf();
2568
+ for (const v1 of toAdopt) {
2569
+ try {
2570
+ const params = await lockupContractParams(contracts, v1.lockupAddress).catch(
2571
+ (error) => {
2572
+ if (error instanceof LockupContractMissing) return void 0;
2573
+ throw error;
2574
+ }
2575
+ );
2576
+ if (params === void 0 && !isRfqSwapTerminal(v1.state)) continue;
2577
+ const refundLocktime = params ? Number(params.refundLocktime) : 0;
2578
+ await store.saveSwapRecord(restoredCorridorRecord(v1, network, refundLocktime));
2579
+ } catch (error) {
2580
+ console.warn(`[swap] could not adopt v1 rfq swap ${v1.rfqId}`, error);
2581
+ }
2582
+ }
2583
+ } catch (error) {
2584
+ console.warn("[swap] v1 rfq swap adoption did not complete", error);
2585
+ }
2586
+ };
2587
+ const migrateOfferRows = async () => {
2588
+ if (mode === "readonly") return;
2589
+ try {
2590
+ const { skipped } = await migrateV0OfferRows(await wallet.getContractManager());
2591
+ for (const { script, reason } of skipped) {
2592
+ console.warn(`[swap] could not migrate Program v0 offer row ${script}: ${reason}`);
2593
+ }
2594
+ } catch (error) {
2595
+ console.warn("[swap] Program v0 offer row migration did not complete", error);
2596
+ }
2597
+ };
2112
2598
  const restore = async () => {
2599
+ void track(migrateOfferRows());
2113
2600
  if (!repository) return;
2114
- const all = await repository.getAllSwapRecords();
2601
+ await adoptLegacyRfqSwaps(repository);
2602
+ const all = await collectSwapRecords(repository);
2115
2603
  const { corridor, offer } = splitRecords(all.filter(readableRecord));
2116
- for (const record of [...corridor, ...offer]) records.set(record.id, record);
2604
+ const retiredScripts = /* @__PURE__ */ new Set();
2605
+ for (const record of [...corridor, ...offer]) {
2606
+ records.set(record.id, record);
2607
+ if (mode !== "readonly" && fundingWasNotSubmitted(record)) {
2608
+ const script = record.family === "offer" ? record.swapPkScript : record.lockupPkScript;
2609
+ if (retiredScripts.has(script)) continue;
2610
+ retiredScripts.add(script);
2611
+ try {
2612
+ await retireUnsubmittedFunding(wallet, repository, record, await contractsOf());
2613
+ } catch (error) {
2614
+ console.warn(
2615
+ `[swap] could not restore unsent coverage for ${record.id}`,
2616
+ error
2617
+ );
2618
+ }
2619
+ }
2620
+ }
2117
2621
  const liveCorridor = corridor.filter((record) => !isRfqSwapTerminal(record.state));
2118
2622
  const store = corridorStore();
2119
2623
  for (const record of liveCorridor) store.index(record);
2120
- if (liveCorridor.length > 0) {
2624
+ const liveLegacy = await legacyLiveRfqSwaps(repository);
2625
+ if (liveCorridor.length > 0 || liveLegacy.length > 0) {
2121
2626
  try {
2122
2627
  await contractsOf();
2123
2628
  for (const record of liveCorridor) {
2124
2629
  if (!await drivable(record)) undrivable.add(record.id);
2125
2630
  }
2631
+ for (const record of liveLegacy) {
2632
+ if (!await drivable(record)) undrivableLegacy.add(record.rfqId);
2633
+ }
2126
2634
  managerDeps.repository = store;
2127
2635
  const result = await manager.restoreFromRepository();
2128
2636
  for (const swap of result.restored) {
@@ -2139,13 +2647,19 @@ var createSwapDrive = (config) => {
2139
2647
  console.warn("[swap] the corridor restore could not drive", error);
2140
2648
  }
2141
2649
  }
2650
+ let offers2 = offer;
2142
2651
  try {
2143
- await sweepOfferDeposits(offer);
2652
+ offers2 = await restoreOfferDeposits(
2653
+ offer.flatMap(
2654
+ (record) => record.status === "recoverable" && record.fundingTxid !== void 0 ? [record.fundingTxid] : []
2655
+ )
2656
+ );
2144
2657
  } catch (error) {
2145
- console.warn("[swap] the offer deposit sweep did not complete", error);
2658
+ console.warn("[swap] the offer deposit restore did not complete", error);
2146
2659
  }
2660
+ await registerRestoredOffers(offers2);
2147
2661
  emitAll();
2148
- if (mode === "auto" && await hasLiveWork(offer)) {
2662
+ if (mode === "auto" && await hasLiveWork(offers2)) {
2149
2663
  try {
2150
2664
  await arm();
2151
2665
  } catch (error) {
@@ -2173,7 +2687,7 @@ var createSwapDrive = (config) => {
2173
2687
  }
2174
2688
  return probe.call(wallet);
2175
2689
  };
2176
- const recoverableAt = async (script) => (await findLockupVtxos(indexer, script)).filter((vtxo) => vtxo.recoverable);
2690
+ const recoverableAt = async (script) => (await findLockupVtxos(lockupSource, script)).filter((vtxo) => vtxo.recoverable);
2177
2691
  const recover = async (id) => {
2178
2692
  if (disposed) throw new ClientDisposed("recover");
2179
2693
  if (mode === "readonly") {
@@ -2197,7 +2711,7 @@ var createSwapDrive = (config) => {
2197
2711
  id
2198
2712
  );
2199
2713
  }
2200
- const script = hex4.decode(record.lockupPkScript);
2714
+ const script = hex6.decode(record.lockupPkScript);
2201
2715
  const before = await recoverableAt(script);
2202
2716
  if (before.length === 0) {
2203
2717
  throw new SwapDriveRefusedError(
@@ -2207,8 +2721,8 @@ var createSwapDrive = (config) => {
2207
2721
  );
2208
2722
  }
2209
2723
  const txid2 = await track((await recoverer()).recoverVtxos());
2210
- const after2 = await recoverableAt(script);
2211
- const still = new Set(after2.map((vtxo) => `${vtxo.txid}:${vtxo.vout}`));
2724
+ const after = await recoverableAt(script);
2725
+ const still = new Set(after.map((vtxo) => `${vtxo.txid}:${vtxo.vout}`));
2212
2726
  const recovered2 = before.every((vtxo) => !still.has(`${vtxo.txid}:${vtxo.vout}`));
2213
2727
  if (recovered2) swept.delete(id);
2214
2728
  await manager.poll();
@@ -2222,10 +2736,31 @@ var createSwapDrive = (config) => {
2222
2736
  id
2223
2737
  );
2224
2738
  }
2225
- const txid = await track((await recoverer()).recoverVtxos());
2226
- await sweepOfferDeposits([records.get(id)]);
2227
- const after = records.get(id);
2228
- const recovered = after?.family === "offer" && after.status !== "recoverable";
2739
+ const wentHome = async () => {
2740
+ await restoreOfferDeposits(
2741
+ record.fundingTxid === void 0 ? [] : [record.fundingTxid]
2742
+ );
2743
+ const after = records.get(id);
2744
+ return after?.family === "offer" && after.status !== "recoverable";
2745
+ };
2746
+ try {
2747
+ if (await wentHome()) return { recovered: true, swap: swapView(id) };
2748
+ } catch (error) {
2749
+ console.warn(`[swap] could not re-read offer ${id} before recovering it`, error);
2750
+ }
2751
+ const vtxoManager = await recoverer();
2752
+ await restoreOfferCoverage(wallet, [offerFactsOf(record)]);
2753
+ const txid = await track(vtxoManager.recoverVtxos());
2754
+ recoveredIn.add(txid);
2755
+ let recovered = false;
2756
+ try {
2757
+ recovered = await wentHome();
2758
+ } catch (error) {
2759
+ console.warn(
2760
+ `[swap] recovered offer ${id} in ${txid}, but could not re-read it`,
2761
+ error
2762
+ );
2763
+ }
2229
2764
  return { recovered, txid, swap: swapView(id) };
2230
2765
  };
2231
2766
  const swapView = (id) => {
@@ -2279,6 +2814,10 @@ var createSwapDrive = (config) => {
2279
2814
  adopt: (record) => {
2280
2815
  if (disposed) throw new ClientDisposed("accept");
2281
2816
  records.set(record.id, record);
2817
+ if (fundingWasNotSubmitted(record)) {
2818
+ emit(record.id);
2819
+ return swapView(record.id);
2820
+ }
2282
2821
  if (record.family === "rfq") {
2283
2822
  corridorStore().index(record);
2284
2823
  managerDeps.repository = corridorStore();
@@ -2314,8 +2853,9 @@ var marketKeyOf = (card) => {
2314
2853
  }
2315
2854
  return base <= quote ? `${base}/${quote}` : `${quote}/${base}`;
2316
2855
  };
2317
- var isAddressable = (card) => !isRfqMarket2(card) || typeof card.discovery_pubkey === "string" && (card.transports?.nostr?.relays?.length ?? 0) > 0;
2318
- var marketBackendOf = (card) => isRfqMarket2(card) ? "rfq" : "feed";
2856
+ var hasRendezvous = (card) => typeof card.discovery_pubkey === "string" && (card.transports?.nostr?.relays?.length ?? 0) > 0;
2857
+ var isAddressable = (card) => !isRfqMarket2(card) || hasRendezvous(card);
2858
+ var marketBackendOf = (card) => isRfqMarket2(card) || hasRendezvous(card) ? "rfq" : "feed";
2319
2859
  var usableMarkets = (snapshot, policy) => {
2320
2860
  const allowed = policy?.allowedRegistries;
2321
2861
  return (allowed ? snapshot.markets.filter((card) => allowed.includes(card.source)) : snapshot.markets).filter(isAddressable);
@@ -2327,16 +2867,23 @@ var eligibleMarkets = (snapshot, legs, policy, takeAmount) => {
2327
2867
  const oriented = (side) => {
2328
2868
  const base = side === "base" ? give : take;
2329
2869
  const quote = side === "base" ? take : give;
2330
- return selectMarkets([...markets], {
2331
- baseId: base.assetId,
2332
- quoteId: quote.assetId,
2333
- baseCorridor: base.corridor,
2334
- quoteCorridor: quote.corridor,
2335
- // The trader receives the take leg, so that side must be one the
2336
- // solver can pay out; a direction nobody solves yields no market.
2870
+ const selection = {
2871
+ // The trader receives the take leg, so the solver must be able to pay that side out.
2337
2872
  wantSide: side === "base" ? "quote" : "base",
2338
2873
  ...takeAmount === void 0 ? {} : { wantAmount: takeAmount }
2339
- }).map((card) => ({
2874
+ };
2875
+ const canonical = selectMarkets([...markets], {
2876
+ baseId: base.marketId,
2877
+ quoteId: quote.marketId,
2878
+ ...selection
2879
+ });
2880
+ const legacy = selectMarkets([...markets], {
2881
+ baseId: `${base.corridor}:${base.assetId}`,
2882
+ quoteId: `${quote.corridor}:${quote.assetId}`,
2883
+ ...selection
2884
+ });
2885
+ const selected = [.../* @__PURE__ */ new Set([...canonical, ...legacy])];
2886
+ return selected.map((card) => ({
2340
2887
  card,
2341
2888
  give: side,
2342
2889
  backend: marketBackendOf(card),
@@ -2364,7 +2911,7 @@ var cardMarketOf = (card, snapshot, key, backend) => ({
2364
2911
  sourceType: card.sourceType,
2365
2912
  solver: card.solver,
2366
2913
  ...card.discovery_pubkey === void 0 ? {} : { discoveryPubkey: card.discovery_pubkey },
2367
- pair: card.pair,
2914
+ pair: card.pair ?? marketPairLabel(card),
2368
2915
  snapshot
2369
2916
  });
2370
2917
  var isCardMarket = (market) => market.kind === "card";
@@ -2374,7 +2921,8 @@ var SUPPORTED_PAIRS = [
2374
2921
  "arkade->arkade",
2375
2922
  "arkade->lightning",
2376
2923
  "lightning->arkade",
2377
- "arkade->onchain"
2924
+ "arkade->onchain",
2925
+ "onchain->arkade"
2378
2926
  ];
2379
2927
  var isSupportedPair = (pair) => SUPPORTED_PAIRS.includes(pair);
2380
2928
  var assembleRoute = (give, take) => {
@@ -2388,16 +2936,16 @@ var assembleRoute = (give, take) => {
2388
2936
  }
2389
2937
  return { give, take };
2390
2938
  };
2391
- var endpoint = (corridor, asset3, instrument) => ({
2939
+ var endpoint = (corridor, asset5, instrument) => ({
2392
2940
  corridor,
2393
- asset: asset3,
2941
+ asset: asset5,
2394
2942
  ...instrument === void 0 ? {} : { instrument }
2395
2943
  });
2396
- var legFor = (asset3, expected) => {
2397
- const leg = toDiscoveryLeg(asset3);
2944
+ var legFor = (asset5, expected) => {
2945
+ const leg = toDiscoveryLeg(asset5);
2398
2946
  if (expected !== void 0 && leg.corridor !== expected) {
2399
2947
  throw new UnsupportedRoute(
2400
- `${asset3} settles on ${leg.corridor}, and this leg is ${expected}`,
2948
+ `${asset5} settles on ${leg.corridor}, and this leg is ${expected}`,
2401
2949
  { give: leg.corridor, take: expected }
2402
2950
  );
2403
2951
  }
@@ -2435,10 +2983,10 @@ var resolveRoute = async (input, deps) => {
2435
2983
  }
2436
2984
  const pair = `${giveLeg.corridor}->${takeLeg.corridor}`;
2437
2985
  if (!isSupportedPair(pair)) {
2438
- throw new UnsupportedRoute(
2439
- 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`,
2440
- { give: giveLeg.corridor, take: takeLeg.corridor }
2441
- );
2986
+ throw new UnsupportedRoute(`${pair} is not an implemented route`, {
2987
+ give: giveLeg.corridor,
2988
+ take: takeLeg.corridor
2989
+ });
2442
2990
  }
2443
2991
  const give = endpoint(
2444
2992
  giveLeg.corridor,
@@ -2479,11 +3027,9 @@ var resolveRoute = async (input, deps) => {
2479
3027
  aliases
2480
3028
  };
2481
3029
  };
2482
- var isCorridor = (value) => value === "arkade" || value === "lightning" || value === "onchain";
3030
+ var isCorridor = (value) => CORRIDORS.includes(value);
2483
3031
  var assetFor = (ref, corridor, network, aliases) => ref === void 0 ? btcOn(railOfCorridor(corridor), network) : (
2484
- // Scoped to the leg's rail, because BTC has one id per rail and a
2485
- // whole-table lookup would refuse `"BTC"` as ambiguous on any snapshot
2486
- // carrying a corridor market — see `scopedToRail`.
3032
+ // Rail-scoped: BTC has one id per rail, so a whole-table `"BTC"` is ambiguous.
2487
3033
  canonicalAssetId(ref, scopedToRail(aliases, railOfCorridor(corridor)))
2488
3034
  );
2489
3035
  var pinAmount = (input, takeInstrument) => {
@@ -2504,6 +3050,9 @@ var pinAmount = (input, takeInstrument) => {
2504
3050
  return void 0;
2505
3051
  };
2506
3052
 
3053
+ // src/client/policy.ts
3054
+ var DEFAULT_MAX_REFUND_WINDOW_SECONDS = 30 * 24 * 3600;
3055
+
2507
3056
  // src/client/verify.ts
2508
3057
  var reasonOf = (error) => error instanceof Error && typeof error.reason === "string" ? error.reason : void 0;
2509
3058
  var CHECK_BY_REASON = {
@@ -2655,15 +3204,24 @@ var verifyQuoteTtl = (input) => {
2655
3204
  throw new QuoteExpired(input.quoteId, input.expiresAt, input.now);
2656
3205
  }
2657
3206
  };
2658
- var verifyQuotedAmount = (input) => {
2659
- const quoted = input.pinned.on === "give" ? input.give : input.take;
2660
- if (quoted !== input.pinned.value) {
3207
+ var CSV_GRANULARITY_SECONDS = 512;
3208
+ var verifyRefundWindow = (input) => {
3209
+ const max = input.maxSeconds ?? DEFAULT_MAX_REFUND_WINDOW_SECONDS;
3210
+ const window = input.refundLocktime - input.now;
3211
+ if (!(window <= max)) {
3212
+ throw new QuoteVerificationFailed("refund_window", `at most ${max}s`, `${window}s`);
3213
+ }
3214
+ const delay = input.refundWithoutReceiverDelay;
3215
+ if (delay !== void 0 && !(delay < max + CSV_GRANULARITY_SECONDS)) {
2661
3216
  throw new QuoteVerificationFailed(
2662
- "pair",
2663
- `${input.pair} ${input.pinned.on}=${input.pinned.value}`,
2664
- `${input.pair} ${input.pinned.on}=${quoted}`
3217
+ "refund_window",
3218
+ `a solo-refund delay of at most ${max}s`,
3219
+ `${delay}s`
2665
3220
  );
2666
3221
  }
3222
+ };
3223
+ var verifyQuotedAmount = (input) => {
3224
+ verifyPinnedAmount(input);
2667
3225
  if (input.take > input.give) {
2668
3226
  throw new QuoteVerificationFailed(
2669
3227
  "pair",
@@ -2672,10 +3230,44 @@ var verifyQuotedAmount = (input) => {
2672
3230
  );
2673
3231
  }
2674
3232
  };
3233
+ var verifyCrossAssetAmount = (input) => {
3234
+ verifyPinnedAmount(input);
3235
+ if (input.give <= 0n || input.take <= 0n) {
3236
+ throw new QuoteVerificationFailed(
3237
+ "pair",
3238
+ `${input.pair} give > 0 take > 0`,
3239
+ `give=${input.give} take=${input.take}`
3240
+ );
3241
+ }
3242
+ };
3243
+ var verifiedCarrierSats = (quote) => {
3244
+ try {
3245
+ return quoteCarrierSats(quote);
3246
+ } catch (error) {
3247
+ if (reasonOf(error) !== "carrier_malformed") throw error;
3248
+ throw new QuoteVerificationFailed(
3249
+ "pair",
3250
+ "carrier_sats a non-negative integer",
3251
+ String(quote.carrier_sats),
3252
+ { cause: error }
3253
+ );
3254
+ }
3255
+ };
3256
+ var verifyPinnedAmount = (input) => {
3257
+ const quoted = input.pinned.on === "give" ? input.give : input.take;
3258
+ if (quoted !== input.pinned.value) {
3259
+ throw new QuoteVerificationFailed(
3260
+ "pair",
3261
+ `${input.pair} ${input.pinned.on}=${input.pinned.value}`,
3262
+ `${input.pair} ${input.pinned.on}=${quoted}`
3263
+ );
3264
+ }
3265
+ };
2675
3266
 
2676
3267
  // src/client/quoteOffer.ts
2677
3268
  import {
2678
3269
  computeWantAmount,
3270
+ marketLegKey as marketLegKey2,
2679
3271
  quoteOffer
2680
3272
  } from "@arkade-os/solver-discovery";
2681
3273
  var FEED_TTL_MS = 3e4;
@@ -2695,6 +3287,9 @@ var quoteFromFeed = async (input) => {
2695
3287
  const plan = await quoteOffer(candidate.card, {
2696
3288
  give: candidate.give,
2697
3289
  ...amount.on === "give" ? { giveAmount: amount.value } : { wantAmount: amount.value },
3290
+ // What `fund` attaches to an asset deposit and the fill pays an asset want: the plan asks
3291
+ // for it back in a BTC payout, and charges it where the card declares a delivered carrier.
3292
+ carrierSats: ASSET_CARRIER_SATS,
2698
3293
  ...QUOTE_OPTIONS,
2699
3294
  fetchImpl: input.feed.fetch
2700
3295
  });
@@ -2718,12 +3313,21 @@ var quoteFromFeed = async (input) => {
2718
3313
  take: { asset: input.endpoints.take.asset, amount: plan.receive.atomic },
2719
3314
  market: input.market,
2720
3315
  expiresAt,
2721
- fee: { amount: spreadOf(plan), asset: input.endpoints.take.asset }
3316
+ fee: {
3317
+ // The plan's payout returns the deposit's carrier; that part is not proceeds.
3318
+ amount: feedSpread(
3319
+ plan,
3320
+ plan.receive.atomic,
3321
+ sellsAssetForBtc(input.endpoints) ? ASSET_CARRIER_SATS : 0n
3322
+ ),
3323
+ asset: input.endpoints.take.asset
3324
+ }
2722
3325
  },
2723
3326
  preparation: { backend: "feed", card: candidate.card, plan, give: candidate.give }
2724
3327
  };
2725
3328
  };
2726
- var spreadOf = (plan) => {
3329
+ var feedSpread = (plan, take, carrierSats = 0n) => {
3330
+ const payout = take > carrierSats ? take - carrierSats : 0n;
2727
3331
  const fair = computeWantAmount({
2728
3332
  deposit: plan.deposit.atomic,
2729
3333
  give: plan.give,
@@ -2731,22 +3335,110 @@ var spreadOf = (plan) => {
2731
3335
  feeBps: 0,
2732
3336
  safetyBps: 0
2733
3337
  });
2734
- const spread = fair - plan.receive.atomic;
3338
+ const spread = fair - payout;
2735
3339
  return spread > 0n ? spread : 0n;
2736
3340
  };
3341
+ var sellsAssetForBtc = (endpoints) => !isBtcAsset(endpoints.give.asset) && isBtcAsset(endpoints.take.asset);
2737
3342
  var feedExpiry = (card, feed, now) => {
2738
3343
  const readAt = card.price_feed === void 0 ? void 0 : feed.fetchedAt(card.price_feed);
2739
3344
  const from = readAt === void 0 ? now : Math.floor(readAt / 1e3);
2740
3345
  return from + FEED_TTL_MS / 1e3;
2741
3346
  };
2742
3347
  var verifyPlanLegs = (plan, legs, give) => {
2743
- const expected = `${legs.give.assetId}->${legs.take.assetId}`;
2744
- const priced = `${plan.deposit.asset.id}->${plan.receive.asset.id}`;
2745
- if (expected !== priced || plan.give !== give) {
2746
- throw new QuoteVerificationFailed("pair", expected, priced);
3348
+ const take = give === "base" ? "quote" : "base";
3349
+ const spelled = (side) => marketLegKey2(plan.market, side);
3350
+ const names = (side, leg) => spelled(side) === leg.marketId || spelled(side) === `${leg.corridor}:${leg.assetId}`;
3351
+ if (plan.give !== give || !names(give, legs.give) || !names(take, legs.take)) {
3352
+ throw new QuoteVerificationFailed(
3353
+ "pair",
3354
+ `${legs.give.marketId}->${legs.take.marketId}`,
3355
+ `${spelled(give)}->${spelled(take)}`
3356
+ );
2747
3357
  }
2748
3358
  };
2749
3359
 
3360
+ // src/jointGraph.ts
3361
+ import { base64 as base642, hex as hex7 } from "@scure/base";
3362
+ import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
3363
+ import { Transaction as Transaction2 } from "@arkade-os/sdk";
3364
+ function digestJointGraph(plan, template) {
3365
+ const parts = [];
3366
+ const pushU32 = (value) => {
3367
+ const len = new Uint8Array(4);
3368
+ new DataView(len.buffer).setUint32(0, value, false);
3369
+ parts.push(len);
3370
+ };
3371
+ const pushField = (bytes) => {
3372
+ pushU32(bytes.length);
3373
+ parts.push(bytes);
3374
+ };
3375
+ pushField(new TextEncoder().encode(template));
3376
+ pushField(unsignedPsbtBytes(parseGraphTx(plan.arkTx)));
3377
+ pushU32(plan.checkpoints.length);
3378
+ for (const checkpoint of plan.checkpoints) {
3379
+ pushField(unsignedPsbtBytes(parseGraphTx(checkpoint)));
3380
+ }
3381
+ pushU32(plan.inputOwners.length);
3382
+ for (const owner of plan.inputOwners) {
3383
+ if (owner === null) {
3384
+ parts.push(new Uint8Array([0]));
3385
+ } else {
3386
+ const bytes = new TextEncoder().encode(owner);
3387
+ parts.push(new Uint8Array([1]));
3388
+ pushField(bytes);
3389
+ }
3390
+ }
3391
+ const preimage = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
3392
+ let at = 0;
3393
+ for (const part of parts) {
3394
+ preimage.set(part, at);
3395
+ at += part.length;
3396
+ }
3397
+ return hex7.encode(sha2562(preimage));
3398
+ }
3399
+ function verifyJointGraph(plan, template) {
3400
+ try {
3401
+ if (!plan || typeof plan !== "object") return false;
3402
+ if (typeof plan.arkTx !== "string" || plan.arkTx.length === 0) return false;
3403
+ if (!Array.isArray(plan.checkpoints) || plan.checkpoints.length < 1 || plan.checkpoints.some((c) => typeof c !== "string" || c.length === 0))
3404
+ return false;
3405
+ if (!/^[0-9a-f]{64}$/.test(plan.graphId)) return false;
3406
+ if (!Array.isArray(plan.inputOwners) || plan.inputOwners.some((o) => o !== null && (typeof o !== "string" || o.length === 0)))
3407
+ return false;
3408
+ if (plan.inputOwners.length !== plan.checkpoints.length) return false;
3409
+ const arkInputs = parseGraphTx(plan.arkTx).inputsLength;
3410
+ if (plan.checkpoints.length !== arkInputs) return false;
3411
+ if (plan.inputOwners.length !== arkInputs) return false;
3412
+ return digestJointGraph(
3413
+ {
3414
+ arkTx: plan.arkTx,
3415
+ checkpoints: [...plan.checkpoints],
3416
+ inputOwners: [...plan.inputOwners]
3417
+ },
3418
+ template
3419
+ ) === plan.graphId;
3420
+ } catch {
3421
+ return false;
3422
+ }
3423
+ }
3424
+ function parseGraphTx(psbt) {
3425
+ return Transaction2.fromPSBT(base642.decode(psbt));
3426
+ }
3427
+ function deepFreeze(value) {
3428
+ if (value !== null && typeof value === "object") {
3429
+ for (const child of Object.values(value)) deepFreeze(child);
3430
+ Object.freeze(value);
3431
+ }
3432
+ return value;
3433
+ }
3434
+ function unsignedPsbtBytes(tx) {
3435
+ const stripped = tx.clone();
3436
+ for (let i = 0; i < stripped.inputsLength; i++) {
3437
+ stripped.updateInput(i, { tapScriptSig: void 0 });
3438
+ }
3439
+ return stripped.toPSBT();
3440
+ }
3441
+
2750
3442
  // src/client/sats.ts
2751
3443
  var satsOf = (value, field) => {
2752
3444
  if (value < 0n || value > BigInt(Number.MAX_SAFE_INTEGER)) {
@@ -2764,8 +3456,7 @@ var PAYMENT_STATUS = {
2764
3456
  /** Persisted, funding not broadcast. */
2765
3457
  accepted: "pending",
2766
3458
  funding: "pending",
2767
- /** The lockup is funded. Nothing has emitted `"sent"` in core since the
2768
- * `onchain-swap` rail left with `packages/boltz-swap`. */
3459
+ /** The lockup is funded. */
2769
3460
  funded: "sent",
2770
3461
  /** Asset swaps only: an unfilled offer. */
2771
3462
  open: "pending",
@@ -2829,14 +3520,19 @@ var receiverExact = (railId, parts) => {
2829
3520
  total: satsOf(parts.total, `${railId}.total`)
2830
3521
  };
2831
3522
  };
3523
+ var quoteMeta = (quote) => ({
3524
+ quoteId: quote.id,
3525
+ expiresAt: quote.expiresAt,
3526
+ ...quote.refundLocktime === void 0 ? {} : { refundLocktime: quote.refundLocktime },
3527
+ ...quote.solver === void 0 ? {} : { solver: quote.solver },
3528
+ ...quote.lock === void 0 ? {} : { paymentHash: quote.lock.hash },
3529
+ ...quote.market.kind === "restored" ? {} : { market: quote.market.key }
3530
+ });
2832
3531
  var resultOf = (railId, swap) => ({
2833
3532
  railId,
2834
- // The tagged public form M6 minted — round-trippable to `client.swaps()`,
2835
- // which is where the outcomes past this handle's terminal one are read.
3533
+ // tagged, so it joins `client.swaps()`/`onUpdate` for outcomes past this handle's terminal one
2836
3534
  swapId: swap.id,
2837
- // The transaction that left THIS wallet, which is what `txid` means on
2838
- // every other rail. A swap's later legs — the solver's fill, the trader's
2839
- // L1 claim — are the client's to report, not the handle's.
3535
+ // the tx that left THIS wallet, as on every other rail; later legs are the client's to report
2840
3536
  ...swap.fundingTxid === void 0 ? {} : { txid: swap.fundingTxid }
2841
3537
  });
2842
3538
  var swapHandle = async (railId, client, quote) => makeHandle(railId, async (emit) => {
@@ -2916,8 +3612,7 @@ function onchainSwapRail(client, deps) {
2916
3612
  }
2917
3613
  const amounts = receiverExact(ONCHAIN_SWAP_RAIL, {
2918
3614
  amount: payout,
2919
- // Both halves of the cost, inside one number: the solver's
2920
- // spread, and the claim the trader pays for out of the payout.
3615
+ // The solver's spread plus the claim the trader pays out of the payout.
2921
3616
  fee: quote.fee.amount + claimFee,
2922
3617
  total: quote.give.amount
2923
3618
  });
@@ -2925,13 +3620,7 @@ function onchainSwapRail(client, deps) {
2925
3620
  railId: ONCHAIN_SWAP_RAIL,
2926
3621
  ...amounts,
2927
3622
  meta: {
2928
- quoteId: quote.id,
2929
- expiresAt: quote.expiresAt,
2930
- ...quote.refundLocktime === void 0 ? {} : { refundLocktime: quote.refundLocktime },
2931
- ...quote.solver === void 0 ? {} : { solver: quote.solver },
2932
- ...quote.lock === void 0 ? {} : { paymentHash: quote.lock.hash },
2933
- market: quote.market.key,
2934
- // The estimate folded into `fee`, so a caller can see it.
3623
+ ...quoteMeta(quote),
2935
3624
  claimFeeSats: Number(claimFee),
2936
3625
  // What the solver locks on L1, before the claim's fee.
2937
3626
  htlcAmountSats: Number(quote.take.amount)
@@ -2971,22 +3660,29 @@ var parseRfqQuote = (quote) => ({
2971
3660
  });
2972
3661
 
2973
3662
  // src/client/quoteRfq.ts
2974
- import { hex as hex5 } from "@scure/base";
3663
+ import { hex as hex8 } from "@scure/base";
2975
3664
  import {
3665
+ ArkAddress as ArkAddress6,
3666
+ asset as asset4,
2976
3667
  networkFromArkadeInfo,
2977
3668
  provisionClaimSecret,
2978
3669
  provisionRefundKey,
2979
3670
  toXOnly
2980
3671
  } from "@arkade-os/sdk";
3672
+ import { quoteOffer as quoteOffer2 } from "@arkade-os/solver-discovery";
3673
+ var lockupOf = (derived) => ({
3674
+ address: derived.address,
3675
+ script: derived.script,
3676
+ pkScript: derived.swapPkScript
3677
+ });
2981
3678
  var covenantInputs = (input) => {
2982
3679
  const network = networkFromArkadeInfo(input.info);
2983
- const arkade = input.corridors.get("arkade").deps;
3680
+ const arkade2 = input.corridors.get("arkade").deps;
2984
3681
  return {
2985
- operatorPubkey: toXOnly(hex5.decode(input.info.signerPubkey), "ark signer key"),
2986
- // The per-network pin the arkade module already resolved, never a key
2987
- // the operator reports about itself: this one ends up in a covenant leaf
3682
+ operatorPubkey: toXOnly(hex8.decode(input.info.signerPubkey), "ark signer key"),
3683
+ // The resolved per-network pin, never operator-reported: it lands in a covenant leaf
2988
3684
  // that decides who can move the funds.
2989
- emulatorPubkey: toXOnly(hex5.decode(arkade.emulatorPubkey), "emulator signer key"),
3685
+ emulatorPubkey: toXOnly(hex8.decode(arkade2.emulatorPubkey), "emulator signer key"),
2990
3686
  claimDelay: unilateralClaimDelay(Number(input.info.unilateralExitDelay)),
2991
3687
  hrp: network.hrp
2992
3688
  };
@@ -2994,7 +3690,7 @@ var covenantInputs = (input) => {
2994
3690
  var sealingKey = (deps) => {
2995
3691
  const configured = deps.covclaimd?.pubkey;
2996
3692
  if (configured === void 0) return void 0;
2997
- const key = hex5.decode(configured);
3693
+ const key = hex8.decode(configured);
2998
3694
  if (key.length !== 33) {
2999
3695
  throw new Error(
3000
3696
  `the covclaimd deployment key must be 33-byte compressed hex, got ${key.length} bytes`
@@ -3014,14 +3710,198 @@ var quoteViaRfq = async (input) => {
3014
3710
  expected: input.market.discoveryPubkey,
3015
3711
  pinnable: input.market.snapshot.live
3016
3712
  });
3713
+ if (input.assetPayment !== void 0 && input.route !== "arkade->arkade")
3714
+ throw new Error("assetPayment supports BTC-to-asset only");
3017
3715
  switch (input.route) {
3716
+ case "arkade->arkade":
3717
+ return quoteArkadeAsset(input);
3018
3718
  case "arkade->lightning":
3019
3719
  return quoteLightningSend(input);
3020
3720
  case "lightning->arkade":
3021
3721
  return quoteLightningReceive(input);
3022
3722
  case "arkade->onchain":
3023
3723
  return quoteOnchainSend(input);
3724
+ case "onchain->arkade":
3725
+ return quoteOnchainReceive(input);
3726
+ }
3727
+ };
3728
+ var quoteArkadeAsset = async (input) => {
3729
+ const pinned = pinnedFor(input);
3730
+ const sides = assetSidesOf(input.legs);
3731
+ if (pinned.on !== "give" && sides.wantAsset === void 0)
3732
+ throw new Error("asset-to-BTC is exact-in only");
3733
+ const payment = input.assetPayment;
3734
+ if (payment !== void 0 && sides.wantAsset === void 0)
3735
+ throw new Error("assetPayment supports BTC-to-asset only");
3736
+ if (input.candidate.card.price_feed === void 0) {
3737
+ throw new UnsupportedRoute(
3738
+ `card ${input.candidate.card.solver} advertises no price feed to measure an asset swap's fee against`,
3739
+ { give: "arkade", take: "arkade" }
3740
+ );
3741
+ }
3742
+ const pair = rfqPairFor(input.legs.give, input.legs.take);
3743
+ const rfqId = newRfqId();
3744
+ const maker = await makerPosition(input.wallet);
3745
+ const receiveAddress = payment?.receiveAddress;
3746
+ const receivePkScript = resolveReceivePkScript(
3747
+ receiveAddress,
3748
+ maker.pkScript,
3749
+ networkFromArkadeInfo(input.info).hrp,
3750
+ toXOnly(hex8.decode(input.info.signerPubkey), "ark signer key")
3751
+ );
3752
+ const choice = payment?.carrier;
3753
+ const carrierRequest = choice === void 0 ? void 0 : choice.mode === "purchase" ? { mode: "purchase" } : {
3754
+ mode: "recycle_receiver",
3755
+ quoteId: choice.quote.quoteId,
3756
+ taxiUrl: choice.taxi.url,
3757
+ taxiKey: choice.taxi.operatorKey
3758
+ };
3759
+ if (choice?.mode === "recycleReceiver") {
3760
+ if (choice.quote.assetId !== sides.wantAsset?.toString())
3761
+ throw new Error("carrier quote assetId differs from requested asset");
3762
+ if (choice.quote.senderKey !== hex8.encode(maker.publicKey))
3763
+ throw new Error("carrier quote senderKey differs from wallet identity");
3764
+ if (input.now >= choice.quote.expiresAt - 30)
3765
+ throw new Error("carrier quote expired before RFQ");
3766
+ }
3767
+ const request = arkadeSwapRequest({
3768
+ rfqId,
3769
+ ...sides,
3770
+ amount: pinned.value,
3771
+ amountSide: toRfqAmountSide(pinned.on),
3772
+ makerPkScript: receivePkScript,
3773
+ makerPublicKey: maker.publicKey
3774
+ });
3775
+ const wire = await input.transport.requestQuote({
3776
+ ...request,
3777
+ profile: {
3778
+ ...request.profile,
3779
+ ...carrierRequest === void 0 ? {} : { carrier: encodeCarrierRequest(carrierRequest) }
3780
+ }
3781
+ });
3782
+ verifyPair(wire.pair, pair);
3783
+ const parsed = parseRfqQuote(wire);
3784
+ verifyCrossAssetAmount({ pair, pinned, give: parsed.give, take: parsed.take });
3785
+ verifyQuoteTtl({
3786
+ quoteId: input.quoteId,
3787
+ expiresAt: parsed.validUntil,
3788
+ now: input.now,
3789
+ floorSeconds: input.policy?.quoteTtlFloorSeconds
3790
+ });
3791
+ let assetPayment;
3792
+ if (payment !== void 0) {
3793
+ let carrier;
3794
+ if (carrierRequest !== void 0) {
3795
+ carrier = parseCarrierEcho(wire.profile?.carrier, carrierRequest);
3796
+ if (carrier.physicalSats !== input.info.dust)
3797
+ throw new Error("carrier physical differs from server dust");
3798
+ if (carrier.expiresAt > parsed.validUntil)
3799
+ throw new Error("carrier echo extends solver expiry");
3800
+ if (choice?.mode === "recycleReceiver") {
3801
+ if (wire.carrier_sats !== void 0)
3802
+ throw new Error("receiver-paid quote must publish no carrier_sats");
3803
+ assertReceiverPaidEchoMatchesExpected(carrier, choice.quote);
3804
+ } else if (parseTopLevelCarrierSats(wire.carrier_sats) !== carrier.physicalSats)
3805
+ throw new Error("carrier echo differs from carrier_sats");
3806
+ }
3807
+ const validUntil = Math.min(
3808
+ parsed.validUntil,
3809
+ carrier?.expiresAt ?? parsed.validUntil,
3810
+ choice?.mode === "recycleReceiver" ? choice.quote.expiresAt : parsed.validUntil
3811
+ ) - 30;
3812
+ if (input.now >= validUntil) throw new Error("asset payment terms lapsed before funding");
3813
+ assetPayment = {
3814
+ receiveAddress: receiveAddress ?? new ArkAddress6(
3815
+ toXOnly(hex8.decode(input.info.signerPubkey), "ark signer key"),
3816
+ maker.pkScript.slice(2),
3817
+ networkFromArkadeInfo(input.info).hrp
3818
+ ).encode(),
3819
+ validUntil,
3820
+ ...carrier === void 0 ? {} : { carrier },
3821
+ ...choice?.mode !== "recycleReceiver" || choice.inputExpiryFloor === void 0 ? {} : { inputExpiryFloor: choice.inputExpiryFloor }
3822
+ };
3823
+ }
3824
+ if (assetPayment !== void 0) deepFreeze(assetPayment);
3825
+ const carrierSats = sides.offerAsset === void 0 ? void 0 : verifiedCarrierSats(wire);
3826
+ const reference = await quoteOffer2(input.candidate.card, {
3827
+ give: input.candidate.give,
3828
+ giveAmount: parsed.give,
3829
+ ...carrierSats === void 0 ? {} : { carrierSats },
3830
+ ...QUOTE_OPTIONS,
3831
+ fetchImpl: input.feed.fetch
3832
+ });
3833
+ verifyPlanLegs(reference, input.legs, input.candidate.give);
3834
+ const terms = offerTermsFromQuote(wire, sides);
3835
+ const offer = await deriveOffer(input.wallet, {
3836
+ wantAmount: terms.wantAmount,
3837
+ ...terms.wantAsset === void 0 ? {} : { wantAsset: terms.wantAsset },
3838
+ ...terms.offerAsset === void 0 ? {} : { offerAsset: terms.offerAsset },
3839
+ emulatorPubkey: input.corridors.get("arkade").deps.emulatorPubkey,
3840
+ maker,
3841
+ ...receiveAddress === void 0 ? {} : { receiveAddress },
3842
+ info: input.info
3843
+ });
3844
+ verifyingDerivation(() => verifyOfferAddress(wire, offer));
3845
+ return {
3846
+ quote: {
3847
+ id: input.quoteId,
3848
+ ...assetPayment === void 0 ? {} : { assetPayment },
3849
+ route: assembleRoute(
3850
+ { ...input.endpoints.give, instrument: { kind: "wallet" } },
3851
+ {
3852
+ ...input.endpoints.take,
3853
+ instrument: receiveAddress === void 0 ? { kind: "wallet" } : { kind: "address", address: receiveAddress }
3854
+ }
3855
+ ),
3856
+ give: { asset: input.endpoints.give.asset, amount: parsed.give },
3857
+ take: { asset: input.endpoints.take.asset, amount: parsed.take },
3858
+ market: input.market,
3859
+ solver: parsed.solver,
3860
+ expiresAt: parsed.validUntil,
3861
+ // Exactly one leg is BTC, so an asset deposit's carrier is on the payout's unit.
3862
+ fee: {
3863
+ amount: feedSpread(reference, parsed.take, carrierSats),
3864
+ asset: input.endpoints.take.asset
3865
+ }
3866
+ },
3867
+ preparation: {
3868
+ backend: "rfq",
3869
+ route: "arkade->arkade",
3870
+ card: input.candidate.card,
3871
+ rfqId,
3872
+ wire: parsed,
3873
+ offer,
3874
+ ...assetPayment === void 0 ? {} : {
3875
+ assetPayment,
3876
+ assetPaymentRecipient: receiveAddress === void 0 ? { kind: "wallet" } : { kind: "address", address: receiveAddress }
3877
+ },
3878
+ ...carrierSats === void 0 ? {} : { carrierSats }
3879
+ }
3880
+ };
3881
+ };
3882
+ var assetSidesOf = (legs) => {
3883
+ const giveIsBtc = legs.give.assetId === BTC_ASSET_ID;
3884
+ const takeIsBtc = legs.take.assetId === BTC_ASSET_ID;
3885
+ if (giveIsBtc && takeIsBtc) {
3886
+ throw new UnsupportedRoute("arkade:BTC -> arkade:BTC moves one asset, it swaps nothing", {
3887
+ give: "arkade",
3888
+ take: "arkade"
3889
+ });
3890
+ }
3891
+ if (!giveIsBtc && !takeIsBtc) {
3892
+ throw new UnsupportedRoute(
3893
+ `arkade:${legs.give.assetId} -> arkade:${legs.take.assetId}: an asset swap prices one asset against BTC, so exactly one leg must be BTC`,
3894
+ { give: "arkade", take: "arkade" }
3895
+ );
3024
3896
  }
3897
+ return giveIsBtc ? { wantAsset: asset4.AssetId.fromString(legs.take.assetId) } : { offerAsset: asset4.AssetId.fromString(legs.give.assetId) };
3898
+ };
3899
+ var makerPosition = async (wallet) => {
3900
+ const [address, publicKey] = await Promise.all([
3901
+ wallet.getAddress(),
3902
+ wallet.identity.xOnlyPublicKey()
3903
+ ]);
3904
+ return { pkScript: ArkAddress6.decode(address).pkScript, publicKey };
3025
3905
  };
3026
3906
  var quoteLightningSend = async (input) => {
3027
3907
  const invoice = input.endpoints.take.instrument;
@@ -3049,6 +3929,7 @@ var quoteLightningSend = async (input) => {
3049
3929
  paymentHash: invoice.paymentHash,
3050
3930
  senderPubkey: secrets.pubkey,
3051
3931
  refundPkScript: secrets.pkScript,
3932
+ now: input.now,
3052
3933
  ...covenant
3053
3934
  })
3054
3935
  );
@@ -3058,6 +3939,12 @@ var quoteLightningSend = async (input) => {
3058
3939
  now: input.now,
3059
3940
  invoiceExpiresAt: invoice.expiresAt
3060
3941
  });
3942
+ verifyRefundWindow({
3943
+ refundLocktime: derived.refundLocktime,
3944
+ refundWithoutReceiverDelay: derived.contractParams.refundWithoutReceiverDelay,
3945
+ now: input.now,
3946
+ maxSeconds: input.policy?.maxRefundWindowSeconds
3947
+ });
3061
3948
  verifyQuoteTtl({
3062
3949
  quoteId: input.quoteId,
3063
3950
  expiresAt: parsed.validUntil,
@@ -3086,11 +3973,7 @@ var quoteLightningSend = async (input) => {
3086
3973
  card: input.candidate.card,
3087
3974
  rfqId,
3088
3975
  wire: parsed,
3089
- lockup: {
3090
- address: derived.address,
3091
- script: derived.script,
3092
- pkScript: derived.swapPkScript
3093
- },
3976
+ lockup: lockupOf(derived),
3094
3977
  contractParams: derived.contractParams,
3095
3978
  secrets,
3096
3979
  refundAddress: secrets.address,
@@ -3103,11 +3986,17 @@ var quoteLightningReceive = async (input) => {
3103
3986
  const pair = rfqPairFor(input.legs.give, input.legs.take);
3104
3987
  const rfqId = newRfqId();
3105
3988
  const secrets = await provisionClaimSecret(input.wallet);
3106
- const paymentHash = hex5.encode(secrets.paymentHash);
3989
+ const paymentHash = hex8.encode(secrets.paymentHash);
3107
3990
  const payoutAddress = await input.wallet.getAddress();
3108
3991
  const lightning = input.corridors.get("lightning").deps;
3109
3992
  const sealTo = sealingKey(lightning);
3110
- const claimPacket = sealTo ? await sealClaimPacket({ preimage: secrets.preimage, covclaimdPubkey: sealTo }) : void 0;
3993
+ const sealsAmount = pinned.on === "take" && input.legs.take.assetId === BTC_ASSET_ID;
3994
+ const binds = bindsClaimAmount();
3995
+ const claimPacket = sealTo !== void 0 && (!binds || sealsAmount) ? await sealClaimPacket({
3996
+ preimage: secrets.preimage,
3997
+ covclaimdPubkey: sealTo,
3998
+ minAmount: binds ? pinned.value : void 0
3999
+ }) : void 0;
3111
4000
  const wire = await input.transport.requestQuote(
3112
4001
  withCanonicalAmount(
3113
4002
  lightningReceiveRequest({
@@ -3115,10 +4004,8 @@ var quoteLightningReceive = async (input) => {
3115
4004
  paymentHash,
3116
4005
  payoutAddress,
3117
4006
  payoutPubkey: secrets.pubkey,
3118
- claimPacket: claimPacket?.ciphertext,
3119
- // Placeholder: the v1 builders type this field `number`, and the
3120
- // wire adapter re-encodes it as the canonical decimal string.
3121
- // Encoding it here as well would put the decision in two places.
4007
+ claimPacket: claimPacket?.packet,
4008
+ // Placeholder: `withCanonicalAmount` writes the canonical decimal string.
3122
4009
  amount: 0,
3123
4010
  amountSide: toRfqAmountSide(pinned.on)
3124
4011
  }),
@@ -3135,10 +4022,7 @@ var quoteLightningReceive = async (input) => {
3135
4022
  paymentHash,
3136
4023
  payoutPubkey: secrets.pubkey,
3137
4024
  payoutAddress,
3138
- operatorPubkey: covenant.operatorPubkey,
3139
- emulatorPubkey: covenant.emulatorPubkey,
3140
- claimDelay: covenant.claimDelay,
3141
- hrp: covenant.hrp
4025
+ ...covenant
3142
4026
  })
3143
4027
  );
3144
4028
  const { payDeadline } = verifyReceiveInvoiceFacts({
@@ -3156,9 +4040,7 @@ var quoteLightningReceive = async (input) => {
3156
4040
  });
3157
4041
  verifyQuoteTtl({
3158
4042
  quoteId: input.quoteId,
3159
- // The hold invoice's window is minutes where the quote's is an hour, so
3160
- // the deadline that binds this leg is the earlier of the two — which is
3161
- // what `payDeadline` already is.
4043
+ // The hold invoice's window (minutes) binds, not the quote's (an hour).
3162
4044
  expiresAt: payDeadline,
3163
4045
  now: input.now,
3164
4046
  floorSeconds: input.policy?.quoteTtlFloorSeconds
@@ -3196,11 +4078,7 @@ var quoteLightningReceive = async (input) => {
3196
4078
  card: input.candidate.card,
3197
4079
  rfqId,
3198
4080
  wire: parsed,
3199
- lockup: {
3200
- address: derived.address,
3201
- script: derived.script,
3202
- pkScript: derived.swapPkScript
3203
- },
4081
+ lockup: lockupOf(derived),
3204
4082
  contractParams: derived.contractParams,
3205
4083
  secrets,
3206
4084
  payoutAddress,
@@ -3227,7 +4105,7 @@ var quoteOnchainSend = async (input) => {
3227
4105
  const quoted = claimFee === void 0 ? pinned : { on: pinned.on, value: pinned.value + claimFee, source: pinned.source };
3228
4106
  const secrets = await provisionClaimSecret(input.wallet);
3229
4107
  const payoutKey = await provisionRefundKey(input.wallet);
3230
- const paymentHash = hex5.encode(secrets.paymentHash);
4108
+ const paymentHash = hex8.encode(secrets.paymentHash);
3231
4109
  const wire = await input.transport.requestQuote(
3232
4110
  withCanonicalAmount(
3233
4111
  onchainSendRequest({
@@ -3239,9 +4117,6 @@ var quoteOnchainSend = async (input) => {
3239
4117
  amount: 0,
3240
4118
  amountSide: toRfqAmountSide(pinned.on)
3241
4119
  }),
3242
- // The grossed pin, when one is active — see above. The solver's
3243
- // obligation is the HTLC amount; the recipient's own amount is
3244
- // that minus the claim's fee.
3245
4120
  quoted.value
3246
4121
  )
3247
4122
  );
@@ -3262,10 +4137,7 @@ var quoteOnchainSend = async (input) => {
3262
4137
  quote: wire,
3263
4138
  paymentHash,
3264
4139
  payoutPubkey: payoutKey.pubkey,
3265
- operatorPubkey: covenant.operatorPubkey,
3266
- emulatorPubkey: covenant.emulatorPubkey,
3267
- claimDelay: covenant.claimDelay,
3268
- hrp: covenant.hrp,
4140
+ ...covenant,
3269
4141
  l1Network,
3270
4142
  refundAddress: payoutKey.address,
3271
4143
  senderPubkey: secrets.pubkey
@@ -3281,14 +4153,20 @@ var quoteOnchainSend = async (input) => {
3281
4153
  direction: "send"
3282
4154
  }
3283
4155
  });
4156
+ verifyRefundWindow({
4157
+ refundLocktime: derived.refundLocktime,
4158
+ refundWithoutReceiverDelay: derived.refundWithoutReceiverDelay,
4159
+ now: input.now,
4160
+ maxSeconds: input.policy?.maxRefundWindowSeconds
4161
+ });
3284
4162
  verifyQuoteTtl({
3285
4163
  quoteId: input.quoteId,
3286
4164
  expiresAt: parsed.validUntil,
3287
4165
  now: input.now,
3288
4166
  floorSeconds: input.policy?.quoteTtlFloorSeconds
3289
4167
  });
3290
- const reportedTake = claimFee === void 0 ? parsed.take : parsed.take - claimFee;
3291
- const reportedFee = claimFee === void 0 ? parsed.give - parsed.take : parsed.give - parsed.take + claimFee;
4168
+ const reportedTake = parsed.take - (claimFee ?? 0n);
4169
+ const reportedFee = parsed.give - parsed.take + (claimFee ?? 0n);
3292
4170
  return {
3293
4171
  quote: {
3294
4172
  id: input.quoteId,
@@ -3302,9 +4180,7 @@ var quoteOnchainSend = async (input) => {
3302
4180
  market: input.market,
3303
4181
  solver: parsed.solver,
3304
4182
  expiresAt: parsed.validUntil,
3305
- // Read off the derivation and not off the wire: the field is
3306
- // optional there, a solver may carry it in the profile instead, and
3307
- // the derivation is what settles which one this covenant used.
4183
+ // Off the derivation, not the wire: it settles which locktime this covenant used.
3308
4184
  refundLocktime: derived.refundLocktime,
3309
4185
  fee: { amount: reportedFee, asset: input.endpoints.give.asset }
3310
4186
  },
@@ -3314,14 +4190,12 @@ var quoteOnchainSend = async (input) => {
3314
4190
  card: input.candidate.card,
3315
4191
  rfqId,
3316
4192
  wire: parsed,
3317
- lockup: {
3318
- address: derived.address,
3319
- script: derived.script,
3320
- pkScript: derived.swapPkScript
3321
- },
4193
+ lockup: lockupOf(derived),
3322
4194
  secrets,
3323
4195
  refundAddress: payoutKey.address,
3324
4196
  fundAmount: parsed.give,
4197
+ // Gross, not `reportedTake`: netting would accept an HTLC short by the fee.
4198
+ expectedAmount: parsed.take,
3325
4199
  payoutKey,
3326
4200
  payoutPkScript,
3327
4201
  htlc: derived.htlc,
@@ -3331,6 +4205,118 @@ var quoteOnchainSend = async (input) => {
3331
4205
  }
3332
4206
  };
3333
4207
  };
4208
+ var quoteOnchainReceive = async (input) => {
4209
+ const pinned = pinnedFor(input);
4210
+ const pair = rfqPairFor(input.legs.give, input.legs.take);
4211
+ const rfqId = newRfqId();
4212
+ const l1Network = l1NetworkFromArk(input.info.network);
4213
+ const secrets = await provisionClaimSecret(input.wallet);
4214
+ const refundKey = await provisionRefundKey(input.wallet);
4215
+ const paymentHash = hex8.encode(secrets.paymentHash);
4216
+ const payoutAddress = await input.wallet.getAddress();
4217
+ const refundPkScript = l1ScriptForAddress(await input.wallet.getBoardingAddress(), l1Network);
4218
+ const wire = await input.transport.requestQuote(
4219
+ withCanonicalAmount(
4220
+ onchainReceiveRequest({
4221
+ rfqId,
4222
+ paymentHash,
4223
+ payoutAddress,
4224
+ payoutPubkey: secrets.pubkey,
4225
+ refundPubkey: refundKey.pubkey,
4226
+ // Placeholder: `withCanonicalAmount` writes the canonical decimal string.
4227
+ amount: 0,
4228
+ amountSide: toRfqAmountSide(pinned.on)
4229
+ }),
4230
+ pinned.value
4231
+ )
4232
+ );
4233
+ verifyPair(wire.pair, pair);
4234
+ const parsed = parseRfqQuote(wire);
4235
+ verifyQuotedAmount({ pair, pinned, give: parsed.give, take: parsed.take });
4236
+ const covenant = covenantInputs(input);
4237
+ const derived = verifyingDerivation(
4238
+ () => deriveOnchainReceive({
4239
+ quote: wire,
4240
+ paymentHash,
4241
+ payoutPubkey: secrets.pubkey,
4242
+ payoutAddress,
4243
+ refundPubkey: refundKey.pubkey,
4244
+ ...covenant,
4245
+ l1Network
4246
+ })
4247
+ );
4248
+ verifySendWindow({
4249
+ quote: wire,
4250
+ quoteId: input.quoteId,
4251
+ now: input.now,
4252
+ onchain: {
4253
+ htlcLocktime: derived.htlcLocktime,
4254
+ minConfirmations: derived.minConfirmations,
4255
+ direction: "receive"
4256
+ }
4257
+ });
4258
+ verifyRefundWindow({
4259
+ refundLocktime: derived.htlcLocktime,
4260
+ now: input.now,
4261
+ maxSeconds: input.policy?.maxRefundWindowSeconds
4262
+ });
4263
+ verifyQuoteTtl({
4264
+ quoteId: input.quoteId,
4265
+ expiresAt: parsed.validUntil,
4266
+ now: input.now,
4267
+ floorSeconds: input.policy?.quoteTtlFloorSeconds
4268
+ });
4269
+ const artifact = {
4270
+ kind: "deposit",
4271
+ corridor: "onchain",
4272
+ address: derived.htlc.address,
4273
+ asset: input.endpoints.give.asset,
4274
+ amount: parsed.give,
4275
+ expiresAt: parsed.validUntil
4276
+ };
4277
+ return {
4278
+ quote: {
4279
+ id: input.quoteId,
4280
+ route: assembleRoute(
4281
+ {
4282
+ ...input.endpoints.give,
4283
+ instrument: {
4284
+ kind: "address",
4285
+ address: derived.htlc.address,
4286
+ amount: parsed.give
4287
+ }
4288
+ },
4289
+ { ...input.endpoints.take, instrument: { kind: "wallet" } }
4290
+ ),
4291
+ give: { asset: input.endpoints.give.asset, amount: parsed.give },
4292
+ take: { asset: input.endpoints.take.asset, amount: parsed.take },
4293
+ lock: { hash: paymentHash },
4294
+ market: input.market,
4295
+ solver: parsed.solver,
4296
+ expiresAt: parsed.validUntil,
4297
+ refundLocktime: derived.refundLocktime,
4298
+ artifact,
4299
+ fee: { amount: parsed.give - parsed.take, asset: input.endpoints.give.asset }
4300
+ },
4301
+ preparation: {
4302
+ backend: "rfq",
4303
+ route: "onchain->arkade",
4304
+ card: input.candidate.card,
4305
+ rfqId,
4306
+ wire: parsed,
4307
+ lockup: lockupOf(derived),
4308
+ secrets,
4309
+ payoutAddress,
4310
+ expectedAmount: parsed.take,
4311
+ refundKey,
4312
+ refundPkScript,
4313
+ htlc: derived.htlc,
4314
+ htlcParams: derived.htlcParams,
4315
+ l1Network,
4316
+ minConfirmations: derived.minConfirmations
4317
+ }
4318
+ };
4319
+ };
3334
4320
 
3335
4321
  // src/client/verbs.ts
3336
4322
  import { arkTarget as arkTarget2, resolveSendAmount as resolveSendAmount2 } from "@arkade-os/sdk";
@@ -3358,22 +4344,20 @@ var settle = async (deps, input, maxFee) => {
3358
4344
  return deps.accept(quote);
3359
4345
  };
3360
4346
  var pay = async (deps, destination, options = {}) => {
3361
- const arkade = arkTarget2(destination);
3362
- if (arkade !== void 0) {
4347
+ const arkade2 = arkTarget2(destination);
4348
+ if (arkade2 !== void 0) {
3363
4349
  const amount = resolveSendAmount2(
3364
4350
  "ark",
3365
4351
  destination,
3366
4352
  options.amount === void 0 ? void 0 : satsOf(options.amount, "amount")
3367
4353
  );
3368
- return { kind: "payment", txid: await deps.wallet.send({ address: arkade, amount }) };
4354
+ return { kind: "payment", txid: await deps.wallet.send({ address: arkade2, amount }) };
3369
4355
  }
3370
4356
  const swap = await settle(
3371
4357
  deps,
3372
4358
  {
3373
4359
  to: destination,
3374
- // `amountOn: "take"` because the number a caller writes beside a
3375
- // destination is what the recipient gets. An invoice pins the same
3376
- // leg by existing, which is why passing both is `AmountMismatch`.
4360
+ // The amount beside a destination is what the recipient gets.
3377
4361
  ...options.amount === void 0 ? {} : { amount: options.amount, amountOn: "take" }
3378
4362
  },
3379
4363
  options.maxFee
@@ -3387,8 +4371,7 @@ var receive = async (deps, options) => {
3387
4371
  via: options.via,
3388
4372
  ...options.asset === void 0 ? {} : { take: options.asset },
3389
4373
  amount: options.amount,
3390
- // The trader's side is the take leg: `receive({ amount })` is
3391
- // "credit me this much", not "let the payer send this much".
4374
+ // "Credit me this much", not "let the payer send this much".
3392
4375
  amountOn: "take"
3393
4376
  },
3394
4377
  options.maxFee
@@ -3413,21 +4396,26 @@ var exchange = async (deps, options) => settle(
3413
4396
 
3414
4397
  // src/client/transport.ts
3415
4398
  var attesting = (transport, responder) => Object.assign(transport, { attestedResponder: responder });
3416
- var nostrTransportFactory = async (rendezvous) => {
3417
- const { nostrRfqTransport } = await import("./nostr.js");
3418
- return attesting(
3419
- nostrRfqTransport({
3420
- relays: [...rendezvous.relays],
3421
- solverPubkey: rendezvous.solverPubkey
3422
- }),
3423
- rendezvous.solverPubkey
3424
- );
4399
+ var createNostrTransportFactory = (pool) => {
4400
+ return async (rendezvous) => {
4401
+ const { nostrRfqTransport } = await import("./nostr.js");
4402
+ return attesting(
4403
+ nostrRfqTransport({
4404
+ relays: [...rendezvous.relays],
4405
+ solverPubkey: rendezvous.solverPubkey,
4406
+ ...pool === void 0 ? {} : { pool }
4407
+ }),
4408
+ rendezvous.solverPubkey
4409
+ );
4410
+ };
3425
4411
  };
4412
+ var nostrTransportFactory = createNostrTransportFactory();
3426
4413
 
3427
4414
  // src/client/client.ts
3428
- import { hex as hex6 } from "@scure/base";
4415
+ import { hex as hex9 } from "@scure/base";
4416
+ import { captureSendDeadline } from "@arkade-os/sdk";
3429
4417
  var PREPARATIONS_HELD = 64;
3430
- var mintQuoteId = () => hex6.encode(crypto.getRandomValues(new Uint8Array(16)));
4418
+ var mintQuoteId = () => hex9.encode(crypto.getRandomValues(new Uint8Array(16)));
3431
4419
  var createSwapClient = (config) => {
3432
4420
  const { wallet } = config;
3433
4421
  const operator = config.operator ?? walletOperator(wallet);
@@ -3444,6 +4432,7 @@ var createSwapClient = (config) => {
3444
4432
  operator,
3445
4433
  ...config.repository === void 0 ? {} : { repository: config.repository },
3446
4434
  corridors: async () => (await resolved()).corridors,
4435
+ network: async () => (await resolved()).base.networkName,
3447
4436
  ...config.policy?.drive === void 0 ? {} : { mode: config.policy.drive },
3448
4437
  indexer
3449
4438
  });
@@ -3481,10 +4470,8 @@ var createSwapClient = (config) => {
3481
4470
  };
3482
4471
  const remember = (id, preparation) => {
3483
4472
  preparations.set(id, preparation);
3484
- while (preparations.size > PREPARATIONS_HELD) {
3485
- const oldest = preparations.keys().next();
3486
- if (oldest.done) break;
3487
- preparations.delete(oldest.value);
4473
+ if (preparations.size > PREPARATIONS_HELD) {
4474
+ preparations.delete(preparations.keys().next().value);
3488
4475
  }
3489
4476
  };
3490
4477
  const client = {
@@ -3493,6 +4480,7 @@ var createSwapClient = (config) => {
3493
4480
  return (await route(input, "resolve")).resolution;
3494
4481
  },
3495
4482
  quote: async (input) => {
4483
+ const assetPayment = captureAssetPayment(input.assetPayment);
3496
4484
  ensureLive("quote");
3497
4485
  const { corridors, discovery } = await resolved();
3498
4486
  let resolvedRoute = await route(input, "quote");
@@ -3518,7 +4506,9 @@ var createSwapClient = (config) => {
3518
4506
  corridors.get(resolvedRoute.legs.take.corridor);
3519
4507
  const quoteId = mintQuoteId();
3520
4508
  const now = Math.floor(Date.now() / 1e3);
3521
- if (resolvedRoute.pair === "arkade->arkade") {
4509
+ if (market.backend === "feed") {
4510
+ if (assetPayment !== void 0)
4511
+ throw new Error("assetPayment needs a negotiated BTC-to-asset market");
3522
4512
  const { quote, preparation } = await quoteFromFeed({
3523
4513
  quoteId,
3524
4514
  candidate: market,
@@ -3547,6 +4537,7 @@ var createSwapClient = (config) => {
3547
4537
  const { quote, preparation } = await quoteViaRfq({
3548
4538
  quoteId,
3549
4539
  route: resolvedRoute.pair,
4540
+ ...assetPayment === void 0 ? {} : { assetPayment },
3550
4541
  candidate: market,
3551
4542
  market: marketRef,
3552
4543
  legs: resolvedRoute.legs,
@@ -3556,6 +4547,7 @@ var createSwapClient = (config) => {
3556
4547
  info,
3557
4548
  corridors,
3558
4549
  transport,
4550
+ feed,
3559
4551
  ...config.policy === void 0 ? {} : { policy: config.policy },
3560
4552
  now
3561
4553
  });
@@ -3566,7 +4558,8 @@ var createSwapClient = (config) => {
3566
4558
  });
3567
4559
  }
3568
4560
  },
3569
- accept: async (quote) => {
4561
+ accept: async (quote, options) => {
4562
+ const validUntil = captureSendDeadline(options?.validUntil);
3570
4563
  ensureLive("accept");
3571
4564
  const { corridors } = await resolved();
3572
4565
  const drive2 = driving();
@@ -3574,6 +4567,7 @@ var createSwapClient = (config) => {
3574
4567
  const preparation = preparations.get(quote.id);
3575
4568
  return acceptQuote({
3576
4569
  quote,
4570
+ ...validUntil === void 0 ? {} : { validUntil },
3577
4571
  ...preparation === void 0 ? {} : { preparation },
3578
4572
  wallet,
3579
4573
  repository: config.repository,
@@ -3603,7 +4597,7 @@ var createSwapClient = (config) => {
3603
4597
  if (repository === void 0) return [];
3604
4598
  const drive2 = driving();
3605
4599
  await drive2.ready;
3606
- const records = await repository.getAllSwapRecords();
4600
+ const records = await collectSwapRecords(repository);
3607
4601
  const swaps = [];
3608
4602
  for (const record of records) {
3609
4603
  if (!readableRecord(record)) continue;
@@ -3643,9 +4637,7 @@ var createSwapClient = (config) => {
3643
4637
  ensureLive("ready");
3644
4638
  return driving().ready;
3645
4639
  },
3646
- // `async`, so the refusal is a rejection rather than a synchronous
3647
- // throw: these are declared `Promise<void>` and a caller is entitled to
3648
- // `.catch()` them.
4640
+ // `async` so the refusal is a rejection, as the `Promise<void>` signature promises
3649
4641
  start: async () => {
3650
4642
  ensureLive("start");
3651
4643
  return driving().start();
@@ -3677,6 +4669,149 @@ var createSwapClient = (config) => {
3677
4669
  return client;
3678
4670
  };
3679
4671
 
4672
+ // src/offerFillPlan.ts
4673
+ import { base64 as base643, hex as hex10 } from "@scure/base";
4674
+ import { ArkAddress as ArkAddress7, Extension, P2A } from "@arkade-os/sdk";
4675
+ var OFFER_FILL_TEMPLATE = "offer-fill/1";
4676
+ var OFFER_FILL_OWNERS = [null, "solver", "sponsor"];
4677
+ async function buildOfferFillPlan(wallet, arkServerUrl, offerHex, opts) {
4678
+ const {
4679
+ fund: fund2,
4680
+ payoutScript,
4681
+ fundingTxid,
4682
+ fundingOutpoint,
4683
+ swapAddress,
4684
+ assetCarrierSats = ASSET_CARRIER_SATS,
4685
+ sponsor
4686
+ } = opts;
4687
+ const offer = decodeOffer(hex10.decode(offerHex));
4688
+ const contract = await connectFillContract(wallet, arkServerUrl, offer, { swapAddress });
4689
+ const vtxos = await contract.getUtxos();
4690
+ const vtxo = resolveDeposit(vtxos, { fundingTxid, fundingOutpoint });
4691
+ const solverPayout = payoutScript ?? ArkAddress7.decode(await wallet.getAddress()).pkScript;
4692
+ const sponsorLeg = sponsor !== void 0 ? normalizeSponsor(sponsor, assetCarrierSats) : void 0;
4693
+ const fill = contract.functions.fulfill();
4694
+ const layout = assembleOfferFill(fill, {
4695
+ offer,
4696
+ vtxo,
4697
+ solverFund: fund2,
4698
+ solverPayout,
4699
+ assetCarrierSats,
4700
+ sponsor: sponsorLeg
4701
+ });
4702
+ const { arkTx, checkpoints } = await fill.build();
4703
+ for (const [i, input] of layout.inputs.entries()) {
4704
+ if (!OFFER_FILL_OWNERS.includes(input.owner)) {
4705
+ throw new Error(`fill plan input ${i} names unknown owner ${input.owner}`);
4706
+ }
4707
+ }
4708
+ return toJointGraph(arkTx, checkpoints, layout, offer.wantAsset?.toString());
4709
+ }
4710
+ function normalizeSponsor(sponsor, assetCarrierSats) {
4711
+ return {
4712
+ fund: sponsor.fund,
4713
+ netContributionSats: sponsor.netContributionSats,
4714
+ fare: sponsor.fare !== void 0 ? {
4715
+ ...sponsor.fare.assetId !== void 0 ? { assetId: sponsor.fare.assetId, amount: sponsor.fare.amount } : {},
4716
+ script: sponsor.fare.script,
4717
+ sats: sponsor.fare.sats ?? assetCarrierSats
4718
+ } : void 0,
4719
+ changeScript: sponsor.changeScript,
4720
+ combineSatsFareWithChange: sponsor.combineSatsFareWithChange
4721
+ };
4722
+ }
4723
+ function toJointGraph(arkTx, checkpoints, layout, wantedAssetId) {
4724
+ if (arkTx.inputsLength !== layout.inputs.length) {
4725
+ throw new Error(
4726
+ `fill plan built ${arkTx.inputsLength} inputs, expected ${layout.inputs.length}`
4727
+ );
4728
+ }
4729
+ if (checkpoints.length !== layout.inputs.length) {
4730
+ throw new Error(
4731
+ `fill plan built ${checkpoints.length} checkpoints, expected ${layout.inputs.length}`
4732
+ );
4733
+ }
4734
+ layout.inputs.forEach((input, i) => {
4735
+ const spent = checkpoints[i].getInput(0);
4736
+ if (!(spent.txid instanceof Uint8Array) || hex10.encode(spent.txid) !== input.txid || spent.index !== input.vout) {
4737
+ throw new Error(`fill plan checkpoint ${i} does not spend ${input.txid}:${input.vout}`);
4738
+ }
4739
+ });
4740
+ const payments = layout.outputs.length;
4741
+ if (arkTx.outputsLength !== payments + 2) {
4742
+ throw new Error(
4743
+ `fill plan built ${arkTx.outputsLength} outputs, expected ${payments} payments plus extension and anchor`
4744
+ );
4745
+ }
4746
+ layout.outputs.forEach((expected, i) => {
4747
+ const out = arkTx.getOutput(i);
4748
+ if (!out?.script || hex10.encode(out.script) !== hex10.encode(expected.script)) {
4749
+ throw new Error(`fill plan output ${i} is not the ${expected.role} script`);
4750
+ }
4751
+ if (out.amount !== expected.sats) {
4752
+ throw new Error(
4753
+ `fill plan output ${i} carries ${out.amount}, expected ${expected.sats}`
4754
+ );
4755
+ }
4756
+ });
4757
+ const ext = arkTx.getOutput(payments);
4758
+ if (!ext?.script || !Extension.isExtension(ext.script)) {
4759
+ throw new Error(`fill plan output ${payments} is not the extension packet`);
4760
+ }
4761
+ const anchor = arkTx.getOutput(payments + 1);
4762
+ if (!anchor?.script || hex10.encode(anchor.script) !== hex10.encode(P2A.script) || anchor.amount !== P2A.amount) {
4763
+ throw new Error(`fill plan output ${payments + 1} is not the anchor`);
4764
+ }
4765
+ const packet = Extension.fromTx(arkTx).getAssetPacket();
4766
+ for (const group of packet?.groups ?? []) {
4767
+ if (group.assetId === null) throw new Error("fill plan carries an issuance group");
4768
+ const assetId = group.assetId.toString();
4769
+ const unitsIn = group.inputs.reduce((s, input) => s + input.amount, BigInt(0));
4770
+ const unitsOut = group.outputs.reduce((s, output) => s + output.amount, BigInt(0));
4771
+ if (unitsIn !== unitsOut) {
4772
+ throw new Error(`fill plan asset ${assetId} mints ${unitsOut - unitsIn} units`);
4773
+ }
4774
+ for (const output of group.outputs) {
4775
+ const hosted = arkTx.getOutput(output.vout);
4776
+ if (output.vout >= payments || !hosted?.script || Extension.isExtension(hosted.script)) {
4777
+ throw new Error(
4778
+ `fill plan asset ${assetId} pays nonexistent output ${output.vout}`
4779
+ );
4780
+ }
4781
+ }
4782
+ }
4783
+ if (wantedAssetId !== void 0) {
4784
+ if ((packet?.groups.length ?? 0) === 0) {
4785
+ throw new Error(`fill plan carries no asset group, expected ${wantedAssetId}`);
4786
+ }
4787
+ const first = packet?.groups[0].assetId?.toString();
4788
+ if (first !== wantedAssetId) {
4789
+ throw new Error(
4790
+ `fill plan asset group 0 is ${first}, expected the wanted ${wantedAssetId}`
4791
+ );
4792
+ }
4793
+ }
4794
+ const arkTxPsbt = base643.encode(arkTx.toPSBT());
4795
+ const checkpointPsbts = checkpoints.map((c) => base643.encode(c.toPSBT()));
4796
+ const inputOwners = layout.inputs.map((input) => input.owner);
4797
+ const graph = {
4798
+ arkTx: arkTxPsbt,
4799
+ checkpoints: checkpointPsbts,
4800
+ graphId: digestJointGraph(
4801
+ { arkTx: arkTxPsbt, checkpoints: checkpointPsbts, inputOwners },
4802
+ OFFER_FILL_TEMPLATE
4803
+ ),
4804
+ inputOwners
4805
+ };
4806
+ return deepFreeze(graph);
4807
+ }
4808
+ function verifyOfferFillPlan(plan) {
4809
+ if (!plan || typeof plan !== "object" || !Array.isArray(plan.inputOwners)) return false;
4810
+ const allowed = OFFER_FILL_OWNERS;
4811
+ if (!plan.inputOwners.every((owner) => allowed.includes(owner))) return false;
4812
+ return verifyJointGraph(plan, OFFER_FILL_TEMPLATE);
4813
+ }
4814
+
3680
4815
  export {
3681
4816
  RAILS,
3682
4817
  BITCOIN_RAILS,
@@ -3691,7 +4826,10 @@ export {
3691
4826
  bitcoinNetworkOf,
3692
4827
  assetPartOf,
3693
4828
  sameAsset,
4829
+ btcAssetPart,
3694
4830
  btcOn,
4831
+ isBtcAsset,
4832
+ isBtcAssetLenient,
3695
4833
  arkadeAsset,
3696
4834
  issuanceOf,
3697
4835
  AmbiguousDestination,
@@ -3715,30 +4853,11 @@ export {
3715
4853
  INDEXED_NETWORKS,
3716
4854
  isIndexedNetwork,
3717
4855
  canonicalAssetId,
3718
- AmountFormatError,
3719
- Amount,
3720
- toAtomicDecimal,
3721
- fromAtomicDecimal,
3722
- isAtomicDecimal,
3723
4856
  toRfqAmountSide,
3724
4857
  fromRfqAmountSide,
3725
4858
  encodeRfqAmount,
3726
4859
  decodeRfqAmount,
3727
4860
  toSafeNumber,
3728
- assetSwapIdOf,
3729
- OFFER_SWAP_ID_PREFIX,
3730
- RFQ_SWAP_ID_PREFIX,
3731
- familyOfSwapId,
3732
- quoteIdOfSwapId,
3733
- recordEndpoint,
3734
- recordInstrument,
3735
- instrumentOf,
3736
- recordArtifact,
3737
- artifactOf,
3738
- recordLeg,
3739
- legOf,
3740
- swapOf,
3741
- fundsFromWallet,
3742
4861
  conflictingFields,
3743
4862
  acceptQuote,
3744
4863
  swapRecordOf,
@@ -3766,11 +4885,15 @@ export {
3766
4885
  splitRecords,
3767
4886
  rfqRecordOf,
3768
4887
  withRfqState,
4888
+ pageRfqRecords,
3769
4889
  corridorRecordStore,
3770
4890
  offerFactsOf,
3771
4891
  offerRecordSource,
3772
4892
  applyOfferSpend,
3773
- withOfferStatus,
4893
+ withDepositFate,
4894
+ fateMoved,
4895
+ restoredOfferRecord,
4896
+ restoredCorridorRecord,
3774
4897
  walletLockupIndexer,
3775
4898
  cancelSwap,
3776
4899
  SwapDriveRefusedError,
@@ -3787,6 +4910,7 @@ export {
3787
4910
  isCardMarket,
3788
4911
  assembleRoute,
3789
4912
  resolveRoute,
4913
+ DEFAULT_MAX_REFUND_WINDOW_SECONDS,
3790
4914
  verifyResponder,
3791
4915
  verifyPair,
3792
4916
  verifyingDerivation,
@@ -3795,10 +4919,19 @@ export {
3795
4919
  verifySendInvoice,
3796
4920
  verifyReceiveInvoiceFacts,
3797
4921
  verifyQuoteTtl,
4922
+ verifyRefundWindow,
3798
4923
  verifyQuotedAmount,
4924
+ verifyCrossAssetAmount,
4925
+ verifiedCarrierSats,
3799
4926
  FEED_TTL_MS,
3800
4927
  feedFetch,
3801
4928
  quoteFromFeed,
4929
+ feedSpread,
4930
+ verifyPlanLegs,
4931
+ digestJointGraph,
4932
+ verifyJointGraph,
4933
+ deepFreeze,
4934
+ unsignedPsbtBytes,
3802
4935
  satsOf,
3803
4936
  PAYMENT_STATUS,
3804
4937
  paymentStatusOf,
@@ -3806,6 +4939,7 @@ export {
3806
4939
  SwapPaymentFailedError,
3807
4940
  railAvailable,
3808
4941
  receiverExact,
4942
+ quoteMeta,
3809
4943
  swapHandle,
3810
4944
  ONCHAIN_SWAP_RAIL,
3811
4945
  claimFeeSats,
@@ -3820,6 +4954,11 @@ export {
3820
4954
  receive,
3821
4955
  exchange,
3822
4956
  attesting,
4957
+ createNostrTransportFactory,
3823
4958
  nostrTransportFactory,
3824
- createSwapClient
4959
+ createSwapClient,
4960
+ OFFER_FILL_TEMPLATE,
4961
+ OFFER_FILL_OWNERS,
4962
+ buildOfferFillPlan,
4963
+ verifyOfferFillPlan
3825
4964
  };