@arkade-os/swap 0.1.0-rc.9 → 0.1.1

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 (57) hide show
  1. package/README.md +261 -252
  2. package/dist/advanced.cjs +6613 -3224
  3. package/dist/advanced.d.cts +328 -283
  4. package/dist/advanced.d.ts +328 -283
  5. package/dist/advanced.js +347 -34
  6. package/dist/chunk-A3SHHRX4.js +104 -0
  7. package/dist/chunk-FMRAV77W.js +3065 -0
  8. package/dist/chunk-T4FHBWZI.js +3459 -0
  9. package/dist/{chunk-NS3K6BZG.js → chunk-YHESEL4I.js} +1792 -636
  10. package/dist/index.cjs +6901 -3901
  11. package/dist/index.d.cts +71 -243
  12. package/dist/index.d.ts +71 -243
  13. package/dist/index.js +131 -167
  14. package/dist/lockupContract-CIXkJPxV.d.ts +148 -0
  15. package/dist/lockupContract-CkhWMKCo.d.cts +148 -0
  16. package/dist/node/index.cjs +61 -10
  17. package/dist/node/index.d.cts +307 -635
  18. package/dist/node/index.d.ts +307 -635
  19. package/dist/node/index.js +65 -10
  20. package/dist/nostr.cjs +427 -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-BPD2ortO.d.ts +269 -0
  25. package/dist/offer-Diff5Flc.d.cts +269 -0
  26. package/dist/offerFillPlan-B-5ae_gQ.d.cts +1671 -0
  27. package/dist/offerFillPlan-CJzneX6F.d.ts +1671 -0
  28. package/dist/protocol.cjs +5717 -4275
  29. package/dist/protocol.d.cts +258 -328
  30. package/dist/protocol.d.ts +258 -328
  31. package/dist/protocol.js +200 -224
  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-BBVRh9ez.d.ts +2357 -0
  41. package/dist/repository-C4pvymhs.d.cts +2357 -0
  42. package/dist/{rfq-BO6o7NwS.d.ts → rfq-C0tHOvn6.d.cts} +323 -444
  43. package/dist/{rfq-BO6o7NwS.d.cts → rfq-C0tHOvn6.d.ts} +323 -444
  44. package/dist/watch-7BiRa4oB.d.ts +74 -0
  45. package/dist/watch-Bxq-lx_6.d.cts +74 -0
  46. package/package.json +10 -10
  47. package/dist/chunk-JFKGMPMH.js +0 -3456
  48. package/dist/chunk-LLG7RD2T.js +0 -1499
  49. package/dist/chunk-U7VWWTL6.js +0 -66
  50. package/dist/errors-CNISbN0M.d.ts +0 -2218
  51. package/dist/errors-DwNhIP0N.d.cts +0 -2218
  52. package/dist/lockupContract-C8-Mcg69.d.ts +0 -664
  53. package/dist/lockupContract-mIt4syse.d.cts +0 -664
  54. package/dist/repository-CGPLbjBe.d.ts +0 -3489
  55. package/dist/repository-DSGGq0ct.d.cts +0 -3489
  56. package/dist/watch-DWyVqyEN.d.cts +0 -96
  57. package/dist/watch-DmvHNX6T.d.ts +0 -96
@@ -1,65 +1,98 @@
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,
24
+ isRecheckableRefundedSend,
19
25
  isRfqConfigurationRefusal,
26
+ isRfqSwapRestorable,
20
27
  isRfqSwapTerminal,
21
28
  lightningCorridor,
22
29
  makeCachedFeedFetch,
23
30
  marketAssetId,
24
31
  marketCorridor,
25
32
  marketPairLabel,
33
+ normalizeRfqSwapRecord,
26
34
  offerOutcome,
27
35
  onchainCorridor,
36
+ onchainReceiveProfile,
28
37
  onchainSendProfile,
29
- preimageForSwapRecord,
30
- prepareOfferCancel,
38
+ parseCarrierEcho,
39
+ parseTopLevelCarrierSats,
31
40
  pushClaim,
41
+ quoteIdOfSwapId,
32
42
  readsChain,
33
43
  rebuildRfqSwap,
44
+ recordArtifact,
45
+ recordAssetPayment,
46
+ recordEndpoint,
47
+ recordLeg,
34
48
  recordOutcome,
49
+ registryAnswered,
35
50
  restoreAssetSwaps,
36
- retireOfferContract,
37
- retireSettledOfferContracts,
38
- rfqClaimDestinationOf,
39
- rfqClaimSecretOf,
40
- rfqSecretsProfile,
41
- rfqSignerOf,
42
51
  rfqSwapOriginOf,
43
52
  senderIdentityForSwapRecord,
44
53
  spendTxidsOf,
54
+ storedFundingBounds,
55
+ swapOf,
56
+ toAtomicDecimal,
57
+ toRestoreTx,
58
+ trackDelivery,
59
+ transportCardsOf,
60
+ undeliveredCarry,
45
61
  walletOperator,
46
62
  watchOfferSwaps
47
- } from "./chunk-JFKGMPMH.js";
63
+ } from "./chunk-T4FHBWZI.js";
48
64
  import {
49
65
  ARKADE_BTC,
66
+ ASSET_CARRIER_SATS,
50
67
  AddressMismatch,
68
+ BTC_ASSET_ID,
51
69
  L1_NETWORKS,
52
70
  LIGHTNING_BTC,
71
+ LockupContractMissing,
72
+ NoSpendableDepositError,
73
+ OFFER_CONTRACT_KIND,
74
+ OFFER_PACKET_TYPE,
53
75
  ONCHAIN_BTC,
54
76
  ONCHAIN_CLAIM_VSIZE,
55
77
  ONCHAIN_DUST_SATS,
78
+ OfferCovenantMismatchError,
79
+ RETIRABLE,
56
80
  SwapRefusal,
81
+ arkadeSwapRequest,
82
+ assembleOfferFill,
57
83
  assertFundable,
58
84
  assertPairLength,
59
85
  assertReceivable,
86
+ bindsClaimAmount,
87
+ buildHtlcRefund,
60
88
  claimOnchainFill,
89
+ connectFillContract,
90
+ createOffer,
91
+ decodeOffer,
61
92
  deriveLightningReceive,
62
93
  deriveLightningSend,
94
+ deriveOffer,
95
+ deriveOnchainReceive,
63
96
  deriveOnchainSend,
64
97
  l1NetworkFromArk,
65
98
  l1ScriptForAddress,
@@ -67,12 +100,38 @@ import {
67
100
  lightningSendRequest,
68
101
  lockupContractParams,
69
102
  newRfqId,
103
+ nextClaimFeeRate,
104
+ offerTermsFromQuote,
105
+ onchainReceiveRequest,
70
106
  onchainSendRequest,
107
+ preimageForSwapRecord,
108
+ prepareOfferCancel,
109
+ promoteOfferContract,
110
+ quoteCarrierSats,
111
+ registerDerivedOffer,
71
112
  registerLockupContract,
113
+ resolveDeposit,
114
+ resolveReceivePkScript,
115
+ restoreOfferCoverage,
116
+ retireOfferContract,
117
+ retireSettledOfferContracts,
118
+ rfqClaimDestinationOf,
119
+ rfqClaimSecretOf,
72
120
  rfqPair,
121
+ rfqSecretsProfile,
122
+ rfqSignerOf,
73
123
  sealClaimPacket,
74
- unilateralClaimDelay
75
- } from "./chunk-LLG7RD2T.js";
124
+ swapPrograms,
125
+ unilateralClaimDelay,
126
+ verifyOfferAddress,
127
+ withExitClosure
128
+ } from "./chunk-FMRAV77W.js";
129
+ import {
130
+ assertRfqSwapPageFilter,
131
+ collectAssetSwaps,
132
+ collectRfqSwaps,
133
+ collectSwapRecords
134
+ } from "./chunk-A3SHHRX4.js";
76
135
 
77
136
  // src/client/assetId.ts
78
137
  import { asset, networks } from "@arkade-os/sdk";
@@ -95,10 +154,8 @@ var REFERENCE_RULE = {
95
154
  /** The 68-lowercase-hex identity form; `asset.AssetId` then re-validates it. */
96
155
  asset: /^[0-9a-f]{68}$/,
97
156
  /**
98
- * Reserved for §9. Lowercase, never EIP-55: a checksum belongs on an
99
- * address a human types, and an id here comes out of the alias table or a
100
- * market card. Mixed case would be two spellings of one asset comparing
101
- * unequal in a pair string, a record and a cache key.
157
+ * Reserved for §9. Lowercase, never EIP-55: mixed case would be two spellings of one asset
158
+ * comparing unequal in a pair string, a record and a cache key.
102
159
  */
103
160
  erc20: /^0x[0-9a-f]{40}$/
104
161
  };
@@ -210,11 +267,20 @@ var sameAsset = (a, b) => {
210
267
  const right = parseAssetId(b);
211
268
  return left.reference === right.reference && left.assetNamespace === right.assetNamespace && left.assetReference === right.assetReference;
212
269
  };
270
+ var btcAssetPart = (network) => network === "bitcoin" ? "slip44:0" : "slip44:1";
213
271
  var btcOn = (rail, network) => (
214
- // The checker will not resolve the conditional against an unbound `R`; the
215
- // assertion is confined to this expression and never reaches a call site.
216
- `${rail}:${network}/${BTC_ASSET_PART}`
272
+ // TS won't resolve the conditional against an unbound `R`; the cast stays in this expression.
273
+ `${rail}:${network}/${btcAssetPart(network)}`
217
274
  );
275
+ var isBtcAsset = (id) => {
276
+ const { rail, reference, assetNamespace, assetReference } = parseAssetId(id);
277
+ return rail !== "eip155" && `${assetNamespace}:${assetReference}` === btcAssetPart(reference);
278
+ };
279
+ var isBtcAssetLenient = (id) => {
280
+ if (isBtcAsset(id)) return true;
281
+ const { rail, assetNamespace, assetReference } = parseAssetId(id);
282
+ return rail !== "eip155" && assetNamespace === "slip44" && assetReference === "0";
283
+ };
218
284
  var arkadeAsset = (network, id) => `arkade:${network}/${ARKADE_ASSET_NAMESPACE}:${id.toString()}`;
219
285
  var issuanceOf = (id) => {
220
286
  const { assetNamespace, assetReference } = parseAssetId(id);
@@ -291,10 +357,10 @@ var QuoteExpired = class extends Error {
291
357
  name = "QuoteExpired";
292
358
  };
293
359
  var MaxFeeExceeded = class extends Error {
294
- constructor(quoteId, asset3, fee, maxFee) {
295
- super(`fee ${fee} of ${asset3} exceeds the ${maxFee} ceiling`);
360
+ constructor(quoteId, asset5, fee, maxFee) {
361
+ super(`fee ${fee} of ${asset5} exceeds the ${maxFee} ceiling`);
296
362
  this.quoteId = quoteId;
297
- this.asset = asset3;
363
+ this.asset = asset5;
298
364
  this.fee = fee;
299
365
  this.maxFee = maxFee;
300
366
  }
@@ -305,11 +371,11 @@ var MaxFeeExceeded = class extends Error {
305
371
  name = "MaxFeeExceeded";
306
372
  };
307
373
  var InsufficientFunds = class extends Error {
308
- constructor(asset3, required, available) {
374
+ constructor(asset5, required, available) {
309
375
  super(
310
- `funding needs ${required} of ${asset3}` + (available === void 0 ? "" : `, wallet holds ${available}`)
376
+ `funding needs ${required} of ${asset5}` + (available === void 0 ? "" : `, wallet holds ${available}`)
311
377
  );
312
- this.asset = asset3;
378
+ this.asset = asset5;
313
379
  this.required = required;
314
380
  this.available = available;
315
381
  }
@@ -347,9 +413,9 @@ var NotCancellable = class extends Error {
347
413
  name = "NotCancellable";
348
414
  };
349
415
  var InconsistentRoute = class extends Error {
350
- constructor(asset3, destination) {
351
- super(`destination ${JSON.stringify(destination)} is not on ${asset3}'s chain`);
352
- this.asset = asset3;
416
+ constructor(asset5, destination) {
417
+ super(`destination ${JSON.stringify(destination)} is not on ${asset5}'s chain`);
418
+ this.asset = asset5;
353
419
  this.destination = destination;
354
420
  }
355
421
  asset;
@@ -402,25 +468,27 @@ function isSwapError(e, name) {
402
468
  // src/client/aliases.ts
403
469
  import { NETWORKS, isNetwork } from "@arkade-os/solver-discovery";
404
470
  var toDiscoveryLeg = (id) => {
405
- const { rail, assetNamespace, assetReference } = parseAssetId(id);
406
- const asset3 = `${assetNamespace}:${assetReference}`;
471
+ const { rail, reference, assetNamespace, assetReference } = parseAssetId(id);
472
+ const asset5 = `${assetNamespace}:${assetReference}`;
473
+ const isBtc = isBtcAsset(id);
474
+ if (!isBtc && rail !== "eip155" && (asset5 === "slip44:0" || asset5 === "slip44:1")) {
475
+ const expected = btcOn(rail, reference);
476
+ throw new UnsupportedRoute(`${id} is not BTC on ${reference}: BTC there is ${expected}`);
477
+ }
407
478
  if (rail === "arkade") {
408
- if (asset3 === BTC_ASSET_PART)
409
- return { corridor: "arkade", assetId: BTC_ASSET_ID, marketId: id };
479
+ if (isBtc) return { corridor: "arkade", assetId: BTC_ASSET_ID, marketId: id };
410
480
  if (assetNamespace === ARKADE_ASSET_NAMESPACE) {
411
481
  return { corridor: "arkade", assetId: assetReference, marketId: id };
412
482
  }
413
- throw new UnsupportedRoute(`the arkade corridor has no ${asset3}`);
483
+ throw new UnsupportedRoute(`the arkade corridor has no ${asset5}`);
414
484
  }
415
485
  if (rail === "bolt11") {
416
- if (asset3 === BTC_ASSET_PART)
417
- return { corridor: "lightning", assetId: BTC_ASSET_ID, marketId: id };
418
- throw new UnsupportedRoute(`the lightning corridor carries BTC only, not ${asset3}`);
486
+ if (isBtc) return { corridor: "lightning", assetId: BTC_ASSET_ID, marketId: id };
487
+ throw new UnsupportedRoute(`the lightning corridor carries BTC only, not ${asset5}`);
419
488
  }
420
489
  if (rail === "bitcoin") {
421
- if (asset3 === BTC_ASSET_PART)
422
- return { corridor: "onchain", assetId: BTC_ASSET_ID, marketId: id };
423
- throw new UnsupportedRoute(`the onchain corridor carries BTC only, not ${asset3}`);
490
+ if (isBtc) return { corridor: "onchain", assetId: BTC_ASSET_ID, marketId: id };
491
+ throw new UnsupportedRoute(`the onchain corridor carries BTC only, not ${asset5}`);
424
492
  }
425
493
  throw new UnsupportedRoute(`no corridor serves ${id}`);
426
494
  };
@@ -451,115 +519,8 @@ var canonicalAssetId = (input, table) => {
451
519
  return matches[0].id;
452
520
  };
453
521
 
454
- // src/client/amount.ts
455
- import {
456
- AMOUNT_PATTERN,
457
- MAX_ASSET_DECIMALS,
458
- fromAtomic,
459
- isAmount,
460
- toAtomic
461
- } from "@arkade-os/solver-discovery";
462
- var AmountFormatError = class extends Error {
463
- constructor(reason, message) {
464
- super(message);
465
- this.reason = reason;
466
- }
467
- reason;
468
- name = "AmountFormatError";
469
- };
470
- var SCALED_DECIMAL = /^([0-9]+)(?:\.([0-9]+))?$/;
471
- var ATOMIC_CEILING = 10n ** 30n;
472
- var MAX_SIGNIFICANT_DIGITS = 64;
473
- var assertDecimals = (decimals) => {
474
- if (!Number.isInteger(decimals) || decimals < 0 || decimals > MAX_ASSET_DECIMALS) {
475
- throw new AmountFormatError(
476
- "invalid_decimals",
477
- `decimals must be an integer in [0, ${MAX_ASSET_DECIMALS}], got ${decimals}`
478
- );
479
- }
480
- };
481
- var assertRepresentable = (value, what) => {
482
- if (value >= ATOMIC_CEILING) {
483
- throw new AmountFormatError(
484
- "too_large",
485
- `${what} does not fit the canonical 30-digit encoding`
486
- );
487
- }
488
- };
489
- var Amount = {
490
- /**
491
- * A human decimal into atomic units.
492
- *
493
- * `string` only, and no exponent. Accepting a `number` is the whole v1
494
- * footgun: it makes `100000` ambiguous between sats and whole BTC, and by
495
- * the time the ambiguity resolves the offer is funded. Exponent form goes
496
- * for the same reason — a UI never produces `1e-4`, so accepting it only
497
- * widens what a mistake can look like.
498
- *
499
- * Refuses rather than rounds when the input is finer than the asset: a
500
- * silently truncated amount is a swap for the wrong size, and nothing
501
- * downstream can tell it was ever a different number. Refuses too when the
502
- * result would not survive the record boundary, so one law holds in both
503
- * directions.
504
- */
505
- parse(display, asset3) {
506
- assertDecimals(asset3.decimals);
507
- const parts = SCALED_DECIMAL.exec(display);
508
- if (!parts) {
509
- throw new AmountFormatError(
510
- "not_decimal",
511
- `not an unsigned decimal amount: ${JSON.stringify(display)} (write 0.5, not .5; no sign, exponent, separator or space)`
512
- );
513
- }
514
- const [, whole, fraction = ""] = parts;
515
- if (fraction.length > asset3.decimals) {
516
- throw new AmountFormatError(
517
- "too_precise",
518
- `${display} has more precision than ${asset3.decimals} decimals allow`
519
- );
520
- }
521
- if (whole.length + fraction.length > MAX_SIGNIFICANT_DIGITS) {
522
- throw new AmountFormatError("too_large", `${display} has too many digits`);
523
- }
524
- const value = toAtomic(display, asset3.decimals);
525
- assertRepresentable(value, `${display} at ${asset3.decimals} decimals`);
526
- return value;
527
- },
528
- /**
529
- * Atomic units into a human decimal, trailing zeros trimmed.
530
- *
531
- * Refuses a negative: every amount on this surface is an obligation, and a
532
- * negative one is a defect upstream rather than a number to render.
533
- */
534
- format(value, asset3) {
535
- assertDecimals(asset3.decimals);
536
- if (value < 0n) {
537
- throw new AmountFormatError("negative", `amount must be non-negative, got ${value}`);
538
- }
539
- assertRepresentable(value, `${value}`);
540
- return fromAtomic(value, asset3.decimals);
541
- }
542
- };
543
- var toAtomicDecimal = (value) => {
544
- if (value < 0n) {
545
- throw new AmountFormatError("negative", `amount must be non-negative, got ${value}`);
546
- }
547
- assertRepresentable(value, `${value}`);
548
- return value.toString();
549
- };
550
- var fromAtomicDecimal = (text) => {
551
- if (!isAmount(text)) {
552
- throw new AmountFormatError(
553
- "not_canonical",
554
- `not a canonical atomic amount: ${JSON.stringify(text)}`
555
- );
556
- }
557
- return BigInt(text);
558
- };
559
- var isAtomicDecimal = (value) => typeof value === "string" && AMOUNT_PATTERN.test(value);
560
-
561
522
  // src/client/rfqAmount.ts
562
- import { isAmount as isAmount2 } from "@arkade-os/solver-discovery";
523
+ import { isAmount } from "@arkade-os/solver-discovery";
563
524
  var toRfqAmountSide = (on) => on === "give" ? "from" : "to";
564
525
  var fromRfqAmountSide = (side) => side === "from" ? "give" : "take";
565
526
  var encodeRfqAmount = (value, field) => {
@@ -576,7 +537,7 @@ var encodeRfqAmount = (value, field) => {
576
537
  };
577
538
  var decodeRfqAmount = (raw, field) => {
578
539
  if (typeof raw === "string") {
579
- if (!isAmount2(raw)) {
540
+ if (!isAmount(raw)) {
580
541
  throw new AmountEncodingUnsupported(
581
542
  field,
582
543
  raw,
@@ -590,8 +551,6 @@ var decodeRfqAmount = (raw, field) => {
590
551
  throw new AmountEncodingUnsupported(
591
552
  field,
592
553
  `${raw}`,
593
- // Past 2^53 the number arrived already rounded — there is no
594
- // "narrow carefully" branch, only a wrong amount.
595
554
  "a JSON number amount is only readable as a non-negative safe integer"
596
555
  );
597
556
  }
@@ -614,109 +573,48 @@ var toSafeNumber = (value, field) => {
614
573
  return Number(value);
615
574
  };
616
575
 
617
- // src/client/record.ts
618
- var assetSwapIdOf = (family, quoteId) => `${family}:${quoteId}`;
619
- var OFFER_SWAP_ID_PREFIX = "offer:";
620
- var RFQ_SWAP_ID_PREFIX = "rfq:";
621
- var familyOfSwapId = (swapId) => swapId.startsWith(OFFER_SWAP_ID_PREFIX) ? "offer" : swapId.startsWith(RFQ_SWAP_ID_PREFIX) ? "rfq" : void 0;
622
- 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;
623
- var recordEndpoint = (endpoint2) => ({
624
- corridor: endpoint2.corridor,
625
- asset: endpoint2.asset,
626
- instrument: recordInstrument(endpoint2.instrument)
627
- });
628
- var recordInstrument = (instrument) => {
629
- switch (instrument.kind) {
630
- case "wallet":
631
- return { kind: "wallet" };
632
- case "address":
633
- return { kind: "address", address: instrument.address };
634
- case "invoice":
635
- return {
636
- kind: "invoice",
637
- bolt11: instrument.bolt11,
638
- paymentHash: instrument.paymentHash,
639
- ...instrument.amount === void 0 ? {} : { amount: toAtomicDecimal(instrument.amount) },
640
- expiresAt: instrument.expiresAt
641
- };
642
- }
643
- };
644
- var instrumentOf = (instrument) => {
645
- switch (instrument.kind) {
646
- case "wallet":
647
- return { kind: "wallet" };
648
- case "address":
649
- return { kind: "address", address: instrument.address };
650
- case "invoice":
651
- return {
652
- kind: "invoice",
653
- bolt11: instrument.bolt11,
654
- paymentHash: instrument.paymentHash,
655
- ...instrument.amount === void 0 ? {} : { amount: fromAtomicDecimal(instrument.amount) },
656
- expiresAt: instrument.expiresAt
657
- };
576
+ // src/client/accept.ts
577
+ import { hex as hex2 } from "@scure/base";
578
+ import { stableStringify } from "@arkade-os/solver-discovery";
579
+ import {
580
+ asset as asset2,
581
+ getAllNormalizedVtxos,
582
+ SendDeadlineExceededError
583
+ } from "@arkade-os/sdk";
584
+
585
+ // src/client/fundingNotSubmitted.ts
586
+ import { ArkAddress } from "@arkade-os/sdk";
587
+ import { hex } from "@scure/base";
588
+ var retireUnsubmittedFunding = async (wallet, repository, record, contracts) => {
589
+ if (!fundingWasNotSubmitted(record)) return;
590
+ const script = record.family === "offer" ? record.swapPkScript : record.lockupPkScript;
591
+ try {
592
+ await retireOfferContract(
593
+ contracts ?? await wallet.getContractManager(),
594
+ async () => {
595
+ const records = await collectSwapRecords(repository);
596
+ const native = records.map((row) => ({
597
+ id: row.id,
598
+ swapPkScript: row.family === "offer" ? row.swapPkScript : row.lockupPkScript,
599
+ createdAt: row.createdAt * 1e3,
600
+ status: row.family === "offer" ? row.status : fundingWasNotSubmitted(row) ? "cancelled" : row.state === "settled" || row.state === "refunded" ? "fulfilled" : "pending"
601
+ }));
602
+ const legacy = (await collectRfqSwaps(repository)).map((row) => ({
603
+ swapPkScript: hex.encode(ArkAddress.decode(row.lockupAddress).pkScript),
604
+ createdAt: row.createdAt * 1e3,
605
+ status: row.state === "settled" || row.state === "refunded" ? "fulfilled" : "pending"
606
+ }));
607
+ return [...native, ...legacy];
608
+ },
609
+ script,
610
+ { scope: wallet }
611
+ );
612
+ } catch (error) {
613
+ console.warn(`[swap] could not retire unsent funding for ${record.id}`, error);
658
614
  }
659
615
  };
660
- var recordArtifact = (artifact) => artifact.kind === "invoice" ? { kind: "invoice", bolt11: artifact.bolt11 } : {
661
- kind: "deposit",
662
- corridor: artifact.corridor,
663
- address: artifact.address,
664
- asset: artifact.asset,
665
- amount: toAtomicDecimal(artifact.amount),
666
- ...artifact.expiresAt === void 0 ? {} : { expiresAt: artifact.expiresAt }
667
- };
668
- var artifactOf = (artifact) => artifact.kind === "invoice" ? { kind: "invoice", bolt11: artifact.bolt11 } : {
669
- kind: "deposit",
670
- corridor: artifact.corridor,
671
- address: artifact.address,
672
- asset: artifact.asset,
673
- amount: fromAtomicDecimal(artifact.amount),
674
- ...artifact.expiresAt === void 0 ? {} : { expiresAt: artifact.expiresAt }
675
- };
676
- var recordLeg = (leg) => ({
677
- asset: leg.asset,
678
- amount: toAtomicDecimal(leg.amount)
679
- });
680
- var legOf = (leg) => ({
681
- asset: leg.asset,
682
- amount: fromAtomicDecimal(leg.amount)
683
- });
684
- var swapOf = (record, outcome) => ({
685
- id: assetSwapIdOf(record.family, record.id),
686
- family: record.family,
687
- outcome,
688
- route: {
689
- give: {
690
- corridor: record.route.give.corridor,
691
- asset: record.route.give.asset,
692
- instrument: instrumentOf(record.route.give.instrument)
693
- },
694
- take: {
695
- corridor: record.route.take.corridor,
696
- asset: record.route.take.asset,
697
- instrument: instrumentOf(record.route.take.instrument)
698
- }
699
- },
700
- give: legOf(record.give),
701
- take: legOf(record.take),
702
- fee: legOf(record.fee),
703
- market: record.market,
704
- ...record.solver === void 0 ? {} : { solver: record.solver },
705
- ...record.family === "rfq" ? { lock: record.lock } : {},
706
- ...record.family === "rfq" ? { refundLocktime: record.refundLocktime } : {},
707
- ...record.artifact === void 0 ? {} : { artifact: artifactOf(record.artifact) },
708
- expiresAt: record.expiresAt,
709
- ...record.fundingTxid === void 0 ? {} : { fundingTxid: record.fundingTxid },
710
- ...record.failure === void 0 ? {} : { failure: record.failure },
711
- ...record.blockedReason === void 0 ? {} : { blockedReason: record.blockedReason },
712
- createdAt: record.createdAt,
713
- updatedAt: record.updatedAt
714
- });
715
- var fundsFromWallet = (route) => route.give.instrument.kind === "wallet";
716
616
 
717
617
  // src/client/accept.ts
718
- import { hex } from "@scure/base";
719
- import { asset as asset2, getAllNormalizedVtxos } from "@arkade-os/sdk";
720
618
  var acceptLocks = /* @__PURE__ */ new Map();
721
619
  var runSerialized = (id, body) => {
722
620
  const tail = acceptLocks.get(id) ?? Promise.resolve();
@@ -751,6 +649,7 @@ var conflictingFields = (record, quote) => {
751
649
  const incoming = recordedFacts(quote);
752
650
  const stored = {
753
651
  "route.pair": `${record.route.give.corridor}->${record.route.take.corridor}`,
652
+ assetPayment: assetPaymentFacts(record.assetPayment),
754
653
  "give.asset": record.route.give.asset,
755
654
  "take.asset": record.route.take.asset,
756
655
  "give.amount": record.give.amount,
@@ -774,6 +673,9 @@ var conflictingFields = (record, quote) => {
774
673
  };
775
674
  var recordedFacts = (quote) => ({
776
675
  "route.pair": `${quote.route.give.corridor}->${quote.route.take.corridor}`,
676
+ assetPayment: assetPaymentFacts(
677
+ quote.assetPayment === void 0 ? void 0 : recordAssetPayment(quote.assetPayment)
678
+ ),
777
679
  "give.asset": quote.route.give.asset,
778
680
  "take.asset": quote.route.take.asset,
779
681
  "give.amount": recordLeg(quote.give).amount,
@@ -789,21 +691,14 @@ var marketSourceOf = (market) => market.kind === "card" ? market.source : void 0
789
691
  var assertFundable2 = async (wallet, quote) => {
790
692
  const give = quote.give;
791
693
  const balance = await wallet.getBalance();
792
- if (assetPartOf(give.asset) === BTC_ASSET_PART) {
793
- const available2 = BigInt(balance.available);
794
- if (available2 < give.amount) {
795
- throw new InsufficientFunds(give.asset, give.amount, available2);
796
- }
797
- return;
798
- }
799
- const held = balance.availableAssets.find((a) => give.asset.endsWith(a.assetId));
800
- const available = held?.amount ?? 0n;
694
+ const available = isBtcAsset(give.asset) ? BigInt(balance.available) : balance.availableAssets.find((a) => give.asset.endsWith(a.assetId))?.amount ?? 0n;
801
695
  if (available < give.amount) {
802
696
  throw new InsufficientFunds(give.asset, give.amount, available);
803
697
  }
804
698
  };
805
699
  var commonOf = (quote, now) => ({
806
700
  id: quote.id,
701
+ ...quote.assetPayment === void 0 ? {} : { assetPayment: recordAssetPayment(quote.assetPayment) },
807
702
  route: {
808
703
  give: recordEndpoint(quote.route.give),
809
704
  take: recordEndpoint(quote.route.take)
@@ -826,24 +721,20 @@ var corridorRecord = (quote, preparation, now) => {
826
721
  ...commonOf(quote, now),
827
722
  family: "rfq",
828
723
  state: "pending",
829
- kind: kindOf(preparation),
724
+ kind: KIND_OF[preparation.route],
830
725
  rfqId: preparation.rfqId,
831
726
  lockupAddress: preparation.lockup.address,
832
- lockupPkScript: hex.encode(preparation.lockup.pkScript),
727
+ lockupPkScript: hex2.encode(preparation.lockup.pkScript),
833
728
  lock: { hash: quote.lock.hash },
834
729
  refundLocktime: quote.refundLocktime,
835
730
  profile: profileOf(preparation, quote.lock.hash)
836
731
  };
837
732
  };
838
- var kindOf = (preparation) => {
839
- switch (preparation.route) {
840
- case "arkade->lightning":
841
- return "lightning_send";
842
- case "lightning->arkade":
843
- return "lightning_receive";
844
- case "arkade->onchain":
845
- return "onchain_send";
846
- }
733
+ var KIND_OF = {
734
+ "arkade->lightning": "lightning_send",
735
+ "lightning->arkade": "lightning_receive",
736
+ "arkade->onchain": "onchain_send",
737
+ "onchain->arkade": "onchain_receive"
847
738
  };
848
739
  var profileOf = (preparation, paymentHash) => {
849
740
  const secrets = rfqSecretsProfile(preparation.secrets, paymentHash);
@@ -864,9 +755,24 @@ var profileOf = (preparation, paymentHash) => {
864
755
  htlcParams: preparation.htlcParams,
865
756
  l1Network: preparation.l1Network,
866
757
  minConfirmations: preparation.minConfirmations,
758
+ expectedAmount: toSafeNumber(preparation.expectedAmount, "expectedAmount"),
867
759
  payoutPkScript: preparation.payoutPkScript
868
760
  })
869
761
  };
762
+ case "onchain->arkade":
763
+ return {
764
+ ...secrets,
765
+ expectedAmount: toSafeNumber(preparation.expectedAmount, "expectedAmount"),
766
+ payoutAddress: preparation.payoutAddress,
767
+ ...onchainReceiveProfile({
768
+ htlc: preparation.htlc,
769
+ htlcParams: preparation.htlcParams,
770
+ l1Network: preparation.l1Network,
771
+ minConfirmations: preparation.minConfirmations,
772
+ refundPkScript: preparation.refundPkScript,
773
+ refundDescriptor: preparation.refundKey.descriptor
774
+ })
775
+ };
870
776
  }
871
777
  };
872
778
  var acceptQuote = async (input) => runSerialized(input.quote.id, () => acceptQuoteBody(input));
@@ -881,6 +787,7 @@ var acceptQuoteBody = async (input) => {
881
787
  if (fields.length > 0) {
882
788
  throw new AcceptConflict(quote.id, stored.id, fields);
883
789
  }
790
+ if (fundingWasNotSubmitted(stored)) return answer(stored);
884
791
  if (stored.fundingTxid !== void 0) return answer(stored);
885
792
  if (!fundsFromWallet(stored.route)) return answer(stored);
886
793
  const found = await reconcileFunding({ wallet }, stored);
@@ -888,7 +795,13 @@ var acceptQuoteBody = async (input) => {
888
795
  return answer(await stampFunding(repository, stored, found, now));
889
796
  }
890
797
  if (expired) throw new QuoteExpired(quote.id, quote.expiresAt, now);
891
- return answer(await fundAndStamp({ wallet, now }, stored, repository));
798
+ return answer(
799
+ await fundAndStamp(
800
+ { wallet, now, validUntil: input.validUntil, drive: input.drive },
801
+ stored,
802
+ repository
803
+ )
804
+ );
892
805
  }
893
806
  if (expired) throw new QuoteExpired(quote.id, quote.expiresAt, now);
894
807
  const preparation = input.preparation;
@@ -899,39 +812,117 @@ var acceptQuoteBody = async (input) => {
899
812
  }
900
813
  const funds = fundsFromWallet(quote.route);
901
814
  if (funds) await assertFundable2(wallet, quote);
902
- const record = preparation.backend === "feed" ? await registeredOfferRecord(input, preparation) : await registeredCorridorRecord(input, preparation);
815
+ const record = preparation.backend === "feed" ? await registeredOfferRecord(input, preparation) : preparation.route === "arkade->arkade" ? await registeredAssetRecord(input, preparation) : await registeredCorridorRecord(input, preparation);
903
816
  await repository.saveSwapRecord(record);
904
817
  if (!funds) return answer(record);
905
- return answer(await fundAndStamp({ wallet, now }, record, repository));
818
+ return answer(
819
+ await fundAndStamp(
820
+ {
821
+ wallet,
822
+ now,
823
+ validUntil: input.validUntil,
824
+ drive: input.drive,
825
+ firstFundingAttempt: true
826
+ },
827
+ record,
828
+ repository
829
+ )
830
+ );
906
831
  };
907
832
  var registeredOfferRecord = async (input, preparation) => {
908
833
  const { quote, wallet, corridors, now } = input;
909
834
  const { plan } = preparation;
910
- const arkade = corridors.get("arkade").deps;
835
+ const arkade2 = corridors.get("arkade").deps;
911
836
  const receiveIsBtc = plan.receive.asset.id === BTC_ASSET_ID;
912
- const offer = await createOffer(wallet, {
913
- // Keyed on the receive side: the covenant binds what the fill delivers.
914
- wantAmount: plan.receive.atomic,
915
- ...receiveIsBtc ? { offerAsset: asset2.AssetId.fromString(plan.deposit.asset.id) } : { wantAsset: asset2.AssetId.fromString(plan.receive.asset.id) },
916
- emulatorPubkey: arkade.emulatorPubkey
917
- });
837
+ const offer = await createOffer(
838
+ wallet,
839
+ {
840
+ // Keyed on the receive side: the covenant binds what the fill delivers.
841
+ wantAmount: plan.receive.atomic,
842
+ ...receiveIsBtc ? { offerAsset: asset2.AssetId.fromString(plan.deposit.asset.id) } : { wantAsset: asset2.AssetId.fromString(plan.receive.asset.id) },
843
+ emulatorPubkey: arkade2.emulatorPubkey
844
+ },
845
+ { coverageId: quote.id }
846
+ );
918
847
  return {
919
848
  ...commonOf(quote, now),
920
849
  family: "offer",
921
850
  status: "pending",
922
851
  offerHex: offer.offerHex,
923
852
  swapAddress: offer.address,
924
- swapPkScript: hex.encode(offer.swapPkScript)
853
+ swapPkScript: hex2.encode(offer.swapPkScript)
854
+ };
855
+ };
856
+ var registeredAssetRecord = async (input, preparation) => {
857
+ if (stableStringify(
858
+ input.quote.assetPayment === void 0 ? void 0 : recordAssetPayment(input.quote.assetPayment)
859
+ ) !== stableStringify(
860
+ preparation.assetPayment === void 0 ? void 0 : recordAssetPayment(preparation.assetPayment)
861
+ ))
862
+ throw new Error("asset payment differs from verified quote preparation");
863
+ if (preparation.assetPaymentRecipient !== void 0 && stableStringify(input.quote.route.take.instrument) !== stableStringify(preparation.assetPaymentRecipient))
864
+ throw new Error("asset payment recipient differs from verified quote preparation");
865
+ await registerDerivedOffer(input.wallet, preparation.offer, { coverageId: input.quote.id });
866
+ return {
867
+ ...commonOf(input.quote, input.now),
868
+ ...preparation.assetPayment === void 0 ? {} : { assetPayment: recordAssetPayment(preparation.assetPayment) },
869
+ family: "offer",
870
+ status: "pending",
871
+ offerHex: preparation.offer.offerHex,
872
+ swapAddress: preparation.offer.address,
873
+ swapPkScript: hex2.encode(preparation.offer.swapPkScript),
874
+ ...preparation.carrierSats === void 0 ? {} : { carrierSats: preparation.carrierSats.toString() }
925
875
  };
926
876
  };
927
877
  var registeredCorridorRecord = async (input, preparation) => {
928
878
  const contracts = await input.wallet.getContractManager();
929
- await registerLockupContract(contracts, preparation.lockup.script, preparation.lockup.address);
879
+ await registerLockupContract(contracts, preparation.lockup.script, preparation.lockup.address, {
880
+ coverageId: input.quote.id,
881
+ scope: input.wallet
882
+ });
883
+ await promoteOfferContract(
884
+ contracts,
885
+ hex2.encode(preparation.lockup.script.pkScript),
886
+ void 0,
887
+ {
888
+ coverageId: input.quote.id,
889
+ scope: input.wallet
890
+ }
891
+ );
930
892
  return corridorRecord(input.quote, preparation, input.now);
931
893
  };
932
894
  var fundAndStamp = async (input, record, repository) => {
933
- const txid = await fund(input, record);
934
- return stampFunding(repository, record, txid, input.now);
895
+ const bounds = storedFundingBounds(record.assetPayment, record.expiresAt);
896
+ const cap = input.validUntil === void 0 ? bounds.validUntil : Math.min(input.validUntil, bounds.validUntil ?? record.expiresAt);
897
+ const validUntil = cap === void 0 ? void 0 : Math.min(cap, record.expiresAt);
898
+ if (input.firstFundingAttempt && record.assetPayment !== void 0 && validUntil !== void 0 && validUntil < record.assetPayment.validUntil) {
899
+ record = { ...record, assetPayment: { ...record.assetPayment, validUntil } };
900
+ await repository.saveSwapRecord(record);
901
+ }
902
+ try {
903
+ const txid = await fund({ ...input, ...bounds, validUntil }, record);
904
+ return stampFunding(repository, record, txid, input.now);
905
+ } catch (error) {
906
+ if (input.firstFundingAttempt && validUntil !== void 0 && error instanceof SendDeadlineExceededError) {
907
+ const stopped = {
908
+ ...record,
909
+ ...record.family === "offer" ? { status: "cancelled" } : { state: "failed" },
910
+ fundingNotSubmitted: { reason: "send_deadline", validUntil },
911
+ updatedAt: Math.floor(Date.now() / 1e3)
912
+ };
913
+ try {
914
+ await repository.saveSwapRecord(stopped);
915
+ input.drive?.ingest(stopped);
916
+ await retireUnsubmittedFunding(input.wallet, repository, stopped);
917
+ } catch (cause) {
918
+ console.warn(
919
+ `[swap] could not finish unsent funding cleanup for ${record.id}`,
920
+ cause
921
+ );
922
+ }
923
+ }
924
+ throw error;
925
+ }
935
926
  };
936
927
  var stampFunding = async (repository, record, fundingTxid, now) => {
937
928
  const stamped = { ...record, fundingTxid, updatedAt: now };
@@ -944,14 +935,20 @@ var stampFunding = async (repository, record, fundingTxid, now) => {
944
935
  };
945
936
  var fund = async (input, record) => {
946
937
  const { wallet } = input;
938
+ const send = (recipient) => input.validUntil === void 0 && input.inputExpiryFloor === void 0 ? wallet.send(recipient) : wallet.send({
939
+ recipients: [recipient],
940
+ ...input.validUntil === void 0 ? {} : { validUntil: input.validUntil },
941
+ ...input.inputExpiryFloor === void 0 ? {} : { inputExpiryFloor: input.inputExpiryFloor }
942
+ });
947
943
  if (record.family === "offer") {
948
944
  const amount = fromAtomicDecimal(record.give.amount);
949
- const depositIsBtc = assetPartOf(record.route.give.asset) === BTC_ASSET_PART;
950
- return wallet.send({
945
+ const depositIsBtc = isBtcAssetLenient(record.route.give.asset);
946
+ return send({
951
947
  address: record.swapAddress,
952
- // An asset deposit rides the SDK's dust-sat carrier, so the sats
953
- // amount is left to the default rather than set here.
948
+ // An asset deposit rides a dust-sat carrier: the solver's published one when the record
949
+ // names it (the fill is priced against it), else the SDK default.
954
950
  ...depositIsBtc ? { amount: toSafeNumber(amount, "give.amount") } : {
951
+ ...record.carrierSats === void 0 ? {} : { amount: toSafeNumber(BigInt(record.carrierSats), "carrierSats") },
955
952
  assets: [
956
953
  { assetId: toDiscoveryLeg(record.route.give.asset).assetId, amount }
957
954
  ]
@@ -959,17 +956,17 @@ var fund = async (input, record) => {
959
956
  extensions: [offerExtensionOf(record)]
960
957
  });
961
958
  }
962
- if (record.kind === "lightning_receive") {
959
+ if (record.kind === "lightning_receive" || record.kind === "onchain_receive") {
963
960
  throw new Error(`receive swap ${record.id} funds nothing from this wallet`);
964
961
  }
965
- return wallet.send({
962
+ return send({
966
963
  address: record.lockupAddress,
967
964
  amount: toSafeNumber(fromAtomicDecimal(record.give.amount), "give.amount")
968
965
  });
969
966
  };
970
967
  var offerExtensionOf = (record) => ({
971
968
  type: OFFER_PACKET_TYPE,
972
- payload: hex.decode(record.offerHex)
969
+ payload: hex2.decode(record.offerHex)
973
970
  });
974
971
  var reconcileFunding = async (input, record) => {
975
972
  const script = record.family === "offer" ? record.swapPkScript : record.lockupPkScript;
@@ -981,7 +978,7 @@ var reconcileFunding = async (input, record) => {
981
978
  };
982
979
  var depositMatches = (vtxo, record, expected) => {
983
980
  const giveAsset = record.route.give.asset;
984
- if (assetPartOf(giveAsset) === BTC_ASSET_PART) {
981
+ if (isBtcAssetLenient(giveAsset)) {
985
982
  return BigInt(vtxo.value) === expected;
986
983
  }
987
984
  return (vtxo.assets ?? []).some(
@@ -1014,14 +1011,22 @@ var publicAssetId = (corridor, assetId, network) => {
1014
1011
  if (!ARKADE_ASSET_IDENTITY.test(assetId)) return void 0;
1015
1012
  return `arkade:${network}/${ARKADE_ASSET_NAMESPACE}:${assetId}`;
1016
1013
  };
1014
+ var cardLegAssetId = (card, side, network) => {
1015
+ const corridor = corridorOfRail(marketCorridor(card, side));
1016
+ if (corridor === void 0) return void 0;
1017
+ const canonical = marketAssetId(card, side);
1018
+ if (canonical !== void 0 && isAssetId(canonical)) return canonical;
1019
+ return publicAssetId(
1020
+ corridor,
1021
+ (side === "base" ? card.base_asset : card.quote_asset).id,
1022
+ network
1023
+ );
1024
+ };
1017
1025
  var aliasTableFrom = (markets, network) => {
1018
1026
  const rows = /* @__PURE__ */ new Map();
1019
1027
  const add = (card, side) => {
1020
1028
  const info = side === "base" ? card.base_asset : card.quote_asset;
1021
- const corridor = corridorOfRail(marketCorridor(card, side));
1022
- if (corridor === void 0) return;
1023
- const canonical = marketAssetId(card, side);
1024
- const id = canonical !== void 0 && isAssetId(canonical) ? canonical : publicAssetId(corridor, info.id, network);
1029
+ const id = cardLegAssetId(card, side, network);
1025
1030
  if (id === void 0 || typeof info.ticker !== "string" || info.ticker === "") return;
1026
1031
  rows.set(`${id} ${info.ticker.toLowerCase()}`, { id, ticker: info.ticker });
1027
1032
  };
@@ -1037,7 +1042,7 @@ var scopedToRail = (table, rail) => ({
1037
1042
  });
1038
1043
 
1039
1044
  // src/client/corridors/arkade.ts
1040
- import { ArkAddress, arkTarget, assertRecipientArkadeAddress } from "@arkade-os/sdk";
1045
+ import { ArkAddress as ArkAddress2, arkTarget, assertRecipientArkadeAddress } from "@arkade-os/sdk";
1041
1046
  var ARKADE_DRIVE = {};
1042
1047
  var messageOf = (error) => error instanceof Error ? error.message : String(error);
1043
1048
  var arkadeCorridor = Object.assign(
@@ -1049,7 +1054,7 @@ var arkadeCorridor = Object.assign(
1049
1054
  const target = arkTarget(raw);
1050
1055
  if (target === void 0) return void 0;
1051
1056
  try {
1052
- const address = ArkAddress.decode(target);
1057
+ const address = ArkAddress2.decode(target);
1053
1058
  assertRecipientArkadeAddress(target, address, {
1054
1059
  hrp: deps.network.hrp,
1055
1060
  signerSet: deps.signerSet
@@ -1069,7 +1074,6 @@ var DEFAULT_INVOICE_EXPIRY_SECONDS = 3600;
1069
1074
  var valueOf = (decoded, name) => decoded.sections.find(
1070
1075
  (section) => section.name === name
1071
1076
  )?.value;
1072
- var PAYMENT_HASH = /^[0-9a-f]{64}$/;
1073
1077
  var decodeBolt11 = (invoice) => {
1074
1078
  const decoded = bolt11.decode(invoice);
1075
1079
  const timestamp = valueOf(decoded, "timestamp");
@@ -1091,7 +1095,7 @@ var decodeBolt11 = (invoice) => {
1091
1095
  };
1092
1096
 
1093
1097
  // src/client/corridors/chainSource.ts
1094
- import { hex as hex2 } from "@scure/base";
1098
+ import { hex as hex3 } from "@scure/base";
1095
1099
  import * as btc from "@scure/btc-signer";
1096
1100
  import { EsploraProvider } from "@arkade-os/sdk";
1097
1101
  var addressOfScript = (script, network) => btc.Address(network).encode(btc.OutScript.decode(script));
@@ -1120,27 +1124,29 @@ var chainSourceOver = (backend, network) => {
1120
1124
  return coins.map((coin) => ({
1121
1125
  txid: coin.txid,
1122
1126
  vout: coin.vout,
1123
- // `Coin.value` is `number` sats; the HTLC's is `bigint`.
1124
1127
  amount: BigInt(coin.value),
1125
- // `Coin` carries a height, never a depth, so the tip is the
1126
- // second half of the answer. A confirmed coin is one deep, not
1127
- // zero — the block it landed in counts.
1128
+ // A confirmed coin is one deep, not zero: its own block counts.
1128
1129
  confirmations: coin.status.confirmed && coin.status.block_height !== void 0 ? Math.max(0, tip.height - coin.status.block_height + 1) : 0
1129
1130
  }));
1130
1131
  },
1131
1132
  async getSpendingTx(txid, vout, pkScript) {
1132
- const outspends = await backend.provider.getTxOutspends(txid);
1133
- const outspend = outspends[vout];
1133
+ const outspend = backend.provider.getTxOutspend ? await backend.provider.getTxOutspend(txid, vout) : (await backend.provider.getTxOutspends(txid))[vout];
1134
1134
  if (!outspend?.spent) return null;
1135
1135
  const spender = outspend.txid || await spenderFromVins(txid, vout, pkScript);
1136
1136
  if (!spender) return null;
1137
- return { txHex: hex2.encode(await backend.provider.getRawTransaction(spender)) };
1137
+ return { txHex: hex3.encode(await backend.provider.getRawTransaction(spender)) };
1138
1138
  },
1139
1139
  broadcast(txHex) {
1140
1140
  return backend.provider.broadcastTransaction(txHex);
1141
1141
  },
1142
1142
  async getMtp() {
1143
1143
  return (await backend.tip()).mtp;
1144
+ },
1145
+ async getTxStatus(txid) {
1146
+ return (await backend.provider.getTxStatus(txid)).confirmed ? "confirmed" : "unconfirmed";
1147
+ },
1148
+ getFeeRate() {
1149
+ return backend.provider.getFeeRate();
1144
1150
  }
1145
1151
  };
1146
1152
  };
@@ -1183,6 +1189,12 @@ var refusedIfNull = (value, corridor, dep) => {
1183
1189
  if (value === null) throw new MissingCorridorDep(corridor, dep);
1184
1190
  return value;
1185
1191
  };
1192
+ var refusedIfMalformed = (value, dep) => {
1193
+ if (value !== void 0 && value !== null && !(Number.isFinite(value) && value > 0)) {
1194
+ throw new MissingCorridorDep("onchain", dep);
1195
+ }
1196
+ return value;
1197
+ };
1186
1198
  var emulatorPubkeyFor = (base) => {
1187
1199
  if (base.emulatorPubkey !== void 0) {
1188
1200
  return resolveEmulatorPubkey(base.network, base.emulatorPubkey);
@@ -1224,26 +1236,27 @@ function resolveCorridorDeps(corridor, overrides, base) {
1224
1236
  case "onchain": {
1225
1237
  const chain = refusedIfNull(overrides?.onchain?.chain, "onchain", "chain source");
1226
1238
  const claim = refusedIfNull(overrides?.onchain?.claim, "onchain", "L1 claim callback");
1227
- const feeRateOverride = overrides?.onchain?.claimFeeRateSatVb;
1228
- if (feeRateOverride !== void 0 && feeRateOverride !== null && !(Number.isFinite(feeRateOverride) && feeRateOverride > 0)) {
1229
- throw new MissingCorridorDep("onchain", "L1 claim fee rate");
1230
- }
1239
+ const refund = refusedIfNull(
1240
+ overrides?.onchain?.refund,
1241
+ "onchain",
1242
+ "L1 refund callback"
1243
+ );
1244
+ const feeRateOverride = refusedIfMalformed(
1245
+ overrides?.onchain?.claimFeeRateSatVb,
1246
+ "L1 claim fee rate"
1247
+ );
1231
1248
  const claimFeeRateSatVb = feeRateOverride === null ? void 0 : feeRateOverride ?? ONCHAIN_CLAIM_FEE_RATE_SATVB[base.networkName];
1232
- const vsizeOverride = overrides?.onchain?.claimVsize;
1233
- if (vsizeOverride !== void 0 && vsizeOverride !== null && !(Number.isFinite(vsizeOverride) && vsizeOverride > 0)) {
1234
- throw new MissingCorridorDep("onchain", "L1 claim vsize");
1235
- }
1236
- const claimVsize = vsizeOverride === null ? ONCHAIN_CLAIM_VSIZE : vsizeOverride ?? ONCHAIN_CLAIM_VSIZE;
1249
+ const claimVsize = refusedIfMalformed(overrides?.onchain?.claimVsize, "L1 claim vsize") ?? ONCHAIN_CLAIM_VSIZE;
1250
+ const l1Network = l1NetworkFromArk(base.networkName);
1237
1251
  return {
1238
1252
  networkName: base.networkName,
1239
- chain: esploraChainSource({
1253
+ chain: chain && "provider" in chain ? chainSourceFrom(chain.provider, l1Network) : esploraChainSource({
1240
1254
  esploraUrl: chain?.esploraUrl ?? ESPLORA_URL[base.networkName],
1241
- network: L1_NETWORKS[l1NetworkFromArk(base.networkName)],
1255
+ network: L1_NETWORKS[l1Network],
1242
1256
  fetchImpl: base.fetchImpl
1243
1257
  }),
1244
1258
  ...claim === void 0 ? {} : { claim },
1245
- // Absent-on-an-unknown-network and explicitly-off read the
1246
- // same: no default claim path, manual mode.
1259
+ ...refund === void 0 ? {} : { refund },
1247
1260
  ...claimFeeRateSatVb === void 0 ? {} : { claimFeeRateSatVb },
1248
1261
  claimVsize
1249
1262
  };
@@ -1376,6 +1389,7 @@ var discoveryIndex = (input) => {
1376
1389
  ref: { fetchedAt: Date.now(), live: true, source: "injected" }
1377
1390
  };
1378
1391
  let held;
1392
+ let revalidateAt = 0;
1379
1393
  const unavailable = (detail) => {
1380
1394
  throw new DiscoverySnapshotUnavailable(input.network, detail);
1381
1395
  };
@@ -1399,8 +1413,7 @@ var discoveryIndex = (input) => {
1399
1413
  markets: cached.markets,
1400
1414
  ref: {
1401
1415
  fetchedAt: cached.fetchedAt,
1402
- // The cards were read back out of local storage, whatever their
1403
- // age: nothing here can attest that a registry ever served them.
1416
+ // Whatever its age: nothing attests a registry ever served these cards.
1404
1417
  live: false,
1405
1418
  source: "cache",
1406
1419
  registry: url
@@ -1415,30 +1428,50 @@ var discoveryIndex = (input) => {
1415
1428
  held = cached;
1416
1429
  return cached;
1417
1430
  }
1431
+ const { network: indexed, registry: url } = sources();
1432
+ if (indexed && url && config.localCards?.length) {
1433
+ const { markets } = await discover({
1434
+ registries: [],
1435
+ localCards: [...config.localCards],
1436
+ network: indexed
1437
+ });
1438
+ if (markets.length > 0) {
1439
+ return { markets, ref: { fetchedAt: Date.now(), live: true, source: "local" } };
1440
+ }
1441
+ }
1418
1442
  return unavailable(whyUnavailable());
1419
1443
  };
1420
1444
  const load = async (opts = {}) => {
1421
1445
  if (injected) return injected;
1422
- const fresh = held?.ref.live === true && Date.now() - held.ref.fetchedAt < MARKETS_CACHE_TTL_MS;
1446
+ const fresh = held?.ref.live === true && Date.now() < revalidateAt;
1423
1447
  if (fresh && !opts.refresh) return held;
1424
1448
  const { network: indexed, registry: url } = sources();
1425
1449
  if (!indexed || !url) {
1426
1450
  return unavailable(whyUnavailable());
1427
1451
  }
1452
+ const delivery = trackDelivery(transportCardsOf(config.transportCards));
1428
1453
  const result = await discover({
1429
1454
  registries: [url],
1430
1455
  localCards: [...config.localCards ?? []],
1431
1456
  network: indexed,
1432
- fetchImpl: config.fetchImpl
1457
+ fetchImpl: config.fetchImpl,
1458
+ transportCards: delivery.fetcher
1433
1459
  });
1434
1460
  if (result.warnings.length) config.logger?.("solver discovery:", ...result.warnings);
1435
- if (result.sources.some((source) => source.ok)) {
1461
+ if (registryAnswered(result.sources)) {
1436
1462
  const fetchedAt = Date.now();
1437
1463
  held = {
1438
1464
  markets: result.markets,
1439
1465
  ref: { fetchedAt, live: true, source: "live", registry: url }
1440
1466
  };
1441
- if (input.repository) {
1467
+ const undelivered = delivery.undelivered();
1468
+ const keepsCache = undelivered.size > 0 && input.repository !== void 0 && undeliveredCarry(
1469
+ result.markets,
1470
+ undelivered,
1471
+ await readCache(input.repository, indexed, url)
1472
+ ).length > 0;
1473
+ revalidateAt = fetchedAt + (keepsCache ? DEGRADED_RETRY_MS : MARKETS_CACHE_TTL_MS);
1474
+ if (input.repository && !keepsCache) {
1442
1475
  try {
1443
1476
  await input.repository.saveCachedMarkets(indexed, url, {
1444
1477
  markets: result.markets,
@@ -1454,12 +1487,26 @@ var discoveryIndex = (input) => {
1454
1487
  held = cached;
1455
1488
  return cached;
1456
1489
  }
1490
+ if (result.markets.length > 0) {
1491
+ const fetchedAt = Date.now();
1492
+ held = { markets: result.markets, ref: { fetchedAt, live: true, source: "local" } };
1493
+ revalidateAt = fetchedAt + DEGRADED_RETRY_MS;
1494
+ return held;
1495
+ }
1457
1496
  return unavailable(whyUnavailable());
1458
1497
  };
1459
1498
  return { peek, load };
1460
1499
  };
1461
1500
 
1462
1501
  // src/client/driveRecords.ts
1502
+ import {
1503
+ ArkAddress as ArkAddress3,
1504
+ asset as asset3,
1505
+ assertPageRequest,
1506
+ pageResult
1507
+ } from "@arkade-os/sdk";
1508
+ import { sha256 } from "@noble/hashes/sha2.js";
1509
+ import { hex as hex4 } from "@scure/base";
1463
1510
  var splitRecords = (records) => {
1464
1511
  const corridor = [];
1465
1512
  const offer = [];
@@ -1478,12 +1525,15 @@ var rfqRecordOf = (record) => ({
1478
1525
  state: record.state,
1479
1526
  createdAt: record.createdAt,
1480
1527
  updatedAt: record.updatedAt,
1481
- ...record.refundTxid === void 0 ? {} : { refundTxid: record.refundTxid },
1482
- ...record.lockupSpendTxids?.length ? { lockupSpendTxids: [...record.lockupSpendTxids] } : {},
1483
- ...record.settlementPreimageHex === void 0 ? {} : { settlementPreimageHex: record.settlementPreimageHex },
1484
- ...record.failure === void 0 ? {} : { failure: record.failure },
1485
- ...record.claimFailure === void 0 ? {} : { claimFailure: record.claimFailure },
1486
- ...record.blockedReason === void 0 ? {} : { blockedReason: record.blockedReason }
1528
+ ...mutableHalfOf(record)
1529
+ });
1530
+ var mutableHalfOf = (from) => ({
1531
+ ...from.refundTxid === void 0 ? {} : { refundTxid: from.refundTxid },
1532
+ ...from.lockupSpendTxids?.length ? { lockupSpendTxids: [...from.lockupSpendTxids] } : {},
1533
+ ...from.settlementPreimageHex === void 0 ? {} : { settlementPreimageHex: from.settlementPreimageHex },
1534
+ ...from.failure === void 0 ? {} : { failure: from.failure },
1535
+ ...from.claimFailure === void 0 ? {} : { claimFailure: from.claimFailure },
1536
+ ...from.blockedReason === void 0 ? {} : { blockedReason: from.blockedReason }
1487
1537
  });
1488
1538
  var withRfqState = (record, state) => {
1489
1539
  const {
@@ -1500,14 +1550,20 @@ var withRfqState = (record, state) => {
1500
1550
  state: state.state,
1501
1551
  profile: state.profile,
1502
1552
  updatedAt: state.updatedAt,
1503
- ...state.refundTxid === void 0 ? {} : { refundTxid: state.refundTxid },
1504
- ...state.lockupSpendTxids?.length ? { lockupSpendTxids: [...state.lockupSpendTxids] } : {},
1505
- ...state.settlementPreimageHex === void 0 ? {} : { settlementPreimageHex: state.settlementPreimageHex },
1506
- ...state.failure === void 0 ? {} : { failure: state.failure },
1507
- ...state.claimFailure === void 0 ? {} : { claimFailure: state.claimFailure },
1508
- ...state.blockedReason === void 0 ? {} : { blockedReason: state.blockedReason }
1553
+ ...mutableHalfOf(state)
1509
1554
  };
1510
1555
  };
1556
+ var pageRfqRecords = (records, filter, page) => {
1557
+ const rows = records.filter(
1558
+ (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)
1559
+ ).sort(
1560
+ (a, b) => a.updatedAt - b.updatedAt || (a.rfqId < b.rfqId ? -1 : a.rfqId > b.rfqId ? 1 : 0)
1561
+ ).slice(0, page.limit + 1);
1562
+ return pageResult(rows, page.limit, (record) => ({
1563
+ updatedAt: record.updatedAt,
1564
+ rfqId: record.rfqId
1565
+ }));
1566
+ };
1511
1567
  var corridorRecordStore = (repository, onRecord = () => {
1512
1568
  }, admits = () => true) => {
1513
1569
  const byRfqId = /* @__PURE__ */ new Map();
@@ -1520,7 +1576,7 @@ var corridorRecordStore = (repository, onRecord = () => {
1520
1576
  const record = await repository.getSwapRecord(known);
1521
1577
  if (record?.family === "rfq") return record;
1522
1578
  }
1523
- const { corridor } = splitRecords(await repository.getAllSwapRecords());
1579
+ const { corridor } = splitRecords(await collectSwapRecords(repository));
1524
1580
  for (const record of corridor) index(record);
1525
1581
  const found = byRfqId.get(rfqId);
1526
1582
  return found === void 0 ? void 0 : corridor.find((r) => r.id === found);
@@ -1528,10 +1584,12 @@ var corridorRecordStore = (repository, onRecord = () => {
1528
1584
  return {
1529
1585
  index,
1530
1586
  quoteIdOf: (rfqId) => byRfqId.get(rfqId),
1531
- async getAllRfqSwaps() {
1532
- const { corridor } = splitRecords(await repository.getAllSwapRecords());
1587
+ async getRfqSwapsPage(filter, page) {
1588
+ assertPageRequest(page);
1589
+ assertRfqSwapPageFilter(filter);
1590
+ const { corridor } = splitRecords(await collectSwapRecords(repository));
1533
1591
  for (const record of corridor) index(record);
1534
- return corridor.filter(admits).map(rfqRecordOf);
1592
+ return pageRfqRecords(corridor.filter(admits).map(rfqRecordOf), filter, page);
1535
1593
  },
1536
1594
  async getRfqSwap(rfqId) {
1537
1595
  const record = await recordFor(rfqId);
@@ -1554,20 +1612,18 @@ var corridorRecordStore = (repository, onRecord = () => {
1554
1612
  };
1555
1613
  var offerFactsOf = (record) => ({
1556
1614
  id: record.id,
1615
+ coverageId: record.id,
1557
1616
  status: record.status,
1558
1617
  offerHex: record.offerHex,
1559
1618
  swapPkScript: record.swapPkScript,
1560
1619
  ...record.fundingTxid === void 0 ? {} : { fundingTxid: record.fundingTxid },
1561
1620
  ...record.spentTxid === void 0 ? {} : { spentTxid: record.spentTxid },
1562
- // Milliseconds: `coverage.ts` marks issuance with `Date.now()`, and a
1563
- // seconds value compared against it leaves every issued script outstanding
1564
- // for the life of the process.
1565
1621
  createdAt: record.createdAt * 1e3
1566
1622
  });
1567
1623
  var offerRecordSource = (repository, onRecord = () => {
1568
1624
  }, now = () => Math.floor(Date.now() / 1e3)) => {
1569
1625
  const list = async () => {
1570
- const { offer } = splitRecords(await repository.getAllSwapRecords());
1626
+ const { offer } = splitRecords(await collectSwapRecords(repository));
1571
1627
  return offer.map(offerFactsOf);
1572
1628
  };
1573
1629
  return {
@@ -1596,12 +1652,93 @@ var applyOfferSpend = (record, changes, now) => ({
1596
1652
  ...record,
1597
1653
  status: changes.status,
1598
1654
  spentTxid: changes.spentTxid,
1599
- // The watcher's `completedAt` comes off a contract event's timestamp, in
1600
- // milliseconds; this record's timestamps are unix seconds.
1655
+ // event timestamps are milliseconds; this record's are unix seconds
1601
1656
  ...changes.completedAt === void 0 ? {} : { completedAt: Math.floor(changes.completedAt / 1e3) },
1602
1657
  updatedAt: now
1603
1658
  });
1604
- var withOfferStatus = (record, status, now) => ({ ...record, status, updatedAt: now });
1659
+ var withDepositFate = (record, fate, now) => ({
1660
+ ...record,
1661
+ status: fate.status,
1662
+ ...fate.spentTxid === void 0 ? {} : { spentTxid: fate.spentTxid },
1663
+ ...fate.completedAt === void 0 ? {} : { completedAt: Math.floor(fate.completedAt / 1e3) },
1664
+ updatedAt: now
1665
+ });
1666
+ var DEPOSIT_SPENT = (status) => status === "cancelled" || status === "fulfilled";
1667
+ var fateMoved = (record, fate) => {
1668
+ if (DEPOSIT_SPENT(record.status) && !DEPOSIT_SPENT(fate.status)) return false;
1669
+ return record.status !== fate.status || fate.spentTxid !== void 0 && record.spentTxid !== fate.spentTxid || fate.completedAt !== void 0 && record.completedAt !== Math.floor(fate.completedAt / 1e3);
1670
+ };
1671
+ var restoredOfferRecord = (swap, network, now) => {
1672
+ const give = restoredAssetId(network, swap.fromAsset);
1673
+ const take = restoredAssetId(network, swap.toAsset);
1674
+ const createdAt = Math.floor(swap.createdAt / 1e3);
1675
+ return withDepositFate(
1676
+ {
1677
+ id: swap.fundingTxid,
1678
+ family: "offer",
1679
+ route: {
1680
+ give: { corridor: "arkade", asset: give, instrument: { kind: "wallet" } },
1681
+ take: { corridor: "arkade", asset: take, instrument: { kind: "wallet" } }
1682
+ },
1683
+ give: { asset: give, amount: toAtomicDecimal(BigInt(swap.fromAmount)) },
1684
+ take: { asset: take, amount: toAtomicDecimal(BigInt(swap.toAmount)) },
1685
+ fee: { asset: take, amount: toAtomicDecimal(0n) },
1686
+ market: { kind: "restored", backend: "feed" },
1687
+ expiresAt: createdAt,
1688
+ status: swap.status,
1689
+ offerHex: swap.offerHex,
1690
+ swapAddress: swap.swapAddress,
1691
+ swapPkScript: swap.swapPkScript,
1692
+ fundingTxid: swap.fundingTxid,
1693
+ createdAt,
1694
+ updatedAt: now
1695
+ },
1696
+ swap,
1697
+ now
1698
+ );
1699
+ };
1700
+ var restoredAssetId = (network, id) => id === BTC_ASSET_ID ? btcOn("arkade", network) : arkadeAsset(network, asset3.AssetId.fromString(id));
1701
+ var RESTORED_CORRIDORS = {
1702
+ lightning_send: ["arkade", "lightning"],
1703
+ lightning_receive: ["lightning", "arkade"],
1704
+ onchain_send: ["arkade", "onchain"],
1705
+ onchain_receive: ["onchain", "arkade"]
1706
+ };
1707
+ var restoredCorridorRecord = (stored, network, refundLocktime) => {
1708
+ const v1 = normalizeRfqSwapRecord(stored);
1709
+ const hashlock = v1.profile.hashlock;
1710
+ const hash = typeof hashlock?.paymentHash === "string" ? hashlock.paymentHash : v1.settlementPreimageHex === void 0 ? void 0 : hex4.encode(sha256(hex4.decode(v1.settlementPreimageHex)));
1711
+ if (hash === void 0) throw new Error(`v1 rfq swap ${v1.rfqId} has no payment hash`);
1712
+ const [giveCorridor, takeCorridor] = RESTORED_CORRIDORS[v1.kind];
1713
+ const give = btcOn(railOfCorridor(giveCorridor), network);
1714
+ const take = btcOn(railOfCorridor(takeCorridor), network);
1715
+ const amount = toAtomicDecimal(BigInt(v1.amount ?? 0));
1716
+ return {
1717
+ id: v1.rfqId,
1718
+ family: "rfq",
1719
+ route: {
1720
+ give: { corridor: giveCorridor, asset: give, instrument: { kind: "wallet" } },
1721
+ take: { corridor: takeCorridor, asset: take, instrument: { kind: "wallet" } }
1722
+ },
1723
+ give: { asset: give, amount },
1724
+ take: { asset: take, amount },
1725
+ fee: { asset: give, amount: toAtomicDecimal(0n) },
1726
+ market: { kind: "restored", backend: "rfq" },
1727
+ expiresAt: v1.createdAt,
1728
+ state: v1.state,
1729
+ kind: v1.kind,
1730
+ rfqId: v1.rfqId,
1731
+ lockupAddress: v1.lockupAddress,
1732
+ lockupPkScript: hex4.encode(ArkAddress3.decode(v1.lockupAddress).pkScript),
1733
+ lock: { hash },
1734
+ refundLocktime,
1735
+ profile: v1.profile,
1736
+ ...v1.fundingTxid === void 0 ? {} : { fundingTxid: v1.fundingTxid },
1737
+ ...mutableHalfOf(v1),
1738
+ createdAt: v1.createdAt,
1739
+ updatedAt: v1.updatedAt
1740
+ };
1741
+ };
1605
1742
  var walletLockupIndexer = (wallet) => {
1606
1743
  let reader;
1607
1744
  const reading = () => reader ??= wallet.getArkadeReader();
@@ -1617,17 +1754,14 @@ var walletLockupIndexer = (wallet) => {
1617
1754
  };
1618
1755
 
1619
1756
  // src/client/cancel.ts
1620
- import { base64, hex as hex3 } from "@scure/base";
1621
- import { ArkAddress as ArkAddress2, Transaction } from "@arkade-os/sdk";
1622
- var OFFER_TERMINAL = (record) => record.status === "cancelled" || record.status === "fulfilled";
1757
+ import { base64, hex as hex5 } from "@scure/base";
1758
+ import { ArkAddress as ArkAddress4, Transaction } from "@arkade-os/sdk";
1623
1759
  var cancelSwap = async (input) => {
1624
1760
  const { wallet, repository, record, drive, indexer } = input;
1625
1761
  const now = input.now ?? (() => Math.floor(Date.now() / 1e3));
1626
- if (OFFER_TERMINAL(record)) {
1627
- return { outcome: record.status === "cancelled" ? "cancelled" : "filled" };
1628
- }
1629
- if (offerOutcome(record.status) === "needs_recovery") {
1630
- return { outcome: "needs_recovery" };
1762
+ const outcome = offerOutcome(record.status);
1763
+ if (outcome === "cancelled" || outcome === "filled" || outcome === "needs_recovery") {
1764
+ return { outcome };
1631
1765
  }
1632
1766
  const gated2 = withStatus(record, "cancelling", now());
1633
1767
  await repository.saveSwapRecord(gated2);
@@ -1652,7 +1786,7 @@ var cancelSwap = async (input) => {
1652
1786
  drive.ingest(rolledBack);
1653
1787
  throw error;
1654
1788
  }
1655
- if (isMissingVtxo(error)) {
1789
+ if (error instanceof NoSpendableDepositError) {
1656
1790
  const reconciled = await reconcileDepositSpend(record, indexer);
1657
1791
  if (reconciled === void 0) {
1658
1792
  return { outcome: "needs_recovery" };
@@ -1681,7 +1815,7 @@ var cancelSwap = async (input) => {
1681
1815
  return { outcome: "cancelled" };
1682
1816
  };
1683
1817
  var reconcileDepositSpend = async (record, indexer) => {
1684
- const offer = decodeOffer(hex3.decode(record.offerHex));
1818
+ const offer = decodeOffer(hex5.decode(record.offerHex));
1685
1819
  const { vtxos } = await indexer.getVtxos({ scripts: [record.swapPkScript] });
1686
1820
  const all = vtxos ?? [];
1687
1821
  const deposit = record.fundingTxid === void 0 ? all.length === 1 ? all[0] : void 0 : all.find((vtxo) => vtxo.txid === record.fundingTxid);
@@ -1698,7 +1832,7 @@ var reconcileDepositSpend = async (record, indexer) => {
1698
1832
  return void 0;
1699
1833
  }
1700
1834
  }).filter((tx) => tx !== void 0);
1701
- const operatorPubkey = ArkAddress2.decode(record.swapAddress).serverPubKey;
1835
+ const operatorPubkey = ArkAddress4.decode(record.swapAddress).serverPubKey;
1702
1836
  const kind = classifyDepositSpend(offer, operatorPubkey, parsed, {
1703
1837
  txid: deposit.txid,
1704
1838
  vout: deposit.vout
@@ -1724,70 +1858,293 @@ var persistBestEffort = async (repository, record) => {
1724
1858
  };
1725
1859
  var retireOfferScripts = async (wallet, repository, record) => {
1726
1860
  try {
1727
- const { offer } = splitRecords(await repository.getAllSwapRecords());
1861
+ const { offer } = splitRecords(await collectSwapRecords(repository));
1728
1862
  await retireOfferContract(
1729
1863
  await wallet.getContractManager(),
1730
1864
  offer.map(offerFactsOf),
1731
- record.swapPkScript
1865
+ record.swapPkScript,
1866
+ { scope: wallet }
1732
1867
  );
1733
1868
  } catch (error) {
1734
1869
  console.warn(`[swap] could not retire offer script for ${record.id}`, error);
1735
1870
  }
1736
1871
  };
1737
- var isMissingVtxo = (error) => error instanceof NoSpendableDepositError;
1738
1872
 
1739
1873
  // src/client/drive.ts
1740
1874
  import {
1741
- ArkAddress as ArkAddress3,
1875
+ ArkAddress as ArkAddress5,
1742
1876
  contractSigner,
1877
+ getNetwork as getNetwork2,
1743
1878
  identityDescriptor
1744
1879
  } from "@arkade-os/sdk";
1745
- import { hex as hex4 } from "@scure/base";
1746
- var SwapDriveRefusedError = class extends Error {
1747
- constructor(reason, detail, swapId) {
1748
- super(detail);
1749
- this.reason = reason;
1750
- this.swapId = swapId;
1880
+ import { hex as hex6 } from "@scure/base";
1881
+
1882
+ // src/migrateOfferRows.ts
1883
+ import { arkade } from "@arkade-os/sdk";
1884
+
1885
+ // src/legacy/swap-want-asset.program.v0.json
1886
+ var swap_want_asset_program_v0_default = {
1887
+ version: 0,
1888
+ name: "banco-btc-to-asset",
1889
+ params: [
1890
+ { name: "makerWP", type: "pubkey" },
1891
+ { name: "wantAmount", type: "int" },
1892
+ { name: "wantAssetTxid", type: "hash" },
1893
+ { name: "wantAssetGroupIndex", type: "int" },
1894
+ { name: "server", type: "pubkey" },
1895
+ { name: "user", type: "pubkey" }
1896
+ ],
1897
+ functions: {
1898
+ fulfill: {
1899
+ tapscript: { signers: ["$server"] },
1900
+ arkadeScript: {
1901
+ asm: [
1902
+ 0,
1903
+ "$wantAssetTxid",
1904
+ "$wantAssetGroupIndex",
1905
+ "INSPECTOUTASSETLOOKUP",
1906
+ "VERIFY",
1907
+ "$wantAmount",
1908
+ "GREATERTHANOREQUAL",
1909
+ "VERIFY",
1910
+ 0,
1911
+ "INSPECTOUTPUTSCRIPTPUBKEY",
1912
+ 1,
1913
+ "EQUALVERIFY",
1914
+ "$makerWP",
1915
+ "EQUAL"
1916
+ ]
1917
+ }
1918
+ },
1919
+ cancel: {
1920
+ tapscript: { signers: ["$user", "$server"] }
1921
+ }
1751
1922
  }
1752
- reason;
1753
- swapId;
1754
- name = "SwapDriveRefusedError";
1755
1923
  };
1756
- var OFFER_LIVE = (status) => status === "pending" || status === "cancelling";
1757
- var traderClaimTxid = (swap) => swap.kind === "lightning_send" ? void 0 : swap.claimTxid;
1758
- var readableRecord = (record) => {
1759
- if (typeof record?.id !== "string" || record.route?.give === void 0) return false;
1760
- if (record.family === "rfq") {
1761
- return typeof record.rfqId === "string" && typeof record.lockupAddress === "string";
1924
+
1925
+ // src/legacy/swap-want-btc.program.v0.json
1926
+ var swap_want_btc_program_v0_default = {
1927
+ version: 0,
1928
+ name: "banco-asset-to-btc",
1929
+ params: [
1930
+ { name: "makerWP", type: "pubkey" },
1931
+ { name: "wantAmount", type: "int" },
1932
+ { name: "server", type: "pubkey" },
1933
+ { name: "user", type: "pubkey" }
1934
+ ],
1935
+ functions: {
1936
+ fulfill: {
1937
+ tapscript: { signers: ["$server"] },
1938
+ arkadeScript: {
1939
+ asm: [
1940
+ 0,
1941
+ "INSPECTOUTPUTVALUE",
1942
+ "$wantAmount",
1943
+ "GREATERTHANOREQUAL",
1944
+ "VERIFY",
1945
+ 0,
1946
+ "INSPECTOUTPUTSCRIPTPUBKEY",
1947
+ 1,
1948
+ "EQUALVERIFY",
1949
+ "$makerWP",
1950
+ "EQUAL"
1951
+ ]
1952
+ }
1953
+ },
1954
+ cancel: {
1955
+ tapscript: { signers: ["$user", "$server"] }
1956
+ }
1762
1957
  }
1763
- return record.family === "offer" && typeof record.offerHex === "string";
1764
1958
  };
1765
- var createSwapDrive = (config) => {
1766
- const { wallet, operator, repository, corridors, indexer } = config;
1767
- const mode = config.mode ?? "auto";
1768
- const now = config.now ?? (() => Math.floor(Date.now() / 1e3));
1769
- const records = /* @__PURE__ */ new Map();
1770
- const live = /* @__PURE__ */ new Map();
1771
- const refunding = /* @__PURE__ */ new Set();
1772
- const swept = /* @__PURE__ */ new Map();
1773
- const passed = /* @__PURE__ */ new Set();
1774
- const delivered = /* @__PURE__ */ new Map();
1775
- const listeners = /* @__PURE__ */ new Set();
1776
- let disposed = false;
1777
- let startRequested = mode === "auto";
1778
- let watcher;
1779
- let readyPromise;
1780
- const inFlight = /* @__PURE__ */ new Set();
1781
- let queue = Promise.resolve();
1782
- const track = (work) => {
1783
- inFlight.add(work);
1784
- void work.then(
1785
- () => inFlight.delete(work),
1786
- () => inFlight.delete(work)
1787
- );
1788
- return work;
1959
+
1960
+ // src/migrateOfferRows.ts
1961
+ function withExitV0(program, exit) {
1962
+ if (!exit) return program;
1963
+ return {
1964
+ ...program,
1965
+ params: [...program.params, { name: "exitDelay", type: "int" }],
1966
+ functions: {
1967
+ ...program.functions,
1968
+ exit: { tapscript: { signers: ["$user"], csv: { type: exit, value: "$exitDelay" } } }
1969
+ }
1789
1970
  };
1790
- const enqueue = (task) => {
1971
+ }
1972
+ var V0_TO_V1 = /* @__PURE__ */ new Map();
1973
+ for (const [v0, v1] of [
1974
+ [swap_want_btc_program_v0_default, swapPrograms.wantBtc],
1975
+ [swap_want_asset_program_v0_default, swapPrograms.wantAsset]
1976
+ ]) {
1977
+ for (const exit of [void 0, "blocks", "seconds"]) {
1978
+ const timelock = exit && { type: exit, value: BigInt(0) };
1979
+ V0_TO_V1.set(
1980
+ JSON.stringify(withExitV0(v0, exit)),
1981
+ arkade.stringifyArtifact(withExitClosure(v1, timelock))
1982
+ );
1983
+ }
1984
+ }
1985
+ async function migrateV0OfferRows(contractManager) {
1986
+ const migrated = [];
1987
+ const skipped = [];
1988
+ for (const row of await contractManager.getUnsupportedContracts()) {
1989
+ if (row.type !== "arkade" || row.metadata?.kind !== OFFER_CONTRACT_KIND) continue;
1990
+ const program = V0_TO_V1.get(row.params.program);
1991
+ if (!program) {
1992
+ skipped.push({ script: row.script, reason: "not a bundled Program v0 offer" });
1993
+ continue;
1994
+ }
1995
+ try {
1996
+ await contractManager.createContract({
1997
+ type: row.type,
1998
+ script: row.script,
1999
+ address: row.address,
2000
+ params: { ...row.params, program },
2001
+ label: row.label,
2002
+ metadata: row.metadata
2003
+ });
2004
+ migrated.push(row.script);
2005
+ } catch (error) {
2006
+ skipped.push({
2007
+ script: row.script,
2008
+ reason: error instanceof Error ? error.message : String(error)
2009
+ });
2010
+ }
2011
+ }
2012
+ return { migrated, skipped };
2013
+ }
2014
+
2015
+ // src/client/legacyRecords.ts
2016
+ import { assertPageRequest as assertPageRequest2 } from "@arkade-os/sdk";
2017
+ var readLegacyRfqSwaps = async (repository, filter = {}) => {
2018
+ try {
2019
+ return await collectRfqSwaps(repository, filter);
2020
+ } catch (error) {
2021
+ console.warn("[swap] the v1 rfq swaps could not be read", error);
2022
+ return [];
2023
+ }
2024
+ };
2025
+ var legacyLiveRfqSwaps = async (repository) => (await readLegacyRfqSwaps(repository)).filter((record) => !isRfqSwapTerminal(record.state));
2026
+ var withLegacyRfqSwaps = (bridge, repository, admits) => {
2027
+ const legacy = /* @__PURE__ */ new Set();
2028
+ return {
2029
+ index: bridge.index,
2030
+ quoteIdOf: bridge.quoteIdOf,
2031
+ async getRfqSwapsPage(filter, page) {
2032
+ assertPageRequest2(page);
2033
+ assertRfqSwapPageFilter(filter);
2034
+ const v2 = await collectRfqSwaps(bridge, filter);
2035
+ const held = new Set(
2036
+ splitRecords(await collectSwapRecords(repository)).corridor.map((r) => r.rfqId)
2037
+ );
2038
+ const v1 = (await readLegacyRfqSwaps(repository, filter)).filter(
2039
+ (record) => !held.has(record.rfqId) && admits(record)
2040
+ );
2041
+ for (const record of v1) legacy.add(record.rfqId);
2042
+ return pageRfqRecords([...v2, ...v1], filter, page);
2043
+ },
2044
+ async getRfqSwap(rfqId) {
2045
+ if (!legacy.has(rfqId)) {
2046
+ const record2 = await bridge.getRfqSwap(rfqId);
2047
+ if (record2 !== void 0) return record2;
2048
+ }
2049
+ const record = await repository.getRfqSwap(rfqId);
2050
+ if (record !== void 0) legacy.add(rfqId);
2051
+ return record;
2052
+ },
2053
+ async saveRfqSwap(record) {
2054
+ if (legacy.has(record.rfqId)) await repository.saveRfqSwap(record);
2055
+ else await bridge.saveRfqSwap(record);
2056
+ },
2057
+ removeRfqSwap: (rfqId) => bridge.removeRfqSwap(rfqId)
2058
+ };
2059
+ };
2060
+ var legacyRfqSwapsToAdopt = async (repository) => {
2061
+ const v1 = await readLegacyRfqSwaps(repository);
2062
+ if (v1.length === 0) return [];
2063
+ const records = await collectSwapRecords(repository);
2064
+ const held = new Set(splitRecords(records).corridor.map((record) => record.rfqId));
2065
+ const ids = new Set(records.map((record) => record.id));
2066
+ return v1.filter((record) => {
2067
+ if (held.has(record.rfqId)) return false;
2068
+ if (ids.has(record.rfqId)) {
2069
+ console.warn(`[swap] v1 rfq swap ${record.rfqId} collides with a v2 record id`);
2070
+ return false;
2071
+ }
2072
+ return true;
2073
+ });
2074
+ };
2075
+ var readLegacyAssetSwaps = async (repository) => {
2076
+ try {
2077
+ return await collectAssetSwaps(repository);
2078
+ } catch (error) {
2079
+ console.warn("[swap] the v1 swaps could not be read", error);
2080
+ return [];
2081
+ }
2082
+ };
2083
+ var legacyOfferDepositsToAdopt = async (repository) => {
2084
+ const unadopted = (await readLegacyAssetSwaps(repository)).filter(
2085
+ (swap) => !!swap.offerHex && !!swap.fundingTxid
2086
+ );
2087
+ if (unadopted.length === 0) return /* @__PURE__ */ new Set();
2088
+ const { offer } = splitRecords(await collectSwapRecords(repository));
2089
+ const adopted = new Set(offer.map((record) => record.fundingTxid));
2090
+ return new Set(unadopted.map((swap) => swap.fundingTxid).filter((txid) => !adopted.has(txid)));
2091
+ };
2092
+
2093
+ // src/client/drive.ts
2094
+ var SwapDriveRefusedError = class extends Error {
2095
+ constructor(reason, detail, swapId) {
2096
+ super(detail);
2097
+ this.reason = reason;
2098
+ this.swapId = swapId;
2099
+ }
2100
+ reason;
2101
+ swapId;
2102
+ name = "SwapDriveRefusedError";
2103
+ };
2104
+ var OFFER_LIVE = (status) => status === "pending" || status === "cancelling";
2105
+ var traderClaimTxid = (swap) => swap.kind === "lightning_send" ? void 0 : swap.claimTxid;
2106
+ var readableRecord = (record) => {
2107
+ if (typeof record?.id !== "string" || record.route?.give === void 0) return false;
2108
+ if (record.assetPayment !== void 0) {
2109
+ try {
2110
+ assetPaymentOf(record.assetPayment, record.expiresAt);
2111
+ } catch {
2112
+ return false;
2113
+ }
2114
+ }
2115
+ if (record.family === "rfq") {
2116
+ return typeof record.rfqId === "string" && typeof record.lockupAddress === "string";
2117
+ }
2118
+ return record.family === "offer" && typeof record.offerHex === "string";
2119
+ };
2120
+ var createSwapDrive = (config) => {
2121
+ const { wallet, operator, repository, corridors, indexer } = config;
2122
+ const mode = config.mode ?? "auto";
2123
+ const now = config.now ?? (() => Math.floor(Date.now() / 1e3));
2124
+ const records = /* @__PURE__ */ new Map();
2125
+ const live = /* @__PURE__ */ new Map();
2126
+ const refunding = /* @__PURE__ */ new Set();
2127
+ const swept = /* @__PURE__ */ new Map();
2128
+ const recoveredIn = /* @__PURE__ */ new Set();
2129
+ const passed = /* @__PURE__ */ new Set();
2130
+ const delivered = /* @__PURE__ */ new Map();
2131
+ const listeners = /* @__PURE__ */ new Set();
2132
+ let disposed = false;
2133
+ let startRequested = mode === "auto";
2134
+ let watcher;
2135
+ let readyPromise;
2136
+ const inFlight = /* @__PURE__ */ new Set();
2137
+ let queue = Promise.resolve();
2138
+ let recheck;
2139
+ const track = (work) => {
2140
+ inFlight.add(work);
2141
+ void work.then(
2142
+ () => inFlight.delete(work),
2143
+ () => inFlight.delete(work)
2144
+ );
2145
+ return work;
2146
+ };
2147
+ const enqueue = (task) => {
1791
2148
  queue = queue.then(task).catch((error) => {
1792
2149
  console.warn("[swap] the drive could not register a swap", error);
1793
2150
  });
@@ -1796,6 +2153,7 @@ var createSwapDrive = (config) => {
1796
2153
  do {
1797
2154
  await queue;
1798
2155
  await Promise.allSettled([...inFlight]);
2156
+ if (!disposed) await recheck;
1799
2157
  await watcher?.idle();
1800
2158
  } while (inFlight.size > 0);
1801
2159
  };
@@ -1808,20 +2166,23 @@ var createSwapDrive = (config) => {
1808
2166
  return repository;
1809
2167
  };
1810
2168
  const undrivable = /* @__PURE__ */ new Set();
2169
+ const undrivableLegacy = /* @__PURE__ */ new Set();
1811
2170
  let bridge;
1812
- const corridorStore = () => bridge ??= corridorRecordStore(
1813
- storage(),
1814
- remember,
1815
- // Terminal records are readable but never driven: excluding them
1816
- // here is what keeps `restoreFromRepository` from rebuilding each
1817
- // one — a covenant derivation and a contract row lookup per
1818
- // record — only to file it in the manager's `finished` set. The
1819
- // exclusion is on the manager's read, not the record: the drive's
1820
- // own `records` registry keeps every readable record, and the
1821
- // index still learns an excluded record's `rfqId` (see
1822
- // `getAllRfqSwaps`), so a consumer handing its swap to the manager
1823
- // directly keeps resolving.
1824
- (r) => !undrivable.has(r.id) && !isRfqSwapTerminal(r.state)
2171
+ let readThrough;
2172
+ const corridorStore = () => (
2173
+ // LEGACY(v1): unwrap to `bridge` alone once the read-through goes.
2174
+ readThrough ??= withLegacyRfqSwaps(
2175
+ bridge ??= corridorRecordStore(
2176
+ storage(),
2177
+ remember,
2178
+ // Terminal records stay readable but are excluded from the manager's read, sparing
2179
+ // a rebuild per record just to file it `finished`, except a refunded send restore
2180
+ // re-reads. The index still learns their `rfqId` (see `getRfqSwapsPage`).
2181
+ (r) => !undrivable.has(r.id) && isRfqSwapRestorable(r)
2182
+ ),
2183
+ storage(),
2184
+ (r) => !undrivableLegacy.has(r.rfqId) && isRfqSwapRestorable(r)
2185
+ )
1825
2186
  );
1826
2187
  const effectiveState = (swap) => {
1827
2188
  if (mode === "auto") return swap.state;
@@ -1830,6 +2191,7 @@ var createSwapDrive = (config) => {
1830
2191
  return traderClaimTxid(swap) ? "claimed" : "pending";
1831
2192
  };
1832
2193
  const outcomeOfEntry = (record, current) => {
2194
+ if (fundingWasNotSubmitted(record)) return "cancelled";
1833
2195
  if (record.family === "offer") return recordOutcome(record);
1834
2196
  if (current === void 0) {
1835
2197
  if (isRfqSwapTerminal(record.state)) return corridorOutcome(record.kind, record.state);
@@ -1857,7 +2219,7 @@ var createSwapDrive = (config) => {
1857
2219
  };
1858
2220
  const updateFor = (id) => {
1859
2221
  const record = records.get(id);
1860
- if (record === void 0) return void 0;
2222
+ if (record === void 0 || !readableRecord(record)) return void 0;
1861
2223
  const current = live.get(id);
1862
2224
  const outcome = outcomeOfEntry(record, current);
1863
2225
  return {
@@ -1907,8 +2269,15 @@ var createSwapDrive = (config) => {
1907
2269
  touch(swap.rfqId, swap);
1908
2270
  });
1909
2271
  let onchainSeams;
2272
+ const liveFeeRate = async (chain) => {
2273
+ try {
2274
+ return await chain.getFeeRate?.();
2275
+ } catch {
2276
+ return void 0;
2277
+ }
2278
+ };
1910
2279
  const defaultOnchainClaim = (chain, feeRateSatVb) => {
1911
- return async (swap, utxo) => {
2280
+ return async (swap, utxo, options) => {
1912
2281
  const record = await corridorStore().getRfqSwap(swap.rfqId);
1913
2282
  if (!record) {
1914
2283
  throw new Error(`rfq swap ${swap.rfqId} has no stored record to claim from`);
@@ -1919,7 +2288,7 @@ var createSwapDrive = (config) => {
1919
2288
  const signer = await contractSigner(wallet, await identityDescriptor(wallet.identity));
1920
2289
  const claimKey = record.profile.claimKey;
1921
2290
  if (typeof claimKey === "string") {
1922
- const held = hex4.encode(await signer.xOnlyPublicKey());
2291
+ const held = hex6.encode(await signer.xOnlyPublicKey());
1923
2292
  if (held !== claimKey) {
1924
2293
  throw new Error(
1925
2294
  `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`
@@ -1929,17 +2298,54 @@ var createSwapDrive = (config) => {
1929
2298
  if (!swap.payoutPkScript) {
1930
2299
  throw new Error(`rfq swap ${swap.rfqId} carries no claim payout script`);
1931
2300
  }
2301
+ const rate = nextClaimFeeRate({
2302
+ configuredSatVb: feeRateSatVb,
2303
+ utxoAmount: utxo.amount,
2304
+ estimateSatVb: await liveFeeRate(chain),
2305
+ ...swap.claimFeeRateSatVb === void 0 ? {} : { lastSatVb: swap.claimFeeRateSatVb },
2306
+ ...options?.bump ? { bump: true } : {}
2307
+ });
1932
2308
  const { txid } = await track(
1933
2309
  claimOnchainFill(chain, {
1934
2310
  htlc: swap.htlc,
1935
2311
  utxo,
1936
2312
  preimage,
1937
2313
  payoutPkScript: swap.payoutPkScript,
1938
- feeRateSatVb,
1939
- sign: (sighash) => signer.signMessage(sighash, "schnorr")
2314
+ feeRateSatVb: rate,
2315
+ sign: (sighash) => signer.signMessage(sighash, "schnorr"),
2316
+ ...swap.claimTxid ? { republish: true } : {}
1940
2317
  })
1941
2318
  );
1942
- return { txid };
2319
+ return { txid, feeRateSatVb: rate };
2320
+ };
2321
+ };
2322
+ const defaultOnchainRefund = (chain, feeRateSatVb) => {
2323
+ return async (swap, utxo) => {
2324
+ const record = await corridorStore().getRfqSwap(swap.rfqId);
2325
+ if (!record) {
2326
+ throw new Error(`rfq swap ${swap.rfqId} has no stored record to refund from`);
2327
+ }
2328
+ const descriptor = record.profile.refundDescriptor;
2329
+ if (typeof descriptor !== "string") {
2330
+ throw new Error(
2331
+ `rfq swap ${swap.rfqId} carries no refund descriptor; wire the onchain corridor's refund callback to take its L1 funding back`
2332
+ );
2333
+ }
2334
+ const signer = await contractSigner(wallet, descriptor);
2335
+ const held = hex6.encode(await signer.xOnlyPublicKey());
2336
+ if (held !== record.profile.refundKey) {
2337
+ throw new Error(
2338
+ `the key behind ${descriptor} is ${held}, not the refund key ${String(record.profile.refundKey)} rfq swap ${swap.rfqId}'s HTLC was derived with`
2339
+ );
2340
+ }
2341
+ const { txHex } = await buildHtlcRefund({
2342
+ htlc: swap.htlc,
2343
+ utxo,
2344
+ payoutPkScript: swap.refundPkScript,
2345
+ feeRateSatVb,
2346
+ sign: (sighash) => signer.signMessage(sighash, "schnorr")
2347
+ });
2348
+ return { txid: await track(chain.broadcast(txHex)) };
1943
2349
  };
1944
2350
  };
1945
2351
  const resolveOnchain = async () => {
@@ -1947,7 +2353,12 @@ var createSwapDrive = (config) => {
1947
2353
  try {
1948
2354
  const deps = (await corridors()).get("onchain").deps;
1949
2355
  const claim = deps.claim ?? (deps.claimFeeRateSatVb === void 0 ? void 0 : defaultOnchainClaim(deps.chain, deps.claimFeeRateSatVb));
1950
- onchainSeams = { chain: deps.chain, ...claim ? { claim } : {} };
2356
+ const refund = deps.refund ?? (deps.claimFeeRateSatVb === void 0 ? void 0 : defaultOnchainRefund(deps.chain, deps.claimFeeRateSatVb));
2357
+ onchainSeams = {
2358
+ chain: deps.chain,
2359
+ ...claim ? { claim } : {},
2360
+ ...refund ? { refund } : {}
2361
+ };
1951
2362
  managerDeps.chain = deps.chain;
1952
2363
  return true;
1953
2364
  } catch (error) {
@@ -1960,6 +2371,7 @@ var createSwapDrive = (config) => {
1960
2371
  }
1961
2372
  };
1962
2373
  const drivable = async (record) => !readsChain(record.kind) || await resolveOnchain();
2374
+ const pinnedNetwork = async () => getNetwork2(await config.network());
1963
2375
  const claimLockup = async (swap, vtxos, { partiallyClaimed }) => {
1964
2376
  const record = await corridorStore().getRfqSwap(swap.rfqId);
1965
2377
  if (!record) throw new Error(`rfq swap ${swap.rfqId} has no stored record to claim from`);
@@ -1977,13 +2389,11 @@ var createSwapDrive = (config) => {
1977
2389
  receiver: await contractSigner(wallet, secret.signingDescriptor),
1978
2390
  preimage: await preimageForSwapRecord(wallet, secret),
1979
2391
  vtxos,
1980
- destinationPkScript: ArkAddress3.decode(payoutAddress).pkScript,
1981
- // Passed straight through, both of them: the manager's own value
1982
- // check decides WHEN to act, `pushClaim`'s decides whether `P` is
1983
- // published, and it is the one with nothing between it and the
1984
- // signature.
2392
+ destinationPkScript: ArkAddress5.decode(payoutAddress).pkScript,
2393
+ // Passed through: `pushClaim`'s own value check decides whether `P` is published.
1985
2394
  expectedAmount: swap.expectedAmount,
1986
- partiallyClaimed
2395
+ partiallyClaimed,
2396
+ network: await pinnedNetwork()
1987
2397
  })
1988
2398
  );
1989
2399
  };
@@ -2010,9 +2420,10 @@ var createSwapDrive = (config) => {
2010
2420
  if (mode === "readonly") return;
2011
2421
  const push = arkadeRefunder({
2012
2422
  operator,
2013
- indexer,
2423
+ contracts: lockupSource,
2014
2424
  wallet,
2015
- repository: corridorStore()
2425
+ repository: corridorStore(),
2426
+ network: pinnedNetwork
2016
2427
  });
2017
2428
  manager.setCallbacks({
2018
2429
  refundArkade: async (swap) => {
@@ -2031,56 +2442,83 @@ var createSwapDrive = (config) => {
2031
2442
  },
2032
2443
  canRefundArkade,
2033
2444
  claimLockup,
2034
- ...onchainSeams?.claim ? { claimOnchain: onchainSeams.claim } : {}
2445
+ ...onchainSeams?.claim ? { claimOnchain: onchainSeams.claim } : {},
2446
+ ...onchainSeams?.refund ? { refundOnchain: onchainSeams.refund } : {}
2035
2447
  });
2036
2448
  };
2037
2449
  let offerSource;
2038
2450
  const offers = () => offerSource ??= offerRecordSource(storage(), remember, now);
2039
- const sweepOfferDeposits = async (offer) => {
2040
- const funded = offer.filter(
2041
- (record) => record.fundingTxid !== void 0 && !RETIRABLE.includes(record.status)
2042
- );
2043
- if (funded.length === 0) return;
2451
+ const restoreOfferDeposits = async (reopen = []) => {
2044
2452
  const store = storage();
2045
- const [history, scanned, address] = await Promise.all([
2453
+ const [history, scanned, address, network] = await Promise.all([
2046
2454
  wallet.getTransactionHistory(),
2047
2455
  store.getScannedTxids(),
2048
- wallet.getAddress()
2456
+ wallet.getAddress(),
2457
+ config.network()
2049
2458
  ]);
2050
- const txs = history.map((tx) => ({
2051
- // `TxType` is `"SENT"`/`"RECEIVED"`; the scan filters on `"sent"`.
2052
- type: String(tx.type).toLowerCase(),
2053
- redeemTxid: tx.key.arkTxid,
2054
- ...tx.key.boardingTxid ? { boardingTxid: tx.key.boardingTxid } : {},
2055
- ...tx.key.commitmentTxid ? { roundTxid: tx.key.commitmentTxid } : {},
2056
- // The scan reads unix SECONDS; a wallet transaction carries ms.
2057
- ...tx.createdAt ? { createdAt: Math.floor(tx.createdAt / 1e3) } : {}
2058
- }));
2459
+ const txs = history.map(toRestoreTx);
2460
+ const { hrp, serverPubKey: operatorPubkey } = ArkAddress5.decode(address);
2461
+ const reopened = await legacyOfferDepositsToAdopt(store);
2462
+ for (const txid of reopen) reopened.add(txid);
2463
+ const cursor = reopened.size === 0 ? scanned : new Set([...scanned].filter((txid) => !reopened.has(txid)));
2059
2464
  const { restored, scannedTxids } = await restoreAssetSwaps(indexer, txs, /* @__PURE__ */ new Set(), {
2060
- operatorPubkey: ArkAddress3.decode(address).serverPubKey,
2061
- scanned
2465
+ operatorPubkey,
2466
+ scanned: cursor,
2467
+ hrp,
2468
+ recoveredIn
2062
2469
  });
2063
- const byDeposit = new Map(restored.map((s) => [`${s.swapPkScript}:${s.fundingTxid}`, s]));
2064
- const stillLive = /* @__PURE__ */ new Set();
2065
- for (const record of funded) {
2066
- const found = byDeposit.get(`${record.swapPkScript}:${record.fundingTxid}`);
2067
- const status = found?.status ?? record.status;
2068
- if (status !== record.status) {
2069
- const updated = withOfferStatus(record, status, now());
2070
- await store.saveSwapRecord(updated);
2071
- remember(updated);
2470
+ const { offer } = splitRecords(await collectSwapRecords(store));
2471
+ const current = new Map(offer.map((record) => [record.id, record]));
2472
+ const byDeposit = new Map(
2473
+ offer.filter((record) => record.fundingTxid !== void 0).map((record) => [`${record.swapPkScript}:${record.fundingTxid}`, record])
2474
+ );
2475
+ const unstamped = /* @__PURE__ */ new Map();
2476
+ for (const record of offer) {
2477
+ if (record.fundingTxid !== void 0 || !OFFER_LIVE(record.status)) continue;
2478
+ unstamped.set(record.swapPkScript, [
2479
+ ...unstamped.get(record.swapPkScript) ?? [],
2480
+ record
2481
+ ]);
2482
+ }
2483
+ const write = async (record) => {
2484
+ await store.saveSwapRecord(record);
2485
+ current.set(record.id, record);
2486
+ remember(record);
2487
+ };
2488
+ for (const found of restored) {
2489
+ const known = byDeposit.get(`${found.swapPkScript}:${found.fundingTxid}`);
2490
+ if (known !== void 0) {
2491
+ if (fateMoved(known, found)) await write(withDepositFate(known, found, now()));
2492
+ continue;
2072
2493
  }
2073
- if (OFFER_LIVE(status) && record.fundingTxid) stillLive.add(record.fundingTxid);
2494
+ const orphan = unstamped.get(found.swapPkScript)?.shift();
2495
+ if (orphan !== void 0) {
2496
+ await write(
2497
+ withDepositFate({ ...orphan, fundingTxid: found.fundingTxid }, found, now())
2498
+ );
2499
+ continue;
2500
+ }
2501
+ await write(restoredOfferRecord(found, network, now()));
2502
+ }
2503
+ const stillLive = /* @__PURE__ */ new Set();
2504
+ for (const record of current.values()) {
2505
+ if (OFFER_LIVE(record.status) && record.fundingTxid) stillLive.add(record.fundingTxid);
2074
2506
  }
2075
2507
  await store.markTxidsScanned(scannedTxids.filter((txid) => !stillLive.has(txid)));
2076
2508
  const registry = managerDeps.contracts;
2077
2509
  if (registry) {
2078
- const { offer: current } = splitRecords(await store.getAllSwapRecords());
2079
- await retireSettledOfferContracts(registry, current.map(offerFactsOf));
2510
+ await retireSettledOfferContracts(registry, [...current.values()].map(offerFactsOf), {
2511
+ scope: wallet
2512
+ });
2080
2513
  }
2514
+ return [...current.values()];
2081
2515
  };
2082
2516
  const contractsOf = async () => managerDeps.contracts ??= await wallet.getContractManager();
2517
+ const lockupSource = {
2518
+ getContractsWithVtxos: async (filter) => (await contractsOf()).getContractsWithVtxos(filter)
2519
+ };
2083
2520
  const registerCorridorSwap = async (record) => {
2521
+ if (fundingWasNotSubmitted(record)) return;
2084
2522
  if (mode === "readonly") return;
2085
2523
  if (!await drivable(record)) {
2086
2524
  undrivable.add(record.id);
@@ -2112,7 +2550,7 @@ var createSwapDrive = (config) => {
2112
2550
  wireCallbacks();
2113
2551
  await manager.start();
2114
2552
  await markPassed();
2115
- if (!watcher && repository) {
2553
+ if (!watcher) {
2116
2554
  watcher = await watchOfferSwaps({
2117
2555
  wallet,
2118
2556
  source: offers(),
@@ -2120,20 +2558,91 @@ var createSwapDrive = (config) => {
2120
2558
  });
2121
2559
  }
2122
2560
  };
2561
+ const registerRestoredOffers = async (offers2) => {
2562
+ if (mode === "readonly") return;
2563
+ const live2 = offers2.filter(
2564
+ (record) => record.fundingTxid !== void 0 && !RETIRABLE.includes(record.status)
2565
+ );
2566
+ if (live2.length === 0) return;
2567
+ try {
2568
+ await restoreOfferCoverage(wallet, live2.map(offerFactsOf));
2569
+ } catch (error) {
2570
+ console.warn("[swap] could not register restored offer covenants", error);
2571
+ }
2572
+ };
2573
+ const adoptLegacyRfqSwaps = async (store) => {
2574
+ try {
2575
+ const toAdopt = await legacyRfqSwapsToAdopt(store);
2576
+ if (toAdopt.length === 0) return;
2577
+ const network = await config.network();
2578
+ const contracts = await contractsOf();
2579
+ for (const v1 of toAdopt) {
2580
+ try {
2581
+ const params = await lockupContractParams(contracts, v1.lockupAddress).catch(
2582
+ (error) => {
2583
+ if (error instanceof LockupContractMissing) return void 0;
2584
+ throw error;
2585
+ }
2586
+ );
2587
+ if (params === void 0 && !isRfqSwapTerminal(v1.state)) continue;
2588
+ const refundLocktime = params ? Number(params.refundLocktime) : 0;
2589
+ await store.saveSwapRecord(restoredCorridorRecord(v1, network, refundLocktime));
2590
+ } catch (error) {
2591
+ console.warn(`[swap] could not adopt v1 rfq swap ${v1.rfqId}`, error);
2592
+ }
2593
+ }
2594
+ } catch (error) {
2595
+ console.warn("[swap] v1 rfq swap adoption did not complete", error);
2596
+ }
2597
+ };
2598
+ const migrateOfferRows = async () => {
2599
+ if (mode === "readonly") return;
2600
+ try {
2601
+ const { skipped } = await migrateV0OfferRows(await wallet.getContractManager());
2602
+ for (const { script, reason } of skipped) {
2603
+ console.warn(`[swap] could not migrate Program v0 offer row ${script}: ${reason}`);
2604
+ }
2605
+ } catch (error) {
2606
+ console.warn("[swap] Program v0 offer row migration did not complete", error);
2607
+ }
2608
+ };
2123
2609
  const restore = async () => {
2610
+ void track(migrateOfferRows());
2124
2611
  if (!repository) return;
2125
- const all = await repository.getAllSwapRecords();
2612
+ await adoptLegacyRfqSwaps(repository);
2613
+ const all = await collectSwapRecords(repository);
2126
2614
  const { corridor, offer } = splitRecords(all.filter(readableRecord));
2127
- for (const record of [...corridor, ...offer]) records.set(record.id, record);
2615
+ const retiredScripts = /* @__PURE__ */ new Set();
2616
+ for (const record of [...corridor, ...offer]) {
2617
+ records.set(record.id, record);
2618
+ if (mode !== "readonly" && fundingWasNotSubmitted(record)) {
2619
+ const script = record.family === "offer" ? record.swapPkScript : record.lockupPkScript;
2620
+ if (retiredScripts.has(script)) continue;
2621
+ retiredScripts.add(script);
2622
+ try {
2623
+ await retireUnsubmittedFunding(wallet, repository, record, await contractsOf());
2624
+ } catch (error) {
2625
+ console.warn(
2626
+ `[swap] could not restore unsent coverage for ${record.id}`,
2627
+ error
2628
+ );
2629
+ }
2630
+ }
2631
+ }
2128
2632
  const liveCorridor = corridor.filter((record) => !isRfqSwapTerminal(record.state));
2633
+ const recheckable = corridor.filter(isRecheckableRefundedSend);
2129
2634
  const store = corridorStore();
2130
- for (const record of liveCorridor) store.index(record);
2131
- if (liveCorridor.length > 0) {
2635
+ for (const record of [...liveCorridor, ...recheckable]) store.index(record);
2636
+ const liveLegacy = await legacyLiveRfqSwaps(repository);
2637
+ if (liveCorridor.length > 0 || liveLegacy.length > 0) {
2132
2638
  try {
2133
2639
  await contractsOf();
2134
2640
  for (const record of liveCorridor) {
2135
2641
  if (!await drivable(record)) undrivable.add(record.id);
2136
2642
  }
2643
+ for (const record of liveLegacy) {
2644
+ if (!await drivable(record)) undrivableLegacy.add(record.rfqId);
2645
+ }
2137
2646
  managerDeps.repository = store;
2138
2647
  const result = await manager.restoreFromRepository();
2139
2648
  for (const swap of result.restored) {
@@ -2150,13 +2659,19 @@ var createSwapDrive = (config) => {
2150
2659
  console.warn("[swap] the corridor restore could not drive", error);
2151
2660
  }
2152
2661
  }
2662
+ let offers2 = offer;
2153
2663
  try {
2154
- await sweepOfferDeposits(offer);
2664
+ offers2 = await restoreOfferDeposits(
2665
+ offer.flatMap(
2666
+ (record) => record.status === "recoverable" && record.fundingTxid !== void 0 ? [record.fundingTxid] : []
2667
+ )
2668
+ );
2155
2669
  } catch (error) {
2156
- console.warn("[swap] the offer deposit sweep did not complete", error);
2670
+ console.warn("[swap] the offer deposit restore did not complete", error);
2157
2671
  }
2672
+ await registerRestoredOffers(offers2);
2158
2673
  emitAll();
2159
- if (mode === "auto" && await hasLiveWork(offer)) {
2674
+ if (mode === "auto" && await hasLiveWork(offers2)) {
2160
2675
  try {
2161
2676
  await arm();
2162
2677
  } catch (error) {
@@ -2164,6 +2679,17 @@ var createSwapDrive = (config) => {
2164
2679
  }
2165
2680
  }
2166
2681
  emitAll();
2682
+ if (mode !== "readonly" && recheckable.length > 0) {
2683
+ recheck = (async () => {
2684
+ try {
2685
+ await contractsOf();
2686
+ managerDeps.repository = store;
2687
+ await manager.recheckRefundedSends({ stopped: () => disposed });
2688
+ } catch (error) {
2689
+ console.warn("[swap] the refunded send re-read did not complete", error);
2690
+ }
2691
+ })();
2692
+ }
2167
2693
  };
2168
2694
  const ready = () => readyPromise ??= restore();
2169
2695
  const stop = async () => {
@@ -2184,7 +2710,7 @@ var createSwapDrive = (config) => {
2184
2710
  }
2185
2711
  return probe.call(wallet);
2186
2712
  };
2187
- const recoverableAt = async (script) => (await findLockupVtxos(indexer, script)).filter((vtxo) => vtxo.recoverable);
2713
+ const recoverableAt = async (script) => (await findLockupVtxos(lockupSource, script)).filter((vtxo) => vtxo.recoverable);
2188
2714
  const recover = async (id) => {
2189
2715
  if (disposed) throw new ClientDisposed("recover");
2190
2716
  if (mode === "readonly") {
@@ -2208,7 +2734,7 @@ var createSwapDrive = (config) => {
2208
2734
  id
2209
2735
  );
2210
2736
  }
2211
- const script = hex4.decode(record.lockupPkScript);
2737
+ const script = hex6.decode(record.lockupPkScript);
2212
2738
  const before = await recoverableAt(script);
2213
2739
  if (before.length === 0) {
2214
2740
  throw new SwapDriveRefusedError(
@@ -2218,8 +2744,8 @@ var createSwapDrive = (config) => {
2218
2744
  );
2219
2745
  }
2220
2746
  const txid2 = await track((await recoverer()).recoverVtxos());
2221
- const after2 = await recoverableAt(script);
2222
- const still = new Set(after2.map((vtxo) => `${vtxo.txid}:${vtxo.vout}`));
2747
+ const after = await recoverableAt(script);
2748
+ const still = new Set(after.map((vtxo) => `${vtxo.txid}:${vtxo.vout}`));
2223
2749
  const recovered2 = before.every((vtxo) => !still.has(`${vtxo.txid}:${vtxo.vout}`));
2224
2750
  if (recovered2) swept.delete(id);
2225
2751
  await manager.poll();
@@ -2233,10 +2759,31 @@ var createSwapDrive = (config) => {
2233
2759
  id
2234
2760
  );
2235
2761
  }
2236
- const txid = await track((await recoverer()).recoverVtxos());
2237
- await sweepOfferDeposits([records.get(id)]);
2238
- const after = records.get(id);
2239
- const recovered = after?.family === "offer" && after.status !== "recoverable";
2762
+ const wentHome = async () => {
2763
+ await restoreOfferDeposits(
2764
+ record.fundingTxid === void 0 ? [] : [record.fundingTxid]
2765
+ );
2766
+ const after = records.get(id);
2767
+ return after?.family === "offer" && after.status !== "recoverable";
2768
+ };
2769
+ try {
2770
+ if (await wentHome()) return { recovered: true, swap: swapView(id) };
2771
+ } catch (error) {
2772
+ console.warn(`[swap] could not re-read offer ${id} before recovering it`, error);
2773
+ }
2774
+ const vtxoManager = await recoverer();
2775
+ await restoreOfferCoverage(wallet, [offerFactsOf(record)]);
2776
+ const txid = await track(vtxoManager.recoverVtxos());
2777
+ recoveredIn.add(txid);
2778
+ let recovered = false;
2779
+ try {
2780
+ recovered = await wentHome();
2781
+ } catch (error) {
2782
+ console.warn(
2783
+ `[swap] recovered offer ${id} in ${txid}, but could not re-read it`,
2784
+ error
2785
+ );
2786
+ }
2240
2787
  return { recovered, txid, swap: swapView(id) };
2241
2788
  };
2242
2789
  const swapView = (id) => {
@@ -2290,6 +2837,10 @@ var createSwapDrive = (config) => {
2290
2837
  adopt: (record) => {
2291
2838
  if (disposed) throw new ClientDisposed("accept");
2292
2839
  records.set(record.id, record);
2840
+ if (fundingWasNotSubmitted(record)) {
2841
+ emit(record.id);
2842
+ return swapView(record.id);
2843
+ }
2293
2844
  if (record.family === "rfq") {
2294
2845
  corridorStore().index(record);
2295
2846
  managerDeps.repository = corridorStore();
@@ -2313,7 +2864,8 @@ import {
2313
2864
  isRfqMarket as isRfqMarket2,
2314
2865
  marketCorridor as marketCorridor2,
2315
2866
  marketLegKey,
2316
- selectMarkets
2867
+ selectMarkets,
2868
+ sideLimits
2317
2869
  } from "@arkade-os/solver-discovery";
2318
2870
  var marketKeyOf = (card) => {
2319
2871
  const base = marketLegKey(card, "base");
@@ -2325,8 +2877,9 @@ var marketKeyOf = (card) => {
2325
2877
  }
2326
2878
  return base <= quote ? `${base}/${quote}` : `${quote}/${base}`;
2327
2879
  };
2328
- var isAddressable = (card) => !isRfqMarket2(card) || typeof card.discovery_pubkey === "string" && (card.transports?.nostr?.relays?.length ?? 0) > 0;
2329
- var marketBackendOf = (card) => isRfqMarket2(card) ? "rfq" : "feed";
2880
+ var hasRendezvous = (card) => typeof card.discovery_pubkey === "string" && (card.transports?.nostr?.relays?.length ?? 0) > 0;
2881
+ var isAddressable = (card) => !isRfqMarket2(card) || hasRendezvous(card);
2882
+ var marketBackendOf = (card) => isRfqMarket2(card) || hasRendezvous(card) ? "rfq" : "feed";
2330
2883
  var usableMarkets = (snapshot, policy) => {
2331
2884
  const allowed = policy?.allowedRegistries;
2332
2885
  return (allowed ? snapshot.markets.filter((card) => allowed.includes(card.source)) : snapshot.markets).filter(isAddressable);
@@ -2339,8 +2892,7 @@ var eligibleMarkets = (snapshot, legs, policy, takeAmount) => {
2339
2892
  const base = side === "base" ? give : take;
2340
2893
  const quote = side === "base" ? take : give;
2341
2894
  const selection = {
2342
- // The trader receives the take leg, so that side must be one the
2343
- // solver can pay out; a direction nobody solves yields no market.
2895
+ // The trader receives the take leg, so the solver must be able to pay that side out.
2344
2896
  wantSide: side === "base" ? "quote" : "base",
2345
2897
  ...takeAmount === void 0 ? {} : { wantAmount: takeAmount }
2346
2898
  };
@@ -2354,9 +2906,7 @@ var eligibleMarkets = (snapshot, legs, policy, takeAmount) => {
2354
2906
  quoteId: `${quote.corridor}:${quote.assetId}`,
2355
2907
  ...selection
2356
2908
  });
2357
- const selected = [...canonical, ...legacy].filter(
2358
- (card, index, all) => all.indexOf(card) === index
2359
- );
2909
+ const selected = [.../* @__PURE__ */ new Set([...canonical, ...legacy])];
2360
2910
  return selected.map((card) => ({
2361
2911
  card,
2362
2912
  give: side,
@@ -2389,13 +2939,26 @@ var cardMarketOf = (card, snapshot, key, backend) => ({
2389
2939
  snapshot
2390
2940
  });
2391
2941
  var isCardMarket = (market) => market.kind === "card";
2942
+ var marketLegOf = (card, side, network) => {
2943
+ const asset5 = cardLegAssetId(card, side, network);
2944
+ return {
2945
+ ...asset5 === void 0 ? {} : { asset: asset5 },
2946
+ decimals: (side === "base" ? card.base_asset : card.quote_asset).decimals,
2947
+ limits: sideLimits(card, side)
2948
+ };
2949
+ };
2950
+ var marketOf = (card, snapshot, network) => ({
2951
+ ...cardMarketOf(card, snapshot, marketKeyOf(card), marketBackendOf(card)),
2952
+ legs: [marketLegOf(card, "base", network), marketLegOf(card, "quote", network)]
2953
+ });
2392
2954
 
2393
2955
  // src/client/resolve.ts
2394
2956
  var SUPPORTED_PAIRS = [
2395
2957
  "arkade->arkade",
2396
2958
  "arkade->lightning",
2397
2959
  "lightning->arkade",
2398
- "arkade->onchain"
2960
+ "arkade->onchain",
2961
+ "onchain->arkade"
2399
2962
  ];
2400
2963
  var isSupportedPair = (pair) => SUPPORTED_PAIRS.includes(pair);
2401
2964
  var assembleRoute = (give, take) => {
@@ -2409,16 +2972,16 @@ var assembleRoute = (give, take) => {
2409
2972
  }
2410
2973
  return { give, take };
2411
2974
  };
2412
- var endpoint = (corridor, asset3, instrument) => ({
2975
+ var endpoint = (corridor, asset5, instrument) => ({
2413
2976
  corridor,
2414
- asset: asset3,
2977
+ asset: asset5,
2415
2978
  ...instrument === void 0 ? {} : { instrument }
2416
2979
  });
2417
- var legFor = (asset3, expected) => {
2418
- const leg = toDiscoveryLeg(asset3);
2980
+ var legFor = (asset5, expected) => {
2981
+ const leg = toDiscoveryLeg(asset5);
2419
2982
  if (expected !== void 0 && leg.corridor !== expected) {
2420
2983
  throw new UnsupportedRoute(
2421
- `${asset3} settles on ${leg.corridor}, and this leg is ${expected}`,
2984
+ `${asset5} settles on ${leg.corridor}, and this leg is ${expected}`,
2422
2985
  { give: leg.corridor, take: expected }
2423
2986
  );
2424
2987
  }
@@ -2456,10 +3019,10 @@ var resolveRoute = async (input, deps) => {
2456
3019
  }
2457
3020
  const pair = `${giveLeg.corridor}->${takeLeg.corridor}`;
2458
3021
  if (!isSupportedPair(pair)) {
2459
- throw new UnsupportedRoute(
2460
- 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`,
2461
- { give: giveLeg.corridor, take: takeLeg.corridor }
2462
- );
3022
+ throw new UnsupportedRoute(`${pair} is not an implemented route`, {
3023
+ give: giveLeg.corridor,
3024
+ take: takeLeg.corridor
3025
+ });
2463
3026
  }
2464
3027
  const give = endpoint(
2465
3028
  giveLeg.corridor,
@@ -2500,11 +3063,9 @@ var resolveRoute = async (input, deps) => {
2500
3063
  aliases
2501
3064
  };
2502
3065
  };
2503
- var isCorridor = (value) => value === "arkade" || value === "lightning" || value === "onchain";
3066
+ var isCorridor = (value) => CORRIDORS.includes(value);
2504
3067
  var assetFor = (ref, corridor, network, aliases) => ref === void 0 ? btcOn(railOfCorridor(corridor), network) : (
2505
- // Scoped to the leg's rail, because BTC has one id per rail and a
2506
- // whole-table lookup would refuse `"BTC"` as ambiguous on any snapshot
2507
- // carrying a corridor market — see `scopedToRail`.
3068
+ // Rail-scoped: BTC has one id per rail, so a whole-table `"BTC"` is ambiguous.
2508
3069
  canonicalAssetId(ref, scopedToRail(aliases, railOfCorridor(corridor)))
2509
3070
  );
2510
3071
  var pinAmount = (input, takeInstrument) => {
@@ -2525,6 +3086,9 @@ var pinAmount = (input, takeInstrument) => {
2525
3086
  return void 0;
2526
3087
  };
2527
3088
 
3089
+ // src/client/policy.ts
3090
+ var DEFAULT_MAX_REFUND_WINDOW_SECONDS = 30 * 24 * 3600;
3091
+
2528
3092
  // src/client/verify.ts
2529
3093
  var reasonOf = (error) => error instanceof Error && typeof error.reason === "string" ? error.reason : void 0;
2530
3094
  var CHECK_BY_REASON = {
@@ -2676,15 +3240,24 @@ var verifyQuoteTtl = (input) => {
2676
3240
  throw new QuoteExpired(input.quoteId, input.expiresAt, input.now);
2677
3241
  }
2678
3242
  };
2679
- var verifyQuotedAmount = (input) => {
2680
- const quoted = input.pinned.on === "give" ? input.give : input.take;
2681
- if (quoted !== input.pinned.value) {
3243
+ var CSV_GRANULARITY_SECONDS = 512;
3244
+ var verifyRefundWindow = (input) => {
3245
+ const max = input.maxSeconds ?? DEFAULT_MAX_REFUND_WINDOW_SECONDS;
3246
+ const window = input.refundLocktime - input.now;
3247
+ if (!(window <= max)) {
3248
+ throw new QuoteVerificationFailed("refund_window", `at most ${max}s`, `${window}s`);
3249
+ }
3250
+ const delay = input.refundWithoutReceiverDelay;
3251
+ if (delay !== void 0 && !(delay < max + CSV_GRANULARITY_SECONDS)) {
2682
3252
  throw new QuoteVerificationFailed(
2683
- "pair",
2684
- `${input.pair} ${input.pinned.on}=${input.pinned.value}`,
2685
- `${input.pair} ${input.pinned.on}=${quoted}`
3253
+ "refund_window",
3254
+ `a solo-refund delay of at most ${max}s`,
3255
+ `${delay}s`
2686
3256
  );
2687
3257
  }
3258
+ };
3259
+ var verifyQuotedAmount = (input) => {
3260
+ verifyPinnedAmount(input);
2688
3261
  if (input.take > input.give) {
2689
3262
  throw new QuoteVerificationFailed(
2690
3263
  "pair",
@@ -2693,10 +3266,44 @@ var verifyQuotedAmount = (input) => {
2693
3266
  );
2694
3267
  }
2695
3268
  };
3269
+ var verifyCrossAssetAmount = (input) => {
3270
+ verifyPinnedAmount(input);
3271
+ if (input.give <= 0n || input.take <= 0n) {
3272
+ throw new QuoteVerificationFailed(
3273
+ "pair",
3274
+ `${input.pair} give > 0 take > 0`,
3275
+ `give=${input.give} take=${input.take}`
3276
+ );
3277
+ }
3278
+ };
3279
+ var verifiedCarrierSats = (quote) => {
3280
+ try {
3281
+ return quoteCarrierSats(quote);
3282
+ } catch (error) {
3283
+ if (reasonOf(error) !== "carrier_malformed") throw error;
3284
+ throw new QuoteVerificationFailed(
3285
+ "pair",
3286
+ "carrier_sats a non-negative integer",
3287
+ String(quote.carrier_sats),
3288
+ { cause: error }
3289
+ );
3290
+ }
3291
+ };
3292
+ var verifyPinnedAmount = (input) => {
3293
+ const quoted = input.pinned.on === "give" ? input.give : input.take;
3294
+ if (quoted !== input.pinned.value) {
3295
+ throw new QuoteVerificationFailed(
3296
+ "pair",
3297
+ `${input.pair} ${input.pinned.on}=${input.pinned.value}`,
3298
+ `${input.pair} ${input.pinned.on}=${quoted}`
3299
+ );
3300
+ }
3301
+ };
2696
3302
 
2697
3303
  // src/client/quoteOffer.ts
2698
3304
  import {
2699
3305
  computeWantAmount,
3306
+ marketLegKey as marketLegKey2,
2700
3307
  quoteOffer
2701
3308
  } from "@arkade-os/solver-discovery";
2702
3309
  var FEED_TTL_MS = 3e4;
@@ -2716,6 +3323,9 @@ var quoteFromFeed = async (input) => {
2716
3323
  const plan = await quoteOffer(candidate.card, {
2717
3324
  give: candidate.give,
2718
3325
  ...amount.on === "give" ? { giveAmount: amount.value } : { wantAmount: amount.value },
3326
+ // What `fund` attaches to an asset deposit and the fill pays an asset want: the plan asks
3327
+ // for it back in a BTC payout, and charges it where the card declares a delivered carrier.
3328
+ carrierSats: ASSET_CARRIER_SATS,
2719
3329
  ...QUOTE_OPTIONS,
2720
3330
  fetchImpl: input.feed.fetch
2721
3331
  });
@@ -2739,12 +3349,21 @@ var quoteFromFeed = async (input) => {
2739
3349
  take: { asset: input.endpoints.take.asset, amount: plan.receive.atomic },
2740
3350
  market: input.market,
2741
3351
  expiresAt,
2742
- fee: { amount: spreadOf(plan), asset: input.endpoints.take.asset }
3352
+ fee: {
3353
+ // The plan's payout returns the deposit's carrier; that part is not proceeds.
3354
+ amount: feedSpread(
3355
+ plan,
3356
+ plan.receive.atomic,
3357
+ sellsAssetForBtc(input.endpoints) ? ASSET_CARRIER_SATS : 0n
3358
+ ),
3359
+ asset: input.endpoints.take.asset
3360
+ }
2743
3361
  },
2744
3362
  preparation: { backend: "feed", card: candidate.card, plan, give: candidate.give }
2745
3363
  };
2746
3364
  };
2747
- var spreadOf = (plan) => {
3365
+ var feedSpread = (plan, take, carrierSats = 0n) => {
3366
+ const payout = take > carrierSats ? take - carrierSats : 0n;
2748
3367
  const fair = computeWantAmount({
2749
3368
  deposit: plan.deposit.atomic,
2750
3369
  give: plan.give,
@@ -2752,22 +3371,110 @@ var spreadOf = (plan) => {
2752
3371
  feeBps: 0,
2753
3372
  safetyBps: 0
2754
3373
  });
2755
- const spread = fair - plan.receive.atomic;
3374
+ const spread = fair - payout;
2756
3375
  return spread > 0n ? spread : 0n;
2757
3376
  };
3377
+ var sellsAssetForBtc = (endpoints) => !isBtcAsset(endpoints.give.asset) && isBtcAsset(endpoints.take.asset);
2758
3378
  var feedExpiry = (card, feed, now) => {
2759
3379
  const readAt = card.price_feed === void 0 ? void 0 : feed.fetchedAt(card.price_feed);
2760
3380
  const from = readAt === void 0 ? now : Math.floor(readAt / 1e3);
2761
3381
  return from + FEED_TTL_MS / 1e3;
2762
3382
  };
2763
3383
  var verifyPlanLegs = (plan, legs, give) => {
2764
- const expected = `${legs.give.assetId}->${legs.take.assetId}`;
2765
- const priced = `${plan.deposit.asset.id}->${plan.receive.asset.id}`;
2766
- if (expected !== priced || plan.give !== give) {
2767
- throw new QuoteVerificationFailed("pair", expected, priced);
3384
+ const take = give === "base" ? "quote" : "base";
3385
+ const spelled = (side) => marketLegKey2(plan.market, side);
3386
+ const names = (side, leg) => spelled(side) === leg.marketId || spelled(side) === `${leg.corridor}:${leg.assetId}`;
3387
+ if (plan.give !== give || !names(give, legs.give) || !names(take, legs.take)) {
3388
+ throw new QuoteVerificationFailed(
3389
+ "pair",
3390
+ `${legs.give.marketId}->${legs.take.marketId}`,
3391
+ `${spelled(give)}->${spelled(take)}`
3392
+ );
2768
3393
  }
2769
3394
  };
2770
3395
 
3396
+ // src/jointGraph.ts
3397
+ import { base64 as base642, hex as hex7 } from "@scure/base";
3398
+ import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
3399
+ import { Transaction as Transaction2 } from "@arkade-os/sdk";
3400
+ function digestJointGraph(plan, template) {
3401
+ const parts = [];
3402
+ const pushU32 = (value) => {
3403
+ const len = new Uint8Array(4);
3404
+ new DataView(len.buffer).setUint32(0, value, false);
3405
+ parts.push(len);
3406
+ };
3407
+ const pushField = (bytes) => {
3408
+ pushU32(bytes.length);
3409
+ parts.push(bytes);
3410
+ };
3411
+ pushField(new TextEncoder().encode(template));
3412
+ pushField(unsignedPsbtBytes(parseGraphTx(plan.arkTx)));
3413
+ pushU32(plan.checkpoints.length);
3414
+ for (const checkpoint of plan.checkpoints) {
3415
+ pushField(unsignedPsbtBytes(parseGraphTx(checkpoint)));
3416
+ }
3417
+ pushU32(plan.inputOwners.length);
3418
+ for (const owner of plan.inputOwners) {
3419
+ if (owner === null) {
3420
+ parts.push(new Uint8Array([0]));
3421
+ } else {
3422
+ const bytes = new TextEncoder().encode(owner);
3423
+ parts.push(new Uint8Array([1]));
3424
+ pushField(bytes);
3425
+ }
3426
+ }
3427
+ const preimage = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
3428
+ let at = 0;
3429
+ for (const part of parts) {
3430
+ preimage.set(part, at);
3431
+ at += part.length;
3432
+ }
3433
+ return hex7.encode(sha2562(preimage));
3434
+ }
3435
+ function verifyJointGraph(plan, template) {
3436
+ try {
3437
+ if (!plan || typeof plan !== "object") return false;
3438
+ if (typeof plan.arkTx !== "string" || plan.arkTx.length === 0) return false;
3439
+ if (!Array.isArray(plan.checkpoints) || plan.checkpoints.length < 1 || plan.checkpoints.some((c) => typeof c !== "string" || c.length === 0))
3440
+ return false;
3441
+ if (!/^[0-9a-f]{64}$/.test(plan.graphId)) return false;
3442
+ if (!Array.isArray(plan.inputOwners) || plan.inputOwners.some((o) => o !== null && (typeof o !== "string" || o.length === 0)))
3443
+ return false;
3444
+ if (plan.inputOwners.length !== plan.checkpoints.length) return false;
3445
+ const arkInputs = parseGraphTx(plan.arkTx).inputsLength;
3446
+ if (plan.checkpoints.length !== arkInputs) return false;
3447
+ if (plan.inputOwners.length !== arkInputs) return false;
3448
+ return digestJointGraph(
3449
+ {
3450
+ arkTx: plan.arkTx,
3451
+ checkpoints: [...plan.checkpoints],
3452
+ inputOwners: [...plan.inputOwners]
3453
+ },
3454
+ template
3455
+ ) === plan.graphId;
3456
+ } catch {
3457
+ return false;
3458
+ }
3459
+ }
3460
+ function parseGraphTx(psbt) {
3461
+ return Transaction2.fromPSBT(base642.decode(psbt));
3462
+ }
3463
+ function deepFreeze(value) {
3464
+ if (value !== null && typeof value === "object") {
3465
+ for (const child of Object.values(value)) deepFreeze(child);
3466
+ Object.freeze(value);
3467
+ }
3468
+ return value;
3469
+ }
3470
+ function unsignedPsbtBytes(tx) {
3471
+ const stripped = tx.clone();
3472
+ for (let i = 0; i < stripped.inputsLength; i++) {
3473
+ stripped.updateInput(i, { tapScriptSig: void 0 });
3474
+ }
3475
+ return stripped.toPSBT();
3476
+ }
3477
+
2771
3478
  // src/client/sats.ts
2772
3479
  var satsOf = (value, field) => {
2773
3480
  if (value < 0n || value > BigInt(Number.MAX_SAFE_INTEGER)) {
@@ -2785,8 +3492,7 @@ var PAYMENT_STATUS = {
2785
3492
  /** Persisted, funding not broadcast. */
2786
3493
  accepted: "pending",
2787
3494
  funding: "pending",
2788
- /** The lockup is funded. Nothing has emitted `"sent"` in core since the
2789
- * `onchain-swap` rail left with `packages/boltz-swap`. */
3495
+ /** The lockup is funded. */
2790
3496
  funded: "sent",
2791
3497
  /** Asset swaps only: an unfilled offer. */
2792
3498
  open: "pending",
@@ -2850,14 +3556,19 @@ var receiverExact = (railId, parts) => {
2850
3556
  total: satsOf(parts.total, `${railId}.total`)
2851
3557
  };
2852
3558
  };
3559
+ var quoteMeta = (quote) => ({
3560
+ quoteId: quote.id,
3561
+ expiresAt: quote.expiresAt,
3562
+ ...quote.refundLocktime === void 0 ? {} : { refundLocktime: quote.refundLocktime },
3563
+ ...quote.solver === void 0 ? {} : { solver: quote.solver },
3564
+ ...quote.lock === void 0 ? {} : { paymentHash: quote.lock.hash },
3565
+ ...quote.market.kind === "restored" ? {} : { market: quote.market.key }
3566
+ });
2853
3567
  var resultOf = (railId, swap) => ({
2854
3568
  railId,
2855
- // The tagged public form M6 minted — round-trippable to `client.swaps()`,
2856
- // which is where the outcomes past this handle's terminal one are read.
3569
+ // tagged, so it joins `client.swaps()`/`onUpdate` for outcomes past this handle's terminal one
2857
3570
  swapId: swap.id,
2858
- // The transaction that left THIS wallet, which is what `txid` means on
2859
- // every other rail. A swap's later legs — the solver's fill, the trader's
2860
- // L1 claim — are the client's to report, not the handle's.
3571
+ // the tx that left THIS wallet, as on every other rail; later legs are the client's to report
2861
3572
  ...swap.fundingTxid === void 0 ? {} : { txid: swap.fundingTxid }
2862
3573
  });
2863
3574
  var swapHandle = async (railId, client, quote) => makeHandle(railId, async (emit) => {
@@ -2937,8 +3648,7 @@ function onchainSwapRail(client, deps) {
2937
3648
  }
2938
3649
  const amounts = receiverExact(ONCHAIN_SWAP_RAIL, {
2939
3650
  amount: payout,
2940
- // Both halves of the cost, inside one number: the solver's
2941
- // spread, and the claim the trader pays for out of the payout.
3651
+ // The solver's spread plus the claim the trader pays out of the payout.
2942
3652
  fee: quote.fee.amount + claimFee,
2943
3653
  total: quote.give.amount
2944
3654
  });
@@ -2946,13 +3656,7 @@ function onchainSwapRail(client, deps) {
2946
3656
  railId: ONCHAIN_SWAP_RAIL,
2947
3657
  ...amounts,
2948
3658
  meta: {
2949
- quoteId: quote.id,
2950
- expiresAt: quote.expiresAt,
2951
- ...quote.refundLocktime === void 0 ? {} : { refundLocktime: quote.refundLocktime },
2952
- ...quote.solver === void 0 ? {} : { solver: quote.solver },
2953
- ...quote.lock === void 0 ? {} : { paymentHash: quote.lock.hash },
2954
- market: quote.market.key,
2955
- // The estimate folded into `fee`, so a caller can see it.
3659
+ ...quoteMeta(quote),
2956
3660
  claimFeeSats: Number(claimFee),
2957
3661
  // What the solver locks on L1, before the claim's fee.
2958
3662
  htlcAmountSats: Number(quote.take.amount)
@@ -2992,22 +3696,29 @@ var parseRfqQuote = (quote) => ({
2992
3696
  });
2993
3697
 
2994
3698
  // src/client/quoteRfq.ts
2995
- import { hex as hex5 } from "@scure/base";
3699
+ import { hex as hex8 } from "@scure/base";
2996
3700
  import {
3701
+ ArkAddress as ArkAddress6,
3702
+ asset as asset4,
2997
3703
  networkFromArkadeInfo,
2998
3704
  provisionClaimSecret,
2999
3705
  provisionRefundKey,
3000
3706
  toXOnly
3001
3707
  } from "@arkade-os/sdk";
3708
+ import { quoteOffer as quoteOffer2 } from "@arkade-os/solver-discovery";
3709
+ var lockupOf = (derived) => ({
3710
+ address: derived.address,
3711
+ script: derived.script,
3712
+ pkScript: derived.swapPkScript
3713
+ });
3002
3714
  var covenantInputs = (input) => {
3003
3715
  const network = networkFromArkadeInfo(input.info);
3004
- const arkade = input.corridors.get("arkade").deps;
3716
+ const arkade2 = input.corridors.get("arkade").deps;
3005
3717
  return {
3006
- operatorPubkey: toXOnly(hex5.decode(input.info.signerPubkey), "ark signer key"),
3007
- // The per-network pin the arkade module already resolved, never a key
3008
- // the operator reports about itself: this one ends up in a covenant leaf
3718
+ operatorPubkey: toXOnly(hex8.decode(input.info.signerPubkey), "ark signer key"),
3719
+ // The resolved per-network pin, never operator-reported: it lands in a covenant leaf
3009
3720
  // that decides who can move the funds.
3010
- emulatorPubkey: toXOnly(hex5.decode(arkade.emulatorPubkey), "emulator signer key"),
3721
+ emulatorPubkey: toXOnly(hex8.decode(arkade2.emulatorPubkey), "emulator signer key"),
3011
3722
  claimDelay: unilateralClaimDelay(Number(input.info.unilateralExitDelay)),
3012
3723
  hrp: network.hrp
3013
3724
  };
@@ -3015,7 +3726,7 @@ var covenantInputs = (input) => {
3015
3726
  var sealingKey = (deps) => {
3016
3727
  const configured = deps.covclaimd?.pubkey;
3017
3728
  if (configured === void 0) return void 0;
3018
- const key = hex5.decode(configured);
3729
+ const key = hex8.decode(configured);
3019
3730
  if (key.length !== 33) {
3020
3731
  throw new Error(
3021
3732
  `the covclaimd deployment key must be 33-byte compressed hex, got ${key.length} bytes`
@@ -3035,14 +3746,198 @@ var quoteViaRfq = async (input) => {
3035
3746
  expected: input.market.discoveryPubkey,
3036
3747
  pinnable: input.market.snapshot.live
3037
3748
  });
3749
+ if (input.assetPayment !== void 0 && input.route !== "arkade->arkade")
3750
+ throw new Error("assetPayment supports BTC-to-asset only");
3038
3751
  switch (input.route) {
3752
+ case "arkade->arkade":
3753
+ return quoteArkadeAsset(input);
3039
3754
  case "arkade->lightning":
3040
3755
  return quoteLightningSend(input);
3041
3756
  case "lightning->arkade":
3042
3757
  return quoteLightningReceive(input);
3043
3758
  case "arkade->onchain":
3044
3759
  return quoteOnchainSend(input);
3760
+ case "onchain->arkade":
3761
+ return quoteOnchainReceive(input);
3762
+ }
3763
+ };
3764
+ var quoteArkadeAsset = async (input) => {
3765
+ const pinned = pinnedFor(input);
3766
+ const sides = assetSidesOf(input.legs);
3767
+ if (pinned.on !== "give" && sides.wantAsset === void 0)
3768
+ throw new Error("asset-to-BTC is exact-in only");
3769
+ const payment = input.assetPayment;
3770
+ if (payment !== void 0 && sides.wantAsset === void 0)
3771
+ throw new Error("assetPayment supports BTC-to-asset only");
3772
+ if (input.candidate.card.price_feed === void 0) {
3773
+ throw new UnsupportedRoute(
3774
+ `card ${input.candidate.card.solver} advertises no price feed to measure an asset swap's fee against`,
3775
+ { give: "arkade", take: "arkade" }
3776
+ );
3777
+ }
3778
+ const pair = rfqPairFor(input.legs.give, input.legs.take);
3779
+ const rfqId = newRfqId();
3780
+ const maker = await makerPosition(input.wallet);
3781
+ const receiveAddress = payment?.receiveAddress;
3782
+ const receivePkScript = resolveReceivePkScript(
3783
+ receiveAddress,
3784
+ maker.pkScript,
3785
+ networkFromArkadeInfo(input.info).hrp,
3786
+ toXOnly(hex8.decode(input.info.signerPubkey), "ark signer key")
3787
+ );
3788
+ const choice = payment?.carrier;
3789
+ const carrierRequest = choice === void 0 ? void 0 : choice.mode === "purchase" ? { mode: "purchase" } : {
3790
+ mode: "recycle_receiver",
3791
+ quoteId: choice.quote.quoteId,
3792
+ taxiUrl: choice.taxi.url,
3793
+ taxiKey: choice.taxi.operatorKey
3794
+ };
3795
+ if (choice?.mode === "recycleReceiver") {
3796
+ if (choice.quote.assetId !== sides.wantAsset?.toString())
3797
+ throw new Error("carrier quote assetId differs from requested asset");
3798
+ if (choice.quote.senderKey !== hex8.encode(maker.publicKey))
3799
+ throw new Error("carrier quote senderKey differs from wallet identity");
3800
+ if (input.now >= choice.quote.expiresAt - 30)
3801
+ throw new Error("carrier quote expired before RFQ");
3802
+ }
3803
+ const request = arkadeSwapRequest({
3804
+ rfqId,
3805
+ ...sides,
3806
+ amount: pinned.value,
3807
+ amountSide: toRfqAmountSide(pinned.on),
3808
+ makerPkScript: receivePkScript,
3809
+ makerPublicKey: maker.publicKey
3810
+ });
3811
+ const wire = await input.transport.requestQuote({
3812
+ ...request,
3813
+ profile: {
3814
+ ...request.profile,
3815
+ ...carrierRequest === void 0 ? {} : { carrier: encodeCarrierRequest(carrierRequest) }
3816
+ }
3817
+ });
3818
+ verifyPair(wire.pair, pair);
3819
+ const parsed = parseRfqQuote(wire);
3820
+ verifyCrossAssetAmount({ pair, pinned, give: parsed.give, take: parsed.take });
3821
+ verifyQuoteTtl({
3822
+ quoteId: input.quoteId,
3823
+ expiresAt: parsed.validUntil,
3824
+ now: input.now,
3825
+ floorSeconds: input.policy?.quoteTtlFloorSeconds
3826
+ });
3827
+ let assetPayment;
3828
+ if (payment !== void 0) {
3829
+ let carrier;
3830
+ if (carrierRequest !== void 0) {
3831
+ carrier = parseCarrierEcho(wire.profile?.carrier, carrierRequest);
3832
+ if (carrier.physicalSats !== input.info.dust)
3833
+ throw new Error("carrier physical differs from server dust");
3834
+ if (carrier.expiresAt > parsed.validUntil)
3835
+ throw new Error("carrier echo extends solver expiry");
3836
+ if (choice?.mode === "recycleReceiver") {
3837
+ if (wire.carrier_sats !== void 0)
3838
+ throw new Error("receiver-paid quote must publish no carrier_sats");
3839
+ assertReceiverPaidEchoMatchesExpected(carrier, choice.quote);
3840
+ } else if (parseTopLevelCarrierSats(wire.carrier_sats) !== carrier.physicalSats)
3841
+ throw new Error("carrier echo differs from carrier_sats");
3842
+ }
3843
+ const validUntil = Math.min(
3844
+ parsed.validUntil,
3845
+ carrier?.expiresAt ?? parsed.validUntil,
3846
+ choice?.mode === "recycleReceiver" ? choice.quote.expiresAt : parsed.validUntil
3847
+ ) - 30;
3848
+ if (input.now >= validUntil) throw new Error("asset payment terms lapsed before funding");
3849
+ assetPayment = {
3850
+ receiveAddress: receiveAddress ?? new ArkAddress6(
3851
+ toXOnly(hex8.decode(input.info.signerPubkey), "ark signer key"),
3852
+ maker.pkScript.slice(2),
3853
+ networkFromArkadeInfo(input.info).hrp
3854
+ ).encode(),
3855
+ validUntil,
3856
+ ...carrier === void 0 ? {} : { carrier },
3857
+ ...choice?.mode !== "recycleReceiver" || choice.inputExpiryFloor === void 0 ? {} : { inputExpiryFloor: choice.inputExpiryFloor }
3858
+ };
3859
+ }
3860
+ if (assetPayment !== void 0) deepFreeze(assetPayment);
3861
+ const carrierSats = sides.offerAsset === void 0 ? void 0 : verifiedCarrierSats(wire);
3862
+ const reference = await quoteOffer2(input.candidate.card, {
3863
+ give: input.candidate.give,
3864
+ giveAmount: parsed.give,
3865
+ ...carrierSats === void 0 ? {} : { carrierSats },
3866
+ ...QUOTE_OPTIONS,
3867
+ fetchImpl: input.feed.fetch
3868
+ });
3869
+ verifyPlanLegs(reference, input.legs, input.candidate.give);
3870
+ const terms = offerTermsFromQuote(wire, sides);
3871
+ const offer = await deriveOffer(input.wallet, {
3872
+ wantAmount: terms.wantAmount,
3873
+ ...terms.wantAsset === void 0 ? {} : { wantAsset: terms.wantAsset },
3874
+ ...terms.offerAsset === void 0 ? {} : { offerAsset: terms.offerAsset },
3875
+ emulatorPubkey: input.corridors.get("arkade").deps.emulatorPubkey,
3876
+ maker,
3877
+ ...receiveAddress === void 0 ? {} : { receiveAddress },
3878
+ info: input.info
3879
+ });
3880
+ verifyingDerivation(() => verifyOfferAddress(wire, offer));
3881
+ return {
3882
+ quote: {
3883
+ id: input.quoteId,
3884
+ ...assetPayment === void 0 ? {} : { assetPayment },
3885
+ route: assembleRoute(
3886
+ { ...input.endpoints.give, instrument: { kind: "wallet" } },
3887
+ {
3888
+ ...input.endpoints.take,
3889
+ instrument: receiveAddress === void 0 ? { kind: "wallet" } : { kind: "address", address: receiveAddress }
3890
+ }
3891
+ ),
3892
+ give: { asset: input.endpoints.give.asset, amount: parsed.give },
3893
+ take: { asset: input.endpoints.take.asset, amount: parsed.take },
3894
+ market: input.market,
3895
+ solver: parsed.solver,
3896
+ expiresAt: parsed.validUntil,
3897
+ // Exactly one leg is BTC, so an asset deposit's carrier is on the payout's unit.
3898
+ fee: {
3899
+ amount: feedSpread(reference, parsed.take, carrierSats),
3900
+ asset: input.endpoints.take.asset
3901
+ }
3902
+ },
3903
+ preparation: {
3904
+ backend: "rfq",
3905
+ route: "arkade->arkade",
3906
+ card: input.candidate.card,
3907
+ rfqId,
3908
+ wire: parsed,
3909
+ offer,
3910
+ ...assetPayment === void 0 ? {} : {
3911
+ assetPayment,
3912
+ assetPaymentRecipient: receiveAddress === void 0 ? { kind: "wallet" } : { kind: "address", address: receiveAddress }
3913
+ },
3914
+ ...carrierSats === void 0 ? {} : { carrierSats }
3915
+ }
3916
+ };
3917
+ };
3918
+ var assetSidesOf = (legs) => {
3919
+ const giveIsBtc = legs.give.assetId === BTC_ASSET_ID;
3920
+ const takeIsBtc = legs.take.assetId === BTC_ASSET_ID;
3921
+ if (giveIsBtc && takeIsBtc) {
3922
+ throw new UnsupportedRoute("arkade:BTC -> arkade:BTC moves one asset, it swaps nothing", {
3923
+ give: "arkade",
3924
+ take: "arkade"
3925
+ });
3045
3926
  }
3927
+ if (!giveIsBtc && !takeIsBtc) {
3928
+ throw new UnsupportedRoute(
3929
+ `arkade:${legs.give.assetId} -> arkade:${legs.take.assetId}: an asset swap prices one asset against BTC, so exactly one leg must be BTC`,
3930
+ { give: "arkade", take: "arkade" }
3931
+ );
3932
+ }
3933
+ return giveIsBtc ? { wantAsset: asset4.AssetId.fromString(legs.take.assetId) } : { offerAsset: asset4.AssetId.fromString(legs.give.assetId) };
3934
+ };
3935
+ var makerPosition = async (wallet) => {
3936
+ const [address, publicKey] = await Promise.all([
3937
+ wallet.getAddress(),
3938
+ wallet.identity.xOnlyPublicKey()
3939
+ ]);
3940
+ return { pkScript: ArkAddress6.decode(address).pkScript, publicKey };
3046
3941
  };
3047
3942
  var quoteLightningSend = async (input) => {
3048
3943
  const invoice = input.endpoints.take.instrument;
@@ -3070,6 +3965,7 @@ var quoteLightningSend = async (input) => {
3070
3965
  paymentHash: invoice.paymentHash,
3071
3966
  senderPubkey: secrets.pubkey,
3072
3967
  refundPkScript: secrets.pkScript,
3968
+ now: input.now,
3073
3969
  ...covenant
3074
3970
  })
3075
3971
  );
@@ -3079,6 +3975,12 @@ var quoteLightningSend = async (input) => {
3079
3975
  now: input.now,
3080
3976
  invoiceExpiresAt: invoice.expiresAt
3081
3977
  });
3978
+ verifyRefundWindow({
3979
+ refundLocktime: derived.refundLocktime,
3980
+ refundWithoutReceiverDelay: derived.contractParams.refundWithoutReceiverDelay,
3981
+ now: input.now,
3982
+ maxSeconds: input.policy?.maxRefundWindowSeconds
3983
+ });
3082
3984
  verifyQuoteTtl({
3083
3985
  quoteId: input.quoteId,
3084
3986
  expiresAt: parsed.validUntil,
@@ -3107,11 +4009,7 @@ var quoteLightningSend = async (input) => {
3107
4009
  card: input.candidate.card,
3108
4010
  rfqId,
3109
4011
  wire: parsed,
3110
- lockup: {
3111
- address: derived.address,
3112
- script: derived.script,
3113
- pkScript: derived.swapPkScript
3114
- },
4012
+ lockup: lockupOf(derived),
3115
4013
  contractParams: derived.contractParams,
3116
4014
  secrets,
3117
4015
  refundAddress: secrets.address,
@@ -3124,11 +4022,17 @@ var quoteLightningReceive = async (input) => {
3124
4022
  const pair = rfqPairFor(input.legs.give, input.legs.take);
3125
4023
  const rfqId = newRfqId();
3126
4024
  const secrets = await provisionClaimSecret(input.wallet);
3127
- const paymentHash = hex5.encode(secrets.paymentHash);
4025
+ const paymentHash = hex8.encode(secrets.paymentHash);
3128
4026
  const payoutAddress = await input.wallet.getAddress();
3129
4027
  const lightning = input.corridors.get("lightning").deps;
3130
4028
  const sealTo = sealingKey(lightning);
3131
- const claimPacket = sealTo ? await sealClaimPacket({ preimage: secrets.preimage, covclaimdPubkey: sealTo }) : void 0;
4029
+ const sealsAmount = pinned.on === "take" && input.legs.take.assetId === BTC_ASSET_ID;
4030
+ const binds = bindsClaimAmount();
4031
+ const claimPacket = sealTo !== void 0 && (!binds || sealsAmount) ? await sealClaimPacket({
4032
+ preimage: secrets.preimage,
4033
+ covclaimdPubkey: sealTo,
4034
+ minAmount: binds ? pinned.value : void 0
4035
+ }) : void 0;
3132
4036
  const wire = await input.transport.requestQuote(
3133
4037
  withCanonicalAmount(
3134
4038
  lightningReceiveRequest({
@@ -3136,10 +4040,8 @@ var quoteLightningReceive = async (input) => {
3136
4040
  paymentHash,
3137
4041
  payoutAddress,
3138
4042
  payoutPubkey: secrets.pubkey,
3139
- claimPacket: claimPacket?.ciphertext,
3140
- // Placeholder: the v1 builders type this field `number`, and the
3141
- // wire adapter re-encodes it as the canonical decimal string.
3142
- // Encoding it here as well would put the decision in two places.
4043
+ claimPacket: claimPacket?.packet,
4044
+ // Placeholder: `withCanonicalAmount` writes the canonical decimal string.
3143
4045
  amount: 0,
3144
4046
  amountSide: toRfqAmountSide(pinned.on)
3145
4047
  }),
@@ -3156,10 +4058,7 @@ var quoteLightningReceive = async (input) => {
3156
4058
  paymentHash,
3157
4059
  payoutPubkey: secrets.pubkey,
3158
4060
  payoutAddress,
3159
- operatorPubkey: covenant.operatorPubkey,
3160
- emulatorPubkey: covenant.emulatorPubkey,
3161
- claimDelay: covenant.claimDelay,
3162
- hrp: covenant.hrp
4061
+ ...covenant
3163
4062
  })
3164
4063
  );
3165
4064
  const { payDeadline } = verifyReceiveInvoiceFacts({
@@ -3177,9 +4076,7 @@ var quoteLightningReceive = async (input) => {
3177
4076
  });
3178
4077
  verifyQuoteTtl({
3179
4078
  quoteId: input.quoteId,
3180
- // The hold invoice's window is minutes where the quote's is an hour, so
3181
- // the deadline that binds this leg is the earlier of the two — which is
3182
- // what `payDeadline` already is.
4079
+ // The hold invoice's window (minutes) binds, not the quote's (an hour).
3183
4080
  expiresAt: payDeadline,
3184
4081
  now: input.now,
3185
4082
  floorSeconds: input.policy?.quoteTtlFloorSeconds
@@ -3217,11 +4114,7 @@ var quoteLightningReceive = async (input) => {
3217
4114
  card: input.candidate.card,
3218
4115
  rfqId,
3219
4116
  wire: parsed,
3220
- lockup: {
3221
- address: derived.address,
3222
- script: derived.script,
3223
- pkScript: derived.swapPkScript
3224
- },
4117
+ lockup: lockupOf(derived),
3225
4118
  contractParams: derived.contractParams,
3226
4119
  secrets,
3227
4120
  payoutAddress,
@@ -3248,7 +4141,7 @@ var quoteOnchainSend = async (input) => {
3248
4141
  const quoted = claimFee === void 0 ? pinned : { on: pinned.on, value: pinned.value + claimFee, source: pinned.source };
3249
4142
  const secrets = await provisionClaimSecret(input.wallet);
3250
4143
  const payoutKey = await provisionRefundKey(input.wallet);
3251
- const paymentHash = hex5.encode(secrets.paymentHash);
4144
+ const paymentHash = hex8.encode(secrets.paymentHash);
3252
4145
  const wire = await input.transport.requestQuote(
3253
4146
  withCanonicalAmount(
3254
4147
  onchainSendRequest({
@@ -3260,9 +4153,6 @@ var quoteOnchainSend = async (input) => {
3260
4153
  amount: 0,
3261
4154
  amountSide: toRfqAmountSide(pinned.on)
3262
4155
  }),
3263
- // The grossed pin, when one is active — see above. The solver's
3264
- // obligation is the HTLC amount; the recipient's own amount is
3265
- // that minus the claim's fee.
3266
4156
  quoted.value
3267
4157
  )
3268
4158
  );
@@ -3283,10 +4173,7 @@ var quoteOnchainSend = async (input) => {
3283
4173
  quote: wire,
3284
4174
  paymentHash,
3285
4175
  payoutPubkey: payoutKey.pubkey,
3286
- operatorPubkey: covenant.operatorPubkey,
3287
- emulatorPubkey: covenant.emulatorPubkey,
3288
- claimDelay: covenant.claimDelay,
3289
- hrp: covenant.hrp,
4176
+ ...covenant,
3290
4177
  l1Network,
3291
4178
  refundAddress: payoutKey.address,
3292
4179
  senderPubkey: secrets.pubkey
@@ -3302,14 +4189,20 @@ var quoteOnchainSend = async (input) => {
3302
4189
  direction: "send"
3303
4190
  }
3304
4191
  });
4192
+ verifyRefundWindow({
4193
+ refundLocktime: derived.refundLocktime,
4194
+ refundWithoutReceiverDelay: derived.refundWithoutReceiverDelay,
4195
+ now: input.now,
4196
+ maxSeconds: input.policy?.maxRefundWindowSeconds
4197
+ });
3305
4198
  verifyQuoteTtl({
3306
4199
  quoteId: input.quoteId,
3307
4200
  expiresAt: parsed.validUntil,
3308
4201
  now: input.now,
3309
4202
  floorSeconds: input.policy?.quoteTtlFloorSeconds
3310
4203
  });
3311
- const reportedTake = claimFee === void 0 ? parsed.take : parsed.take - claimFee;
3312
- const reportedFee = claimFee === void 0 ? parsed.give - parsed.take : parsed.give - parsed.take + claimFee;
4204
+ const reportedTake = parsed.take - (claimFee ?? 0n);
4205
+ const reportedFee = parsed.give - parsed.take + (claimFee ?? 0n);
3313
4206
  return {
3314
4207
  quote: {
3315
4208
  id: input.quoteId,
@@ -3323,9 +4216,7 @@ var quoteOnchainSend = async (input) => {
3323
4216
  market: input.market,
3324
4217
  solver: parsed.solver,
3325
4218
  expiresAt: parsed.validUntil,
3326
- // Read off the derivation and not off the wire: the field is
3327
- // optional there, a solver may carry it in the profile instead, and
3328
- // the derivation is what settles which one this covenant used.
4219
+ // Off the derivation, not the wire: it settles which locktime this covenant used.
3329
4220
  refundLocktime: derived.refundLocktime,
3330
4221
  fee: { amount: reportedFee, asset: input.endpoints.give.asset }
3331
4222
  },
@@ -3335,14 +4226,12 @@ var quoteOnchainSend = async (input) => {
3335
4226
  card: input.candidate.card,
3336
4227
  rfqId,
3337
4228
  wire: parsed,
3338
- lockup: {
3339
- address: derived.address,
3340
- script: derived.script,
3341
- pkScript: derived.swapPkScript
3342
- },
4229
+ lockup: lockupOf(derived),
3343
4230
  secrets,
3344
4231
  refundAddress: payoutKey.address,
3345
4232
  fundAmount: parsed.give,
4233
+ // Gross, not `reportedTake`: netting would accept an HTLC short by the fee.
4234
+ expectedAmount: parsed.take,
3346
4235
  payoutKey,
3347
4236
  payoutPkScript,
3348
4237
  htlc: derived.htlc,
@@ -3352,6 +4241,118 @@ var quoteOnchainSend = async (input) => {
3352
4241
  }
3353
4242
  };
3354
4243
  };
4244
+ var quoteOnchainReceive = async (input) => {
4245
+ const pinned = pinnedFor(input);
4246
+ const pair = rfqPairFor(input.legs.give, input.legs.take);
4247
+ const rfqId = newRfqId();
4248
+ const l1Network = l1NetworkFromArk(input.info.network);
4249
+ const secrets = await provisionClaimSecret(input.wallet);
4250
+ const refundKey = await provisionRefundKey(input.wallet);
4251
+ const paymentHash = hex8.encode(secrets.paymentHash);
4252
+ const payoutAddress = await input.wallet.getAddress();
4253
+ const refundPkScript = l1ScriptForAddress(await input.wallet.getBoardingAddress(), l1Network);
4254
+ const wire = await input.transport.requestQuote(
4255
+ withCanonicalAmount(
4256
+ onchainReceiveRequest({
4257
+ rfqId,
4258
+ paymentHash,
4259
+ payoutAddress,
4260
+ payoutPubkey: secrets.pubkey,
4261
+ refundPubkey: refundKey.pubkey,
4262
+ // Placeholder: `withCanonicalAmount` writes the canonical decimal string.
4263
+ amount: 0,
4264
+ amountSide: toRfqAmountSide(pinned.on)
4265
+ }),
4266
+ pinned.value
4267
+ )
4268
+ );
4269
+ verifyPair(wire.pair, pair);
4270
+ const parsed = parseRfqQuote(wire);
4271
+ verifyQuotedAmount({ pair, pinned, give: parsed.give, take: parsed.take });
4272
+ const covenant = covenantInputs(input);
4273
+ const derived = verifyingDerivation(
4274
+ () => deriveOnchainReceive({
4275
+ quote: wire,
4276
+ paymentHash,
4277
+ payoutPubkey: secrets.pubkey,
4278
+ payoutAddress,
4279
+ refundPubkey: refundKey.pubkey,
4280
+ ...covenant,
4281
+ l1Network
4282
+ })
4283
+ );
4284
+ verifySendWindow({
4285
+ quote: wire,
4286
+ quoteId: input.quoteId,
4287
+ now: input.now,
4288
+ onchain: {
4289
+ htlcLocktime: derived.htlcLocktime,
4290
+ minConfirmations: derived.minConfirmations,
4291
+ direction: "receive"
4292
+ }
4293
+ });
4294
+ verifyRefundWindow({
4295
+ refundLocktime: derived.htlcLocktime,
4296
+ now: input.now,
4297
+ maxSeconds: input.policy?.maxRefundWindowSeconds
4298
+ });
4299
+ verifyQuoteTtl({
4300
+ quoteId: input.quoteId,
4301
+ expiresAt: parsed.validUntil,
4302
+ now: input.now,
4303
+ floorSeconds: input.policy?.quoteTtlFloorSeconds
4304
+ });
4305
+ const artifact = {
4306
+ kind: "deposit",
4307
+ corridor: "onchain",
4308
+ address: derived.htlc.address,
4309
+ asset: input.endpoints.give.asset,
4310
+ amount: parsed.give,
4311
+ expiresAt: parsed.validUntil
4312
+ };
4313
+ return {
4314
+ quote: {
4315
+ id: input.quoteId,
4316
+ route: assembleRoute(
4317
+ {
4318
+ ...input.endpoints.give,
4319
+ instrument: {
4320
+ kind: "address",
4321
+ address: derived.htlc.address,
4322
+ amount: parsed.give
4323
+ }
4324
+ },
4325
+ { ...input.endpoints.take, instrument: { kind: "wallet" } }
4326
+ ),
4327
+ give: { asset: input.endpoints.give.asset, amount: parsed.give },
4328
+ take: { asset: input.endpoints.take.asset, amount: parsed.take },
4329
+ lock: { hash: paymentHash },
4330
+ market: input.market,
4331
+ solver: parsed.solver,
4332
+ expiresAt: parsed.validUntil,
4333
+ refundLocktime: derived.refundLocktime,
4334
+ artifact,
4335
+ fee: { amount: parsed.give - parsed.take, asset: input.endpoints.give.asset }
4336
+ },
4337
+ preparation: {
4338
+ backend: "rfq",
4339
+ route: "onchain->arkade",
4340
+ card: input.candidate.card,
4341
+ rfqId,
4342
+ wire: parsed,
4343
+ lockup: lockupOf(derived),
4344
+ secrets,
4345
+ payoutAddress,
4346
+ expectedAmount: parsed.take,
4347
+ refundKey,
4348
+ refundPkScript,
4349
+ htlc: derived.htlc,
4350
+ htlcParams: derived.htlcParams,
4351
+ l1Network,
4352
+ minConfirmations: derived.minConfirmations
4353
+ }
4354
+ };
4355
+ };
3355
4356
 
3356
4357
  // src/client/verbs.ts
3357
4358
  import { arkTarget as arkTarget2, resolveSendAmount as resolveSendAmount2 } from "@arkade-os/sdk";
@@ -3379,22 +4380,20 @@ var settle = async (deps, input, maxFee) => {
3379
4380
  return deps.accept(quote);
3380
4381
  };
3381
4382
  var pay = async (deps, destination, options = {}) => {
3382
- const arkade = arkTarget2(destination);
3383
- if (arkade !== void 0) {
4383
+ const arkade2 = arkTarget2(destination);
4384
+ if (arkade2 !== void 0) {
3384
4385
  const amount = resolveSendAmount2(
3385
4386
  "ark",
3386
4387
  destination,
3387
4388
  options.amount === void 0 ? void 0 : satsOf(options.amount, "amount")
3388
4389
  );
3389
- return { kind: "payment", txid: await deps.wallet.send({ address: arkade, amount }) };
4390
+ return { kind: "payment", txid: await deps.wallet.send({ address: arkade2, amount }) };
3390
4391
  }
3391
4392
  const swap = await settle(
3392
4393
  deps,
3393
4394
  {
3394
4395
  to: destination,
3395
- // `amountOn: "take"` because the number a caller writes beside a
3396
- // destination is what the recipient gets. An invoice pins the same
3397
- // leg by existing, which is why passing both is `AmountMismatch`.
4396
+ // The amount beside a destination is what the recipient gets.
3398
4397
  ...options.amount === void 0 ? {} : { amount: options.amount, amountOn: "take" }
3399
4398
  },
3400
4399
  options.maxFee
@@ -3408,8 +4407,7 @@ var receive = async (deps, options) => {
3408
4407
  via: options.via,
3409
4408
  ...options.asset === void 0 ? {} : { take: options.asset },
3410
4409
  amount: options.amount,
3411
- // The trader's side is the take leg: `receive({ amount })` is
3412
- // "credit me this much", not "let the payer send this much".
4410
+ // "Credit me this much", not "let the payer send this much".
3413
4411
  amountOn: "take"
3414
4412
  },
3415
4413
  options.maxFee
@@ -3434,21 +4432,26 @@ var exchange = async (deps, options) => settle(
3434
4432
 
3435
4433
  // src/client/transport.ts
3436
4434
  var attesting = (transport, responder) => Object.assign(transport, { attestedResponder: responder });
3437
- var nostrTransportFactory = async (rendezvous) => {
3438
- const { nostrRfqTransport } = await import("./nostr.js");
3439
- return attesting(
3440
- nostrRfqTransport({
3441
- relays: [...rendezvous.relays],
3442
- solverPubkey: rendezvous.solverPubkey
3443
- }),
3444
- rendezvous.solverPubkey
3445
- );
4435
+ var createNostrTransportFactory = (pool) => {
4436
+ return async (rendezvous) => {
4437
+ const { nostrRfqTransport } = await import("./nostr.js");
4438
+ return attesting(
4439
+ nostrRfqTransport({
4440
+ relays: [...rendezvous.relays],
4441
+ solverPubkey: rendezvous.solverPubkey,
4442
+ ...pool === void 0 ? {} : { pool }
4443
+ }),
4444
+ rendezvous.solverPubkey
4445
+ );
4446
+ };
3446
4447
  };
4448
+ var nostrTransportFactory = createNostrTransportFactory();
3447
4449
 
3448
4450
  // src/client/client.ts
3449
- import { hex as hex6 } from "@scure/base";
4451
+ import { hex as hex9 } from "@scure/base";
4452
+ import { captureSendDeadline } from "@arkade-os/sdk";
3450
4453
  var PREPARATIONS_HELD = 64;
3451
- var mintQuoteId = () => hex6.encode(crypto.getRandomValues(new Uint8Array(16)));
4454
+ var mintQuoteId = () => hex9.encode(crypto.getRandomValues(new Uint8Array(16)));
3452
4455
  var createSwapClient = (config) => {
3453
4456
  const { wallet } = config;
3454
4457
  const operator = config.operator ?? walletOperator(wallet);
@@ -3465,6 +4468,7 @@ var createSwapClient = (config) => {
3465
4468
  operator,
3466
4469
  ...config.repository === void 0 ? {} : { repository: config.repository },
3467
4470
  corridors: async () => (await resolved()).corridors,
4471
+ network: async () => (await resolved()).base.networkName,
3468
4472
  ...config.policy?.drive === void 0 ? {} : { mode: config.policy.drive },
3469
4473
  indexer
3470
4474
  });
@@ -3502,10 +4506,8 @@ var createSwapClient = (config) => {
3502
4506
  };
3503
4507
  const remember = (id, preparation) => {
3504
4508
  preparations.set(id, preparation);
3505
- while (preparations.size > PREPARATIONS_HELD) {
3506
- const oldest = preparations.keys().next();
3507
- if (oldest.done) break;
3508
- preparations.delete(oldest.value);
4509
+ if (preparations.size > PREPARATIONS_HELD) {
4510
+ preparations.delete(preparations.keys().next().value);
3509
4511
  }
3510
4512
  };
3511
4513
  const client = {
@@ -3514,6 +4516,7 @@ var createSwapClient = (config) => {
3514
4516
  return (await route(input, "resolve")).resolution;
3515
4517
  },
3516
4518
  quote: async (input) => {
4519
+ const assetPayment = captureAssetPayment(input.assetPayment);
3517
4520
  ensureLive("quote");
3518
4521
  const { corridors, discovery } = await resolved();
3519
4522
  let resolvedRoute = await route(input, "quote");
@@ -3539,7 +4542,9 @@ var createSwapClient = (config) => {
3539
4542
  corridors.get(resolvedRoute.legs.take.corridor);
3540
4543
  const quoteId = mintQuoteId();
3541
4544
  const now = Math.floor(Date.now() / 1e3);
3542
- if (resolvedRoute.pair === "arkade->arkade") {
4545
+ if (market.backend === "feed") {
4546
+ if (assetPayment !== void 0)
4547
+ throw new Error("assetPayment needs a negotiated BTC-to-asset market");
3543
4548
  const { quote, preparation } = await quoteFromFeed({
3544
4549
  quoteId,
3545
4550
  candidate: market,
@@ -3568,6 +4573,7 @@ var createSwapClient = (config) => {
3568
4573
  const { quote, preparation } = await quoteViaRfq({
3569
4574
  quoteId,
3570
4575
  route: resolvedRoute.pair,
4576
+ ...assetPayment === void 0 ? {} : { assetPayment },
3571
4577
  candidate: market,
3572
4578
  market: marketRef,
3573
4579
  legs: resolvedRoute.legs,
@@ -3577,6 +4583,7 @@ var createSwapClient = (config) => {
3577
4583
  info,
3578
4584
  corridors,
3579
4585
  transport,
4586
+ feed,
3580
4587
  ...config.policy === void 0 ? {} : { policy: config.policy },
3581
4588
  now
3582
4589
  });
@@ -3587,7 +4594,8 @@ var createSwapClient = (config) => {
3587
4594
  });
3588
4595
  }
3589
4596
  },
3590
- accept: async (quote) => {
4597
+ accept: async (quote, options) => {
4598
+ const validUntil = captureSendDeadline(options?.validUntil);
3591
4599
  ensureLive("accept");
3592
4600
  const { corridors } = await resolved();
3593
4601
  const drive2 = driving();
@@ -3595,6 +4603,7 @@ var createSwapClient = (config) => {
3595
4603
  const preparation = preparations.get(quote.id);
3596
4604
  return acceptQuote({
3597
4605
  quote,
4606
+ ...validUntil === void 0 ? {} : { validUntil },
3598
4607
  ...preparation === void 0 ? {} : { preparation },
3599
4608
  wallet,
3600
4609
  repository: config.repository,
@@ -3624,7 +4633,7 @@ var createSwapClient = (config) => {
3624
4633
  if (repository === void 0) return [];
3625
4634
  const drive2 = driving();
3626
4635
  await drive2.ready;
3627
- const records = await repository.getAllSwapRecords();
4636
+ const records = await collectSwapRecords(repository);
3628
4637
  const swaps = [];
3629
4638
  for (const record of records) {
3630
4639
  if (!readableRecord(record)) continue;
@@ -3638,10 +4647,10 @@ var createSwapClient = (config) => {
3638
4647
  },
3639
4648
  markets: async () => {
3640
4649
  ensureLive("markets");
3641
- const { discovery } = await resolved();
4650
+ const { base, discovery } = await resolved();
3642
4651
  const snapshot = await discovery.load();
3643
4652
  return usableMarkets(snapshot, config.policy).map(
3644
- (card) => cardMarketOf(card, snapshot.ref, marketKeyOf(card), marketBackendOf(card))
4653
+ (card) => marketOf(card, snapshot.ref, base.networkName)
3645
4654
  );
3646
4655
  },
3647
4656
  pay: async (destination, options) => {
@@ -3664,9 +4673,7 @@ var createSwapClient = (config) => {
3664
4673
  ensureLive("ready");
3665
4674
  return driving().ready;
3666
4675
  },
3667
- // `async`, so the refusal is a rejection rather than a synchronous
3668
- // throw: these are declared `Promise<void>` and a caller is entitled to
3669
- // `.catch()` them.
4676
+ // `async` so the refusal is a rejection, as the `Promise<void>` signature promises
3670
4677
  start: async () => {
3671
4678
  ensureLive("start");
3672
4679
  return driving().start();
@@ -3698,6 +4705,149 @@ var createSwapClient = (config) => {
3698
4705
  return client;
3699
4706
  };
3700
4707
 
4708
+ // src/offerFillPlan.ts
4709
+ import { base64 as base643, hex as hex10 } from "@scure/base";
4710
+ import { ArkAddress as ArkAddress7, Extension, P2A } from "@arkade-os/sdk";
4711
+ var OFFER_FILL_TEMPLATE = "offer-fill/1";
4712
+ var OFFER_FILL_OWNERS = [null, "solver", "sponsor"];
4713
+ async function buildOfferFillPlan(wallet, arkServerUrl, offerHex, opts) {
4714
+ const {
4715
+ fund: fund2,
4716
+ payoutScript,
4717
+ fundingTxid,
4718
+ fundingOutpoint,
4719
+ swapAddress,
4720
+ assetCarrierSats = ASSET_CARRIER_SATS,
4721
+ sponsor
4722
+ } = opts;
4723
+ const offer = decodeOffer(hex10.decode(offerHex));
4724
+ const contract = await connectFillContract(wallet, arkServerUrl, offer, { swapAddress });
4725
+ const vtxos = await contract.getUtxos();
4726
+ const vtxo = resolveDeposit(vtxos, { fundingTxid, fundingOutpoint });
4727
+ const solverPayout = payoutScript ?? ArkAddress7.decode(await wallet.getAddress()).pkScript;
4728
+ const sponsorLeg = sponsor !== void 0 ? normalizeSponsor(sponsor, assetCarrierSats) : void 0;
4729
+ const fill = contract.functions.fulfill();
4730
+ const layout = assembleOfferFill(fill, {
4731
+ offer,
4732
+ vtxo,
4733
+ solverFund: fund2,
4734
+ solverPayout,
4735
+ assetCarrierSats,
4736
+ sponsor: sponsorLeg
4737
+ });
4738
+ const { arkTx, checkpoints } = await fill.build();
4739
+ for (const [i, input] of layout.inputs.entries()) {
4740
+ if (!OFFER_FILL_OWNERS.includes(input.owner)) {
4741
+ throw new Error(`fill plan input ${i} names unknown owner ${input.owner}`);
4742
+ }
4743
+ }
4744
+ return toJointGraph(arkTx, checkpoints, layout, offer.wantAsset?.toString());
4745
+ }
4746
+ function normalizeSponsor(sponsor, assetCarrierSats) {
4747
+ return {
4748
+ fund: sponsor.fund,
4749
+ netContributionSats: sponsor.netContributionSats,
4750
+ fare: sponsor.fare !== void 0 ? {
4751
+ ...sponsor.fare.assetId !== void 0 ? { assetId: sponsor.fare.assetId, amount: sponsor.fare.amount } : {},
4752
+ script: sponsor.fare.script,
4753
+ sats: sponsor.fare.sats ?? assetCarrierSats
4754
+ } : void 0,
4755
+ changeScript: sponsor.changeScript,
4756
+ combineSatsFareWithChange: sponsor.combineSatsFareWithChange
4757
+ };
4758
+ }
4759
+ function toJointGraph(arkTx, checkpoints, layout, wantedAssetId) {
4760
+ if (arkTx.inputsLength !== layout.inputs.length) {
4761
+ throw new Error(
4762
+ `fill plan built ${arkTx.inputsLength} inputs, expected ${layout.inputs.length}`
4763
+ );
4764
+ }
4765
+ if (checkpoints.length !== layout.inputs.length) {
4766
+ throw new Error(
4767
+ `fill plan built ${checkpoints.length} checkpoints, expected ${layout.inputs.length}`
4768
+ );
4769
+ }
4770
+ layout.inputs.forEach((input, i) => {
4771
+ const spent = checkpoints[i].getInput(0);
4772
+ if (!(spent.txid instanceof Uint8Array) || hex10.encode(spent.txid) !== input.txid || spent.index !== input.vout) {
4773
+ throw new Error(`fill plan checkpoint ${i} does not spend ${input.txid}:${input.vout}`);
4774
+ }
4775
+ });
4776
+ const payments = layout.outputs.length;
4777
+ if (arkTx.outputsLength !== payments + 2) {
4778
+ throw new Error(
4779
+ `fill plan built ${arkTx.outputsLength} outputs, expected ${payments} payments plus extension and anchor`
4780
+ );
4781
+ }
4782
+ layout.outputs.forEach((expected, i) => {
4783
+ const out = arkTx.getOutput(i);
4784
+ if (!out?.script || hex10.encode(out.script) !== hex10.encode(expected.script)) {
4785
+ throw new Error(`fill plan output ${i} is not the ${expected.role} script`);
4786
+ }
4787
+ if (out.amount !== expected.sats) {
4788
+ throw new Error(
4789
+ `fill plan output ${i} carries ${out.amount}, expected ${expected.sats}`
4790
+ );
4791
+ }
4792
+ });
4793
+ const ext = arkTx.getOutput(payments);
4794
+ if (!ext?.script || !Extension.isExtension(ext.script)) {
4795
+ throw new Error(`fill plan output ${payments} is not the extension packet`);
4796
+ }
4797
+ const anchor = arkTx.getOutput(payments + 1);
4798
+ if (!anchor?.script || hex10.encode(anchor.script) !== hex10.encode(P2A.script) || anchor.amount !== P2A.amount) {
4799
+ throw new Error(`fill plan output ${payments + 1} is not the anchor`);
4800
+ }
4801
+ const packet = Extension.fromTx(arkTx).getAssetPacket();
4802
+ for (const group of packet?.groups ?? []) {
4803
+ if (group.assetId === null) throw new Error("fill plan carries an issuance group");
4804
+ const assetId = group.assetId.toString();
4805
+ const unitsIn = group.inputs.reduce((s, input) => s + input.amount, BigInt(0));
4806
+ const unitsOut = group.outputs.reduce((s, output) => s + output.amount, BigInt(0));
4807
+ if (unitsIn !== unitsOut) {
4808
+ throw new Error(`fill plan asset ${assetId} mints ${unitsOut - unitsIn} units`);
4809
+ }
4810
+ for (const output of group.outputs) {
4811
+ const hosted = arkTx.getOutput(output.vout);
4812
+ if (output.vout >= payments || !hosted?.script || Extension.isExtension(hosted.script)) {
4813
+ throw new Error(
4814
+ `fill plan asset ${assetId} pays nonexistent output ${output.vout}`
4815
+ );
4816
+ }
4817
+ }
4818
+ }
4819
+ if (wantedAssetId !== void 0) {
4820
+ if ((packet?.groups.length ?? 0) === 0) {
4821
+ throw new Error(`fill plan carries no asset group, expected ${wantedAssetId}`);
4822
+ }
4823
+ const first = packet?.groups[0].assetId?.toString();
4824
+ if (first !== wantedAssetId) {
4825
+ throw new Error(
4826
+ `fill plan asset group 0 is ${first}, expected the wanted ${wantedAssetId}`
4827
+ );
4828
+ }
4829
+ }
4830
+ const arkTxPsbt = base643.encode(arkTx.toPSBT());
4831
+ const checkpointPsbts = checkpoints.map((c) => base643.encode(c.toPSBT()));
4832
+ const inputOwners = layout.inputs.map((input) => input.owner);
4833
+ const graph = {
4834
+ arkTx: arkTxPsbt,
4835
+ checkpoints: checkpointPsbts,
4836
+ graphId: digestJointGraph(
4837
+ { arkTx: arkTxPsbt, checkpoints: checkpointPsbts, inputOwners },
4838
+ OFFER_FILL_TEMPLATE
4839
+ ),
4840
+ inputOwners
4841
+ };
4842
+ return deepFreeze(graph);
4843
+ }
4844
+ function verifyOfferFillPlan(plan) {
4845
+ if (!plan || typeof plan !== "object" || !Array.isArray(plan.inputOwners)) return false;
4846
+ const allowed = OFFER_FILL_OWNERS;
4847
+ if (!plan.inputOwners.every((owner) => allowed.includes(owner))) return false;
4848
+ return verifyJointGraph(plan, OFFER_FILL_TEMPLATE);
4849
+ }
4850
+
3701
4851
  export {
3702
4852
  RAILS,
3703
4853
  BITCOIN_RAILS,
@@ -3712,7 +4862,10 @@ export {
3712
4862
  bitcoinNetworkOf,
3713
4863
  assetPartOf,
3714
4864
  sameAsset,
4865
+ btcAssetPart,
3715
4866
  btcOn,
4867
+ isBtcAsset,
4868
+ isBtcAssetLenient,
3716
4869
  arkadeAsset,
3717
4870
  issuanceOf,
3718
4871
  AmbiguousDestination,
@@ -3736,30 +4889,11 @@ export {
3736
4889
  INDEXED_NETWORKS,
3737
4890
  isIndexedNetwork,
3738
4891
  canonicalAssetId,
3739
- AmountFormatError,
3740
- Amount,
3741
- toAtomicDecimal,
3742
- fromAtomicDecimal,
3743
- isAtomicDecimal,
3744
4892
  toRfqAmountSide,
3745
4893
  fromRfqAmountSide,
3746
4894
  encodeRfqAmount,
3747
4895
  decodeRfqAmount,
3748
4896
  toSafeNumber,
3749
- assetSwapIdOf,
3750
- OFFER_SWAP_ID_PREFIX,
3751
- RFQ_SWAP_ID_PREFIX,
3752
- familyOfSwapId,
3753
- quoteIdOfSwapId,
3754
- recordEndpoint,
3755
- recordInstrument,
3756
- instrumentOf,
3757
- recordArtifact,
3758
- artifactOf,
3759
- recordLeg,
3760
- legOf,
3761
- swapOf,
3762
- fundsFromWallet,
3763
4897
  conflictingFields,
3764
4898
  acceptQuote,
3765
4899
  swapRecordOf,
@@ -3767,6 +4901,7 @@ export {
3767
4901
  railOfCorridor,
3768
4902
  corridorOfRail,
3769
4903
  publicAssetId,
4904
+ cardLegAssetId,
3770
4905
  aliasTableFrom,
3771
4906
  scopedToRail,
3772
4907
  arkadeCorridor,
@@ -3787,11 +4922,15 @@ export {
3787
4922
  splitRecords,
3788
4923
  rfqRecordOf,
3789
4924
  withRfqState,
4925
+ pageRfqRecords,
3790
4926
  corridorRecordStore,
3791
4927
  offerFactsOf,
3792
4928
  offerRecordSource,
3793
4929
  applyOfferSpend,
3794
- withOfferStatus,
4930
+ withDepositFate,
4931
+ fateMoved,
4932
+ restoredOfferRecord,
4933
+ restoredCorridorRecord,
3795
4934
  walletLockupIndexer,
3796
4935
  cancelSwap,
3797
4936
  SwapDriveRefusedError,
@@ -3806,8 +4945,10 @@ export {
3806
4945
  marketRefOf,
3807
4946
  cardMarketOf,
3808
4947
  isCardMarket,
4948
+ marketOf,
3809
4949
  assembleRoute,
3810
4950
  resolveRoute,
4951
+ DEFAULT_MAX_REFUND_WINDOW_SECONDS,
3811
4952
  verifyResponder,
3812
4953
  verifyPair,
3813
4954
  verifyingDerivation,
@@ -3816,10 +4957,19 @@ export {
3816
4957
  verifySendInvoice,
3817
4958
  verifyReceiveInvoiceFacts,
3818
4959
  verifyQuoteTtl,
4960
+ verifyRefundWindow,
3819
4961
  verifyQuotedAmount,
4962
+ verifyCrossAssetAmount,
4963
+ verifiedCarrierSats,
3820
4964
  FEED_TTL_MS,
3821
4965
  feedFetch,
3822
4966
  quoteFromFeed,
4967
+ feedSpread,
4968
+ verifyPlanLegs,
4969
+ digestJointGraph,
4970
+ verifyJointGraph,
4971
+ deepFreeze,
4972
+ unsignedPsbtBytes,
3823
4973
  satsOf,
3824
4974
  PAYMENT_STATUS,
3825
4975
  paymentStatusOf,
@@ -3827,6 +4977,7 @@ export {
3827
4977
  SwapPaymentFailedError,
3828
4978
  railAvailable,
3829
4979
  receiverExact,
4980
+ quoteMeta,
3830
4981
  swapHandle,
3831
4982
  ONCHAIN_SWAP_RAIL,
3832
4983
  claimFeeSats,
@@ -3841,6 +4992,11 @@ export {
3841
4992
  receive,
3842
4993
  exchange,
3843
4994
  attesting,
4995
+ createNostrTransportFactory,
3844
4996
  nostrTransportFactory,
3845
- createSwapClient
4997
+ createSwapClient,
4998
+ OFFER_FILL_TEMPLATE,
4999
+ OFFER_FILL_OWNERS,
5000
+ buildOfferFillPlan,
5001
+ verifyOfferFillPlan
3846
5002
  };