@arkade-os/swap 0.1.0-rc.25 → 0.1.0-rc.27

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 (38) hide show
  1. package/dist/advanced.cjs +2009 -663
  2. package/dist/advanced.d.cts +9 -8
  3. package/dist/advanced.d.ts +9 -8
  4. package/dist/advanced.js +41 -23
  5. package/dist/{chunk-UFJEO4VV.js → chunk-4X56MN56.js} +578 -101
  6. package/dist/{chunk-5PI54AVY.js → chunk-BWUC2LDD.js} +593 -298
  7. package/dist/{chunk-CZHB3ZDG.js → chunk-VFZJNU27.js} +705 -253
  8. package/dist/index.cjs +2000 -656
  9. package/dist/index.d.cts +6 -6
  10. package/dist/index.d.ts +6 -6
  11. package/dist/index.js +29 -13
  12. package/dist/{lockupContract-5r5RlgOJ.d.cts → lockupContract-CAjvaCVw.d.ts} +8 -1
  13. package/dist/{lockupContract-5r5RlgOJ.d.ts → lockupContract-DZaNiqP-.d.cts} +8 -1
  14. package/dist/node/index.d.cts +48 -25
  15. package/dist/node/index.d.ts +48 -25
  16. package/dist/nostr.cjs +39 -0
  17. package/dist/nostr.d.cts +1 -1
  18. package/dist/nostr.d.ts +1 -1
  19. package/dist/nostr.js +1 -1
  20. package/dist/{offer-N2oXLfLX.d.cts → offer-BwUhEawd.d.cts} +26 -18
  21. package/dist/{offer-cE8qJmbC.d.ts → offer-v7vBCPmQ.d.ts} +26 -18
  22. package/dist/{errors-Ckp_FRdo.d.ts → offerFillPlan-BGeAXIna.d.ts} +55 -6
  23. package/dist/{errors-DXjXCHYp.d.cts → offerFillPlan-BYw1EWEj.d.cts} +55 -6
  24. package/dist/protocol.cjs +872 -451
  25. package/dist/protocol.d.cts +25 -39
  26. package/dist/protocol.d.ts +25 -39
  27. package/dist/protocol.js +14 -12
  28. package/dist/repositories/realm/index.d.cts +2 -2
  29. package/dist/repositories/realm/index.d.ts +2 -2
  30. package/dist/repositories/sqlite/index.d.cts +2 -2
  31. package/dist/repositories/sqlite/index.d.ts +2 -2
  32. package/dist/{repository-yN-i_u-0.d.cts → repository-D2emdY6f.d.cts} +124 -121
  33. package/dist/{repository-DITDhUdX.d.ts → repository-YEQaxJro.d.ts} +124 -121
  34. package/dist/{rfq-BgdgO9OO.d.cts → rfq-CRiAHBBH.d.cts} +16 -2
  35. package/dist/{rfq-BgdgO9OO.d.ts → rfq-CRiAHBBH.d.ts} +16 -2
  36. package/dist/{watch-Bws1mS0R.d.cts → watch-BwbZkceT.d.cts} +1 -1
  37. package/dist/{watch-G0Z7yJZb.d.ts → watch-CjEsO0Qh.d.ts} +1 -1
  38. package/package.json +2 -2
package/dist/advanced.cjs CHANGED
@@ -121,6 +121,16 @@ var init_swap_want_btc_program = __esm({
121
121
  });
122
122
 
123
123
  // src/coverage.ts
124
+ function markIssued(script, issued, options) {
125
+ const scope = options.scope ?? legacyScope;
126
+ const issuedAt = issuedByScope.get(scope) ?? /* @__PURE__ */ new Map();
127
+ const outstanding = issuedAt.get(script) ?? { issuedAt: void 0, ids: /* @__PURE__ */ new Set() };
128
+ const id = options.coverageId;
129
+ if (id === void 0) outstanding.issuedAt = issued;
130
+ else outstanding.ids.add(id);
131
+ issuedAt.set(script, outstanding);
132
+ issuedByScope.set(scope, issuedAt);
133
+ }
124
134
  async function serialize(script, task) {
125
135
  const previous = inFlight.get(script) ?? Promise.resolve();
126
136
  const result = previous.then(task, task);
@@ -136,25 +146,35 @@ async function serialize(script, task) {
136
146
  });
137
147
  return result;
138
148
  }
139
- function addressOutstanding(swaps, script) {
149
+ function addressOutstanding(swaps, script, scope) {
150
+ const issuedAt = issuedByScope.get(scope);
151
+ if (issuedAt === void 0) return false;
140
152
  const issued = issuedAt.get(script);
141
153
  if (issued === void 0) return false;
142
- if (swaps.some((s) => s.swapPkScript === script && s.createdAt >= issued)) {
143
- issuedAt.delete(script);
144
- return false;
154
+ for (const swap of swaps) {
155
+ if (swap.swapPkScript !== script) continue;
156
+ if (swap.id !== void 0) issued.ids.delete(swap.id);
157
+ if (issued.issuedAt !== void 0 && swap.createdAt >= issued.issuedAt) {
158
+ issued.issuedAt = void 0;
159
+ }
145
160
  }
146
- return true;
161
+ if (issued.ids.size > 0 || issued.issuedAt !== void 0) return true;
162
+ issuedAt.delete(script);
163
+ return false;
147
164
  }
148
- async function promoteOfferContract(manager, script, issued = Date.now()) {
165
+ async function promoteOfferContract(manager, script, issued = Date.now(), options = {}) {
149
166
  await serialize(script, async () => {
150
167
  await manager.setContractWatchState(script, "watched");
151
- issuedAt.set(script, issued);
168
+ if (options.restore && options.coverageId !== void 0) return;
169
+ markIssued(script, issued, options);
152
170
  });
153
171
  }
154
- async function retireOfferContract(manager, swaps, script) {
172
+ async function retireOfferContract(manager, swaps, script, options = {}) {
155
173
  await serialize(script, async () => {
156
- if (swaps.some((s) => s.swapPkScript === script && !RETIRABLE.includes(s.status))) return;
157
- if (addressOutstanding(swaps, script)) return;
174
+ const records = typeof swaps === "function" ? await swaps() : swaps;
175
+ const outstanding = addressOutstanding(records, script, options.scope ?? legacyScope);
176
+ if (records.some((s) => s.swapPkScript === script && !RETIRABLE.includes(s.status))) return;
177
+ if (outstanding) return;
158
178
  try {
159
179
  await manager.setContractWatchState(script, "retained");
160
180
  } catch (err) {
@@ -162,20 +182,68 @@ async function retireOfferContract(manager, swaps, script) {
162
182
  }
163
183
  });
164
184
  }
165
- async function retireSettledOfferContracts(manager, swaps) {
185
+ async function retireSettledOfferContracts(manager, swaps, options = {}) {
166
186
  const settled = new Set(
167
187
  swaps.filter((s) => RETIRABLE.includes(s.status)).map((s) => s.swapPkScript)
168
188
  );
169
- for (const script of settled) await retireOfferContract(manager, swaps, script);
189
+ for (const script of settled) await retireOfferContract(manager, swaps, script, options);
170
190
  }
171
- var RETIRABLE, LOCKUP_RETIRABLE, issuedAt, inFlight;
191
+ var RETIRABLE, LOCKUP_RETIRABLE, legacyScope, issuedByScope, inFlight, registerContractCoverage;
172
192
  var init_coverage = __esm({
173
193
  "src/coverage.ts"() {
174
194
  "use strict";
175
195
  RETIRABLE = ["fulfilled", "cancelled"];
176
196
  LOCKUP_RETIRABLE = ["settled", "refunded"];
177
- issuedAt = /* @__PURE__ */ new Map();
197
+ legacyScope = {};
198
+ issuedByScope = /* @__PURE__ */ new WeakMap();
178
199
  inFlight = /* @__PURE__ */ new Map();
200
+ registerContractCoverage = async (script, register, options = {}) => serialize(script, async () => {
201
+ const row = await register();
202
+ markIssued(script, Date.now(), options);
203
+ return row;
204
+ });
205
+ }
206
+ });
207
+
208
+ // src/rfqCorridor.ts
209
+ var RfqCorridorRegistry, rfqCorridorHandlers;
210
+ var init_rfqCorridor = __esm({
211
+ "src/rfqCorridor.ts"() {
212
+ "use strict";
213
+ RfqCorridorRegistry = class {
214
+ handlers = /* @__PURE__ */ new Map();
215
+ register(handler) {
216
+ if (this.handlers.has(handler.kind)) {
217
+ throw new Error(
218
+ `RFQ corridor handler for kind '${handler.kind}' is already registered`
219
+ );
220
+ }
221
+ this.handlers.set(handler.kind, handler);
222
+ }
223
+ /** A bare `string` on purpose: the key comes off a stored record, and narrowing it to the
224
+ * `kind` union would read as a check already made. */
225
+ get(kind) {
226
+ return this.handlers.get(kind);
227
+ }
228
+ /** The handler for a kind, or a loud failure naming the registered kinds. */
229
+ getOrThrow(kind) {
230
+ const handler = this.get(kind);
231
+ if (!handler) {
232
+ throw new Error(
233
+ `no RFQ corridor handler registered for kind '${kind}'; registered: ${this.registeredKinds().join(", ") || "none"}`
234
+ );
235
+ }
236
+ return handler;
237
+ }
238
+ registeredKinds() {
239
+ return [...this.handlers.keys()];
240
+ }
241
+ /** Test seam, mirroring the contract registry's. */
242
+ unregister(kind) {
243
+ return this.handlers.delete(kind);
244
+ }
245
+ };
246
+ rfqCorridorHandlers = new RfqCorridorRegistry();
179
247
  }
180
248
  });
181
249
 
@@ -310,6 +378,96 @@ var init_store = __esm({
310
378
  }
311
379
  });
312
380
 
381
+ // src/rfqProfileParts.ts
382
+ var rfqSecretsProfile, parseHex32, parseSigner, parsePayoutAddress, parseHashlock, hydrateHashlock, rfqSignerOf, rfqClaimSecretOf, rfqClaimDestinationOf;
383
+ var init_rfqProfileParts = __esm({
384
+ "src/rfqProfileParts.ts"() {
385
+ "use strict";
386
+ init_rfqCorridor();
387
+ init_store();
388
+ rfqSecretsProfile = (secrets, paymentHash) => {
389
+ const { signingDescriptor, ...preimage } = swapSecretsToRecord(secrets);
390
+ return {
391
+ signer: { signingDescriptor },
392
+ ...paymentHash ? { hashlock: { paymentHash, ...preimage } } : {}
393
+ };
394
+ };
395
+ parseHex32 = (value, field) => {
396
+ if (typeof value !== "string" || !/^[0-9a-fA-F]{64}$/.test(value)) {
397
+ throw new Error(`${field} must be 32 bytes of hex, got ${JSON.stringify(value)}`);
398
+ }
399
+ return value.toLowerCase();
400
+ };
401
+ parseSigner = (value) => {
402
+ const signingDescriptor = value?.signingDescriptor;
403
+ if (typeof signingDescriptor !== "string" || signingDescriptor.length === 0) {
404
+ throw new Error(
405
+ `rfq profile.signer carries no signingDescriptor (got ${JSON.stringify(signingDescriptor)})`
406
+ );
407
+ }
408
+ return { signingDescriptor };
409
+ };
410
+ parsePayoutAddress = (value, kind) => {
411
+ if (typeof value !== "string" || value.length === 0) {
412
+ throw new Error(
413
+ `this ${kind} record's claim destination is unusable: expected an Arkade address, got ${JSON.stringify(value)}`
414
+ );
415
+ }
416
+ return value;
417
+ };
418
+ parseHashlock = (value) => {
419
+ const raw = value ?? {};
420
+ const hashlock = {
421
+ paymentHash: parseHex32(raw.paymentHash, "rfq profile.hashlock.paymentHash")
422
+ };
423
+ if (raw.preimageHex !== void 0) {
424
+ hashlock.preimageHex = parseHex32(raw.preimageHex, "rfq profile.hashlock.preimageHex");
425
+ }
426
+ if (raw.preimageSaltHex !== void 0) {
427
+ hashlock.preimageSaltHex = parseHex32(
428
+ raw.preimageSaltHex,
429
+ "rfq profile.hashlock.preimageSaltHex"
430
+ );
431
+ }
432
+ return hashlock;
433
+ };
434
+ hydrateHashlock = (profile) => {
435
+ try {
436
+ return { paymentHash: parseHashlock(profile.hashlock).paymentHash };
437
+ } catch (cause) {
438
+ throw new Error(
439
+ `rfq record carries no usable hashlock; it cannot verify a preimage: ${String(cause)}`,
440
+ { cause }
441
+ );
442
+ }
443
+ };
444
+ rfqSignerOf = (record) => {
445
+ const signer = record.profile.signer;
446
+ if (signer === void 0) return void 0;
447
+ return parseSigner(signer);
448
+ };
449
+ rfqClaimSecretOf = (record) => {
450
+ const handler = rfqCorridorHandlers.getOrThrow(record.kind);
451
+ if (!handler.claimSecret) return void 0;
452
+ try {
453
+ const claim = handler.claimSecret(record.profile);
454
+ return { ...parseSigner(claim), ...parseHashlock(claim) };
455
+ } catch (cause) {
456
+ throw new PreimageNotRecoverableError(
457
+ "malformed-record",
458
+ `this ${record.kind} record's claim secret is unreadable: ${String(cause)}`,
459
+ { cause }
460
+ );
461
+ }
462
+ };
463
+ rfqClaimDestinationOf = (record) => {
464
+ const handler = rfqCorridorHandlers.getOrThrow(record.kind);
465
+ if (!handler.claimDestination) return void 0;
466
+ return parsePayoutAddress(handler.claimDestination(record.profile), record.kind);
467
+ };
468
+ }
469
+ });
470
+
313
471
  // src/offer.ts
314
472
  function withExitClosure(program, exit) {
315
473
  if (!exit) return program;
@@ -487,13 +645,16 @@ function decodeExitDelay(value) {
487
645
  if (!type) throw new Error(`unknown exitDelay locktime type: 0x${value[0].toString(16)}`);
488
646
  return { type, value: readU64(value.subarray(1)) };
489
647
  }
490
- async function registerOfferContract(wallet, info, binding, operatorPubkey, expectedPkScript) {
648
+ async function registerOfferContract(wallet, info, binding, operatorPubkey, expectedPkScript, options = {}) {
491
649
  const contractManager = await wallet.getContractManager();
492
650
  const client = await derivingClient(wallet, info, contractManager);
493
651
  await contractManager.createContract(
494
652
  offerContractParams(client, binding, operatorPubkey, expectedPkScript)
495
653
  );
496
- await promoteOfferContract(contractManager, import_base2.hex.encode(expectedPkScript));
654
+ await promoteOfferContract(contractManager, import_base2.hex.encode(expectedPkScript), void 0, {
655
+ ...options,
656
+ scope: wallet
657
+ });
497
658
  }
498
659
  function offerContractParams(client, binding, operatorPubkey, expectedPkScript) {
499
660
  const { program, args, keys } = swapProgramBinding(binding, operatorPubkey);
@@ -526,6 +687,7 @@ async function restoreOfferCoverage(wallet, swaps) {
526
687
  covenants.push({
527
688
  script: swap.swapPkScript,
528
689
  issued: swap.createdAt,
690
+ coverageId: swap.coverageId,
529
691
  params: offerContractParams(
530
692
  client,
531
693
  binding,
@@ -544,7 +706,11 @@ async function restoreOfferCoverage(wallet, swaps) {
544
706
  for (const contract of params) await contractManager.createContract(contract);
545
707
  }
546
708
  for (const covenant of covenants) {
547
- await promoteOfferContract(contractManager, covenant.script, covenant.issued);
709
+ await promoteOfferContract(contractManager, covenant.script, covenant.issued, {
710
+ coverageId: covenant.coverageId,
711
+ restore: true,
712
+ scope: wallet
713
+ });
548
714
  }
549
715
  }
550
716
  function serverExitDelay(delay) {
@@ -555,9 +721,9 @@ function serverExitDelay(delay) {
555
721
  }
556
722
  return assertExitDelay({ value: delay, type: delay < BigInt(512) ? "blocks" : "seconds" });
557
723
  }
558
- async function createOffer(wallet, params) {
724
+ async function createOffer(wallet, params, options = {}) {
559
725
  const derived = await deriveOffer(wallet, params);
560
- await registerDerivedOffer(wallet, derived);
726
+ await registerDerivedOffer(wallet, derived, options);
561
727
  return {
562
728
  offerHex: derived.offerHex,
563
729
  extension: derived.extension,
@@ -565,6 +731,29 @@ async function createOffer(wallet, params) {
565
731
  swapPkScript: derived.swapPkScript
566
732
  };
567
733
  }
734
+ function resolveReceivePkScript(receiveAddress, walletPkScript, hrp, serverPubKey) {
735
+ if (receiveAddress === void 0) return walletPkScript;
736
+ let address;
737
+ try {
738
+ address = import_sdk3.ArkAddress.decode(receiveAddress);
739
+ } catch (cause) {
740
+ throw new Error("receiveAddress is not a valid Arkade address", { cause });
741
+ }
742
+ if (address.hrp !== hrp) {
743
+ throw new Error(
744
+ `receiveAddress network ${address.hrp} does not match the server network ${hrp}`
745
+ );
746
+ }
747
+ if (address.encode() !== receiveAddress) {
748
+ throw new Error("receiveAddress is not in canonical bech32m form");
749
+ }
750
+ if (import_base2.hex.encode(address.serverPubKey) !== import_base2.hex.encode(serverPubKey)) {
751
+ throw new Error(
752
+ "receiveAddress is bound to a different server public key than the connected server"
753
+ );
754
+ }
755
+ return address.pkScript;
756
+ }
568
757
  async function deriveOffer(wallet, params) {
569
758
  if (Boolean(params.wantAsset) === Boolean(params.offerAsset)) {
570
759
  throw new Error("set exactly one of wantAsset (BTC->asset) or offerAsset (asset->BTC)");
@@ -593,7 +782,12 @@ async function deriveOffer(wallet, params) {
593
782
  wantAmount: params.wantAmount,
594
783
  wantAsset: params.wantAsset,
595
784
  offerAsset: params.offerAsset,
596
- makerPkScript: maker.pkScript,
785
+ makerPkScript: resolveReceivePkScript(
786
+ params.receiveAddress,
787
+ maker.pkScript,
788
+ network.hrp,
789
+ operatorPubKey
790
+ ),
597
791
  makerPublicKey: maker.publicKey,
598
792
  emulatorPubkey: emuKey,
599
793
  // checked before registration below. @see assertExitDelay
@@ -614,17 +808,18 @@ async function deriveOffer(wallet, params) {
614
808
  operatorPubkey: operatorPubKey
615
809
  });
616
810
  }
617
- async function registerDerivedOffer(wallet, derived) {
811
+ async function registerDerivedOffer(wallet, derived, options = {}) {
618
812
  await registerOfferContract(
619
813
  wallet,
620
814
  derived.info,
621
815
  derived.binding,
622
816
  derived.operatorPubkey,
623
- derived.swapPkScript
817
+ derived.swapPkScript,
818
+ options
624
819
  );
625
820
  }
626
821
  async function prepareOfferCancel(wallet, offerHex, opts) {
627
- const { fundingTxid, swapAddress } = opts;
822
+ const { fundingTxid, fundingOutpoint, swapAddress } = opts;
628
823
  const offer = decodeOffer(import_base2.hex.decode(offerHex));
629
824
  const [contractManager, info, reader, broadcaster] = await Promise.all([
630
825
  wallet.getContractManager(),
@@ -654,13 +849,7 @@ async function prepareOfferCancel(wallet, offerHex, opts) {
654
849
  }
655
850
  const contract = new import_sdk3.arkade.ArkadeContract(client, program, args, keys);
656
851
  const [vtxos, makerAddress] = await Promise.all([contract.getUtxos(), wallet.getAddress()]);
657
- if (!fundingTxid && vtxos.length > 1) {
658
- throw new Error(
659
- "multiple spendable deposits at the swap address \u2014 pass fundingTxid to select one"
660
- );
661
- }
662
- const vtxo = fundingTxid ? vtxos.find((v) => v.txid === fundingTxid) : vtxos[0];
663
- if (!vtxo) throw new NoSpendableDepositError();
852
+ const vtxo = resolveDeposit(vtxos, { fundingTxid, fundingOutpoint });
664
853
  const makerPkScript = import_sdk3.ArkAddress.decode(makerAddress).pkScript;
665
854
  const cancel = contract.functions.cancel().from({ txid: vtxo.txid, vout: vtxo.vout, value: vtxo.value }).to(makerPkScript, BigInt(vtxo.value));
666
855
  for (const a of vtxo.assets ?? []) {
@@ -676,7 +865,339 @@ async function prepareOfferCancel(wallet, offerHex, opts) {
676
865
  send: async () => (await cancel.send()).txid
677
866
  };
678
867
  }
679
- var import_base2, import_utils, import_sdk3, swapPrograms, OFFER_PACKET_TYPE, FIELDS, EXIT_TYPES, NAMES, readU64, setRatio, OFFER_CONTRACT_LABEL, OFFER_CONTRACT_KIND, derivingClient, NoSpendableDepositError, OfferCovenantMismatchError, ASSET_CARRIER_SATS;
868
+ async function connectFillContract(wallet, arkServerUrl, offer, opts = {}) {
869
+ const { swapAddress, emulator, emulatorPubkey } = opts;
870
+ const contractManager = await wallet.getContractManager();
871
+ const client = await import_sdk3.arkade.Arkade.connect({
872
+ arkade: new import_sdk3.RestArkProvider(arkServerUrl),
873
+ indexer: new import_sdk3.RestIndexerProvider(arkServerUrl),
874
+ identity: wallet.identity,
875
+ contractManager,
876
+ ...emulator !== void 0 ? {
877
+ emulator: typeof emulator === "string" ? new import_sdk3.RestEmulatorProvider(emulator) : emulator
878
+ } : {},
879
+ ...emulatorPubkey ? { emulatorPubkey } : {}
880
+ });
881
+ const serverKey = swapAddress ? import_sdk3.ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
882
+ const { program, args, keys } = swapProgramBinding(offer, serverKey);
883
+ const rebuilt = new import_sdk3.arkade.ArkadeProgramScript(program, args, keys);
884
+ if (import_base2.hex.encode(rebuilt.pkScript) !== import_base2.hex.encode(offer.swapPkScript)) {
885
+ throw new Error(
886
+ "rebuilt covenant does not match the offer's swapPkScript \u2014 the server signing key has likely rotated since funding; pass swapAddress (the funded address) to pin the original key"
887
+ );
888
+ }
889
+ return new import_sdk3.arkade.ArkadeContract(client, program, args, keys);
890
+ }
891
+ function resolveDeposit(vtxos, sel) {
892
+ const { fundingTxid, fundingOutpoint } = sel;
893
+ if (fundingOutpoint !== void 0) {
894
+ const txid = parseHex32(fundingOutpoint.txid, "fundingOutpoint.txid");
895
+ const vout = assertVout(fundingOutpoint.vout, "fundingOutpoint.vout");
896
+ if (fundingTxid !== void 0 && fundingTxid.toLowerCase() !== txid) {
897
+ throw new Error(
898
+ `fundingTxid ${fundingTxid} does not match fundingOutpoint ${txid}:${vout} \u2014 pass one deposit reference`
899
+ );
900
+ }
901
+ const vtxo2 = vtxos.find((v) => v.txid.toLowerCase() === txid && v.vout === vout);
902
+ if (!vtxo2) throw new NoSpendableDepositError();
903
+ return vtxo2;
904
+ }
905
+ if (fundingTxid !== void 0) {
906
+ const txid = parseHex32(fundingTxid, "fundingTxid");
907
+ const matches = vtxos.filter((v) => v.txid.toLowerCase() === txid);
908
+ if (matches.length > 1) {
909
+ throw new Error(
910
+ `multiple spendable deposits share fundingTxid ${txid} \u2014 pass fundingOutpoint to select one`
911
+ );
912
+ }
913
+ const [vtxo2] = matches;
914
+ if (!vtxo2) throw new NoSpendableDepositError();
915
+ return vtxo2;
916
+ }
917
+ if (vtxos.length > 1) {
918
+ throw new Error(
919
+ "multiple spendable deposits at the swap address \u2014 pass fundingTxid to select one"
920
+ );
921
+ }
922
+ const [vtxo] = vtxos;
923
+ if (!vtxo) throw new NoSpendableDepositError();
924
+ return vtxo;
925
+ }
926
+ function assembleOfferFill(fill, args) {
927
+ const {
928
+ offer,
929
+ vtxo,
930
+ solverFund,
931
+ solverPayout,
932
+ assetCarrierSats = ASSET_CARRIER_SATS,
933
+ sponsor
934
+ } = args;
935
+ const wantedAssetId = offer.wantAsset?.toString();
936
+ if (solverFund.length === 0) {
937
+ throw new Error("fillOffer needs coins to pay wantAmount with \u2014 `fund` is empty");
938
+ }
939
+ solverFund.forEach((coin, i) => assertFillCoin(coin, `fund[${i}]`));
940
+ assertScript(solverPayout, "payoutScript");
941
+ toAmount(vtxo.value, "deposit.value", "sats", BigInt(1));
942
+ assertAssetEntries(vtxo.assets, "deposit");
943
+ const carrier = toAmount(assetCarrierSats, "assetCarrierSats", "sats", BigInt(1));
944
+ let sponsorFund = [];
945
+ let sponsorChange = BigInt(0);
946
+ let fareAsset = "";
947
+ let fareAmount = BigInt(0);
948
+ let fareSats = BigInt(0);
949
+ let combineSatsFareWithChange = false;
950
+ if (sponsor !== void 0) {
951
+ if (sponsor.fund.length === 0) {
952
+ throw new Error("sponsor needs coins to contribute with \u2014 `sponsor.fund` is empty");
953
+ }
954
+ sponsor.fund.forEach((coin, i) => {
955
+ assertFillCoin(coin, `sponsor.fund[${i}]`);
956
+ if ((coin.assets?.length ?? 0) > 0) {
957
+ throw new Error(`sponsor.fund[${i}] carries assets \u2014 sponsor funding is sats-only`);
958
+ }
959
+ });
960
+ assertScript(sponsor.changeScript, "sponsor.changeScript");
961
+ const contribution = toAmount(
962
+ sponsor.netContributionSats,
963
+ "sponsor.netContributionSats",
964
+ "sats"
965
+ );
966
+ if (contribution <= BigInt(0)) {
967
+ throw new Error("sponsor.netContributionSats must be a positive amount of sats");
968
+ }
969
+ if (sponsor.combineSatsFareWithChange !== void 0 && typeof sponsor.combineSatsFareWithChange !== "boolean") {
970
+ throw new Error("sponsor.combineSatsFareWithChange must be a boolean");
971
+ }
972
+ combineSatsFareWithChange = sponsor.combineSatsFareWithChange === true;
973
+ if (combineSatsFareWithChange && sponsor.fare === void 0) {
974
+ throw new Error("sponsor.combineSatsFareWithChange requires a fare");
975
+ }
976
+ if (sponsor.fare !== void 0) {
977
+ const { assetId, amount } = sponsor.fare;
978
+ if (assetId === void 0 !== (amount === void 0)) {
979
+ throw new Error(
980
+ "sponsor.fare needs assetId and amount together, or neither for a sats fare"
981
+ );
982
+ }
983
+ if (assetId !== void 0) {
984
+ fareAsset = assertAssetId(assetId, "sponsor.fare.assetId");
985
+ fareAmount = toAmount(amount, "sponsor.fare.amount", "asset units");
986
+ if (fareAmount <= BigInt(0)) {
987
+ throw new Error("sponsor.fare.amount must be a positive amount of asset units");
988
+ }
989
+ }
990
+ assertScript(sponsor.fare.script, "sponsor.fare.script");
991
+ fareSats = toAmount(sponsor.fare.sats, "sponsor.fare.sats", "sats", BigInt(1));
992
+ if (combineSatsFareWithChange) {
993
+ if (assetId !== void 0) {
994
+ throw new Error("sponsor.combineSatsFareWithChange requires a sats-only fare");
995
+ }
996
+ if (import_base2.hex.encode(sponsor.fare.script) !== import_base2.hex.encode(sponsor.changeScript)) {
997
+ throw new Error(
998
+ "sponsor.combineSatsFareWithChange requires fare and change to use the same script"
999
+ );
1000
+ }
1001
+ }
1002
+ }
1003
+ const sponsorInputs = sponsor.fund.reduce((s, c) => s + BigInt(c.value), BigInt(0));
1004
+ if (contribution > sponsorInputs) {
1005
+ throw new Error(
1006
+ `sponsor.netContributionSats ${contribution} exceeds the sponsor inputs ${sponsorInputs}`
1007
+ );
1008
+ }
1009
+ sponsorFund = sponsor.fund;
1010
+ const baseSponsorChange = sponsorInputs - contribution;
1011
+ sponsorChange = combineSatsFareWithChange ? toAmount(baseSponsorChange + fareSats, "combined sponsor change", "sats", BigInt(1)) : baseSponsorChange;
1012
+ }
1013
+ if (wantedAssetId !== void 0) {
1014
+ const required = offer.wantAmount + (sponsor?.fare !== void 0 && fareAsset === wantedAssetId ? fareAmount : BigInt(0));
1015
+ const supplied = solverFund.reduce(
1016
+ (sum, coin) => sum + amountOfAsset(coin.assets, wantedAssetId),
1017
+ BigInt(0)
1018
+ );
1019
+ if (supplied < required) {
1020
+ throw new Error(
1021
+ `fillOffer needs ${required} of ${wantedAssetId} to pay the maker, but \`fund\` declares ${supplied} \u2014 pass coins carrying it, and declare their assets`
1022
+ );
1023
+ }
1024
+ }
1025
+ if (offer.offerAsset) {
1026
+ const offered = offer.offerAsset.toString();
1027
+ const deposited = amountOfAsset(vtxo.assets, offered);
1028
+ if (deposited <= BigInt(0)) {
1029
+ throw new Error(
1030
+ `the deposit at the swap address carries no ${offered}, which this offer sells \u2014 filling it would pay wantAmount for nothing. The indexer may be behind, or the offer may not be backed by what it advertises`
1031
+ );
1032
+ }
1033
+ }
1034
+ const seen = /* @__PURE__ */ new Set();
1035
+ const claim = (txid, vout, what) => {
1036
+ const key = `${txid.toLowerCase()}:${vout}`;
1037
+ if (seen.has(key)) throw new Error(`duplicate fill input ${key} (${what})`);
1038
+ seen.add(key);
1039
+ };
1040
+ claim(parseHex32(vtxo.txid, "deposit.txid"), assertVout(vtxo.vout, "deposit.vout"), "deposit");
1041
+ solverFund.forEach((coin, i) => claim(coin.txid, coin.vout, `fund[${i}]`));
1042
+ sponsorFund.forEach((coin, i) => claim(coin.txid, coin.vout, `sponsor.fund[${i}]`));
1043
+ const makerSats = wantedAssetId === void 0 ? toAmount(offer.wantAmount, "offer.wantAmount", "sats") : carrier;
1044
+ const outputs = [
1045
+ { role: "receiver", script: offer.makerPkScript, sats: makerSats }
1046
+ ];
1047
+ const fareVout = outputs.length;
1048
+ if (sponsor?.fare !== void 0 && !combineSatsFareWithChange) {
1049
+ outputs.push({ role: "sponsor-fare", script: sponsor.fare.script, sats: fareSats });
1050
+ }
1051
+ if (sponsor !== void 0 && sponsorChange > BigInt(0)) {
1052
+ outputs.push({ role: "sponsor-change", script: sponsor.changeScript, sats: sponsorChange });
1053
+ }
1054
+ const solverVout = outputs.length;
1055
+ fill.from({ txid: vtxo.txid, vout: vtxo.vout, value: vtxo.value }).fund(sponsorFund.length > 0 ? [...solverFund, ...sponsorFund] : solverFund).to(offer.makerPkScript, makerSats);
1056
+ if (sponsor?.fare !== void 0 && !combineSatsFareWithChange)
1057
+ fill.to(sponsor.fare.script, fareSats);
1058
+ if (sponsor !== void 0 && sponsorChange > BigInt(0))
1059
+ fill.to(sponsor.changeScript, sponsorChange);
1060
+ fill.change(solverPayout);
1061
+ const held = /* @__PURE__ */ new Map();
1062
+ const hold = (vin, assets) => {
1063
+ for (const a of assets ?? []) {
1064
+ const amount = BigInt(a.amount);
1065
+ if (amount <= BigInt(0)) continue;
1066
+ held.set(a.assetId, [...held.get(a.assetId) ?? [], { vin, amount }]);
1067
+ }
1068
+ };
1069
+ hold(0, vtxo.assets);
1070
+ solverFund.forEach((coin, i) => hold(i + 1, coin.assets));
1071
+ sponsorFund.forEach((coin, i) => hold(1 + solverFund.length + i, coin.assets));
1072
+ const explicitSats = outputs.reduce((s, o) => s + o.sats, BigInt(0));
1073
+ const inputsSum = BigInt(vtxo.value) + solverFund.reduce((s, c) => s + BigInt(c.value), BigInt(0)) + sponsorFund.reduce((s, c) => s + BigInt(c.value), BigInt(0));
1074
+ if (inputsSum > MAX_SAFE_SATS) {
1075
+ throw new Error(`fill inputs total ${inputsSum} sats exceeds the safe integer domain`);
1076
+ }
1077
+ if (explicitSats > MAX_SAFE_SATS) {
1078
+ throw new Error(`fill outputs total ${explicitSats} sats exceeds the safe integer domain`);
1079
+ }
1080
+ if (explicitSats > inputsSum) {
1081
+ throw new Error(
1082
+ `fill outputs total ${explicitSats} sats but the inputs carry ${inputsSum} \u2014 increase solver or sponsor funding`
1083
+ );
1084
+ }
1085
+ const hasPayoutOutput = inputsSum > explicitSats;
1086
+ if (sponsor?.fare !== void 0 && fareAsset !== "") {
1087
+ const carried = (held.get(fareAsset) ?? []).reduce((s, i) => s + i.amount, BigInt(0));
1088
+ if (carried < fareAmount) {
1089
+ throw new Error(
1090
+ `sponsor fare needs ${fareAmount} of ${fareAsset} but the inputs carry ${carried}`
1091
+ );
1092
+ }
1093
+ }
1094
+ const stranded = (assetId, amount) => new Error(
1095
+ `fillOffer has ${amount} of ${assetId} to return but no payout output \u2014 fund with more sats than the maker's output takes`
1096
+ );
1097
+ if (wantedAssetId !== void 0) {
1098
+ const supplying = held.get(wantedAssetId) ?? [];
1099
+ const supplied = supplying.reduce((s, i) => s + i.amount, BigInt(0));
1100
+ const group = [{ vout: 0, amount: offer.wantAmount }];
1101
+ const farePart = sponsor?.fare !== void 0 && fareAsset === wantedAssetId ? fareAmount : BigInt(0);
1102
+ if (farePart > BigInt(0)) group.push({ vout: fareVout, amount: farePart });
1103
+ const surplus = supplied - offer.wantAmount - farePart;
1104
+ if (surplus > BigInt(0)) {
1105
+ if (!hasPayoutOutput) throw stranded(wantedAssetId, surplus);
1106
+ group.push({ vout: solverVout, amount: surplus });
1107
+ }
1108
+ fill.withAsset({ assetId: wantedAssetId, inputs: supplying, outputs: group });
1109
+ held.delete(wantedAssetId);
1110
+ }
1111
+ if (sponsor?.fare !== void 0 && fareAsset !== "" && fareAsset !== wantedAssetId) {
1112
+ const supplying = held.get(fareAsset) ?? [];
1113
+ const carried = supplying.reduce((s, i) => s + i.amount, BigInt(0));
1114
+ const group = [{ vout: fareVout, amount: fareAmount }];
1115
+ const remainder = carried - fareAmount;
1116
+ if (remainder > BigInt(0)) {
1117
+ if (!hasPayoutOutput) throw stranded(fareAsset, remainder);
1118
+ group.push({ vout: solverVout, amount: remainder });
1119
+ }
1120
+ fill.withAsset({ assetId: fareAsset, inputs: supplying, outputs: group });
1121
+ held.delete(fareAsset);
1122
+ }
1123
+ for (const [assetId, inputs] of held) {
1124
+ const amount = inputs.reduce((s, i) => s + i.amount, BigInt(0));
1125
+ if (!hasPayoutOutput) throw stranded(assetId, amount);
1126
+ fill.withAsset({ assetId, inputs, outputs: [{ vout: solverVout, amount }] });
1127
+ }
1128
+ if (hasPayoutOutput) {
1129
+ outputs.push({ role: "solver", script: solverPayout, sats: inputsSum - explicitSats });
1130
+ }
1131
+ return {
1132
+ inputs: [
1133
+ { owner: null, txid: vtxo.txid.toLowerCase(), vout: vtxo.vout },
1134
+ ...solverFund.map((coin) => ({
1135
+ owner: "solver",
1136
+ txid: coin.txid.toLowerCase(),
1137
+ vout: coin.vout
1138
+ })),
1139
+ ...sponsorFund.map((coin) => ({
1140
+ owner: "sponsor",
1141
+ txid: coin.txid.toLowerCase(),
1142
+ vout: coin.vout
1143
+ }))
1144
+ ],
1145
+ outputs
1146
+ };
1147
+ }
1148
+ function assertVout(vout, what) {
1149
+ if (typeof vout !== "number" || !Number.isSafeInteger(vout) || vout < 0 || vout > 4294967295) {
1150
+ throw new Error(`${what} must be a non-negative output index`);
1151
+ }
1152
+ return vout;
1153
+ }
1154
+ function toAmount(value, what, unit, min = BigInt(0)) {
1155
+ const max = unit === "sats" ? MAX_SAFE_SATS : U64_MAX;
1156
+ let amount;
1157
+ if (typeof value === "bigint") {
1158
+ if (value >= BigInt(0) && value <= max) amount = value;
1159
+ } else if (typeof value === "number") {
1160
+ if (Number.isSafeInteger(value) && value >= 0) amount = BigInt(value);
1161
+ }
1162
+ if (amount === void 0) {
1163
+ throw new Error(`${what} must be a safe integer amount of ${unit} (0 to ${max})`);
1164
+ }
1165
+ if (amount < min) {
1166
+ throw new Error(`${what} must be a positive amount of ${unit}`);
1167
+ }
1168
+ return amount;
1169
+ }
1170
+ function assertScript(script, what) {
1171
+ if (!(script instanceof Uint8Array) || script.length === 0) {
1172
+ throw new Error(`${what} must be a non-empty output script`);
1173
+ }
1174
+ }
1175
+ function assertAssetId(assetId, what) {
1176
+ if (typeof assetId !== "string") throw new Error(`${what} must be an asset id string`);
1177
+ try {
1178
+ return import_sdk3.asset.AssetId.fromString(assetId).toString();
1179
+ } catch {
1180
+ throw new Error(`${what} is not a valid asset id`);
1181
+ }
1182
+ }
1183
+ function assertAssetEntries(assets, what) {
1184
+ const seen = /* @__PURE__ */ new Set();
1185
+ for (const [i, a] of (assets ?? []).entries()) {
1186
+ const id = assertAssetId(a.assetId, `${what}.assets[${i}].assetId`);
1187
+ if (seen.has(id)) {
1188
+ throw new Error(`${what} declares ${id} twice \u2014 merge the entries instead`);
1189
+ }
1190
+ seen.add(id);
1191
+ toAmount(a.amount, `${what}.assets[${i}].amount`, "asset units");
1192
+ }
1193
+ }
1194
+ function assertFillCoin(coin, what) {
1195
+ parseHex32(coin.txid, `${what}.txid`);
1196
+ assertVout(coin.vout, `${what}.vout`);
1197
+ toAmount(coin.value, `${what}.value`, "sats", BigInt(1));
1198
+ assertAssetEntries(coin.assets, what);
1199
+ }
1200
+ var import_base2, import_utils, import_sdk3, swapPrograms, OFFER_PACKET_TYPE, FIELDS, EXIT_TYPES, NAMES, readU64, setRatio, OFFER_CONTRACT_LABEL, OFFER_CONTRACT_KIND, derivingClient, NoSpendableDepositError, OfferCovenantMismatchError, ASSET_CARRIER_SATS, amountOfAsset, U64_MAX, MAX_SAFE_SATS;
680
1201
  var init_offer = __esm({
681
1202
  "src/offer.ts"() {
682
1203
  "use strict";
@@ -686,6 +1207,7 @@ var init_offer = __esm({
686
1207
  init_swap_want_asset_program();
687
1208
  init_swap_want_btc_program();
688
1209
  init_coverage();
1210
+ init_rfqProfileParts();
689
1211
  init_store();
690
1212
  swapPrograms = {
691
1213
  wantAsset: import_sdk3.arkade.parseArtifact(swap_want_asset_program_default),
@@ -738,20 +1260,33 @@ var init_offer = __esm({
738
1260
  name = "OfferCovenantMismatchError";
739
1261
  };
740
1262
  ASSET_CARRIER_SATS = BigInt(import_sdk3.ASSET_CARRIER_SATS);
1263
+ amountOfAsset = (assets, assetId) => {
1264
+ let total = BigInt(0);
1265
+ for (const a of assets ?? []) {
1266
+ if (a.assetId === assetId) total += BigInt(a.amount);
1267
+ }
1268
+ return total;
1269
+ };
1270
+ U64_MAX = (BigInt(1) << BigInt(64)) - BigInt(1);
1271
+ MAX_SAFE_SATS = BigInt(Number.MAX_SAFE_INTEGER);
741
1272
  }
742
1273
  });
743
1274
 
744
1275
  // src/lockupContract.ts
745
- async function registerLockupContract(contracts, script, address) {
1276
+ async function registerLockupContract(contracts, script, address, options = {}) {
746
1277
  try {
747
- await contracts.createContract({
748
- type: SWAP_LOCKUP_CONTRACT_TYPE,
749
- params: import_sdk4.VHTLCV2ContractHandler.serializeParams(script.options),
750
- script: import_base3.hex.encode(script.pkScript),
751
- address,
752
- label: SWAP_LOCKUP_CONTRACT_LABEL,
753
- metadata: { genericallySpendable: false, kind: SWAP_LOCKUP_CONTRACT_KIND }
754
- });
1278
+ await registerContractCoverage(
1279
+ import_base3.hex.encode(script.pkScript),
1280
+ () => contracts.createContract({
1281
+ type: SWAP_LOCKUP_CONTRACT_TYPE,
1282
+ params: import_sdk4.VHTLCV2ContractHandler.serializeParams(script.options),
1283
+ script: import_base3.hex.encode(script.pkScript),
1284
+ address,
1285
+ label: SWAP_LOCKUP_CONTRACT_LABEL,
1286
+ metadata: { genericallySpendable: false, kind: SWAP_LOCKUP_CONTRACT_KIND }
1287
+ }),
1288
+ options
1289
+ );
755
1290
  } catch (error) {
756
1291
  throw new LockupRegistrationFailed(script, address, error);
757
1292
  }
@@ -766,6 +1301,7 @@ var import_base3, import_sdk4, SWAP_LOCKUP_CONTRACT_TYPE, SWAP_LOCKUP_CONTRACT_L
766
1301
  var init_lockupContract = __esm({
767
1302
  "src/lockupContract.ts"() {
768
1303
  "use strict";
1304
+ init_coverage();
769
1305
  import_base3 = require("@scure/base");
770
1306
  import_sdk4 = require("@arkade-os/sdk");
771
1307
  SWAP_LOCKUP_CONTRACT_TYPE = "vhtlc-v2";
@@ -863,6 +1399,13 @@ function onchainHtlcScript(params, network) {
863
1399
  refundLocktime: params.refundLocktime
864
1400
  };
865
1401
  }
1402
+ function nextClaimFeeRate(input) {
1403
+ const last = input.lastSatVb;
1404
+ const estimate = Number.isFinite(input.estimateSatVb) ? input.estimateSatVb : 0;
1405
+ const wanted = last === void 0 ? Math.max(input.configuredSatVb, estimate) : input.bump ? Math.max(Math.ceil(last * 1.5), last + 1, estimate) : Math.max(last, estimate);
1406
+ const affordable = Number((input.utxoAmount - ONCHAIN_DUST_SATS) / BigInt(ONCHAIN_CLAIM_VSIZE));
1407
+ return Math.max(last ?? input.configuredSatVb, Math.min(wanted, affordable));
1408
+ }
866
1409
  function extractPreimage(txHex, paymentHash) {
867
1410
  let raw;
868
1411
  try {
@@ -879,7 +1422,7 @@ function extractPreimage(txHex, paymentHash) {
879
1422
  }
880
1423
  async function claimOnchainFill(chain, input) {
881
1424
  const now = input.now ?? Math.floor(Date.now() / 1e3);
882
- if (input.htlc.refundLocktime - now < ONCHAIN_CLAIM_MARGIN_SECONDS) {
1425
+ if (!input.republish && input.htlc.refundLocktime - now < ONCHAIN_CLAIM_MARGIN_SECONDS) {
883
1426
  throw gateError(
884
1427
  "claim_window_closed",
885
1428
  "refund leaf opens too soon to claim safely \u2014 take the covenant refund instead"
@@ -913,7 +1456,7 @@ async function classifyOnchainHtlc(chain, input) {
913
1456
  if (mtp >= input.htlc.refundLocktime) return { phase: "refundable", utxo: best };
914
1457
  return { phase: "claimable", utxo: best };
915
1458
  }
916
- var import_base4, import_sha22, import_legacy, btc, import_sdk5, ONCHAIN_ORDER_MARGIN_SECONDS, ONCHAIN_CLAIM_MARGIN_SECONDS, MAX_MIN_CONFIRMATIONS, LOCKTIME_THRESHOLD, ONCHAIN_SECONDS_PER_BLOCK, ONCHAIN_DUST_SATS, ONCHAIN_CLAIM_VSIZE, paymentHashOf, h160FromPaymentHash, assertPreimageMatches, gateError, L1_NETWORKS, l1ScriptForAddress, buildLeafSpend, buildHtlcClaim, buildHtlcRefund;
1459
+ var import_base4, import_sha22, import_legacy, btc, import_sdk5, ONCHAIN_ORDER_MARGIN_SECONDS, ONCHAIN_CLAIM_MARGIN_SECONDS, ONCHAIN_CLAIM_BUMP_SECONDS, MAX_MIN_CONFIRMATIONS, LOCKTIME_THRESHOLD, ONCHAIN_SECONDS_PER_BLOCK, ONCHAIN_DUST_SATS, ONCHAIN_CLAIM_VSIZE, paymentHashOf, h160FromPaymentHash, assertPreimageMatches, gateError, L1_NETWORKS, l1ScriptForAddress, buildLeafSpend, buildHtlcClaim, buildHtlcRefund;
917
1460
  var init_onchainHtlc = __esm({
918
1461
  "src/onchainHtlc.ts"() {
919
1462
  "use strict";
@@ -924,6 +1467,7 @@ var init_onchainHtlc = __esm({
924
1467
  import_sdk5 = require("@arkade-os/sdk");
925
1468
  ONCHAIN_ORDER_MARGIN_SECONDS = 2 * 60 * 60;
926
1469
  ONCHAIN_CLAIM_MARGIN_SECONDS = 90 * 60;
1470
+ ONCHAIN_CLAIM_BUMP_SECONDS = 20 * 60;
927
1471
  MAX_MIN_CONFIRMATIONS = 6;
928
1472
  LOCKTIME_THRESHOLD = 5e8;
929
1473
  ONCHAIN_SECONDS_PER_BLOCK = 600;
@@ -1790,14 +2334,14 @@ __export(nostr_exports, {
1790
2334
  nostrCardFetcher: () => nostrCardFetcher,
1791
2335
  nostrRfqTransport: () => nostrRfqTransport
1792
2336
  });
1793
- var import_solver_discovery5, import_sdk17, import_nostr_tools, RFQ_DIRECTED_KIND, DEFAULT_TIMEOUT_MS, CARD_FETCH_TIMEOUT_MS, newPool, RelayUnavailable, TransportClosed, closeReasons, nostrRfqTransport, isNewer, nostrCardFetcher;
2337
+ var import_solver_discovery7, import_sdk19, import_nostr_tools, RFQ_DIRECTED_KIND, DEFAULT_TIMEOUT_MS, CARD_FETCH_TIMEOUT_MS, newPool, RelayUnavailable, TransportClosed, closeReasons, nostrRfqTransport, isNewer, nostrCardFetcher;
1794
2338
  var init_nostr = __esm({
1795
2339
  "src/nostr.ts"() {
1796
2340
  "use strict";
1797
- import_solver_discovery5 = require("@arkade-os/solver-discovery");
2341
+ import_solver_discovery7 = require("@arkade-os/solver-discovery");
1798
2342
  init_rfq();
1799
2343
  init_closeOnceWebSocket();
1800
- import_sdk17 = require("@arkade-os/sdk");
2344
+ import_sdk19 = require("@arkade-os/sdk");
1801
2345
  import_nostr_tools = require("nostr-tools");
1802
2346
  RFQ_DIRECTED_KIND = 24859;
1803
2347
  DEFAULT_TIMEOUT_MS = 3e4;
@@ -1825,7 +2369,7 @@ var init_nostr = __esm({
1825
2369
  return url ? `${url}: ${reason ?? "closed"}` : reason ?? "closed";
1826
2370
  });
1827
2371
  nostrRfqTransport = (options) => {
1828
- (0, import_sdk17.assertTimerMs)("timeoutMs", options.timeoutMs);
2372
+ (0, import_sdk19.assertTimerMs)("timeoutMs", options.timeoutMs);
1829
2373
  const relays = options.relays;
1830
2374
  const solverPubkey = options.solverPubkey;
1831
2375
  const secretKey = options.secretKey ?? (0, import_nostr_tools.generateSecretKey)();
@@ -1918,7 +2462,7 @@ var init_nostr = __esm({
1918
2462
  };
1919
2463
  isNewer = (event, held) => !held || event.created_at > held.created_at || event.created_at === held.created_at && event.id < held.id;
1920
2464
  nostrCardFetcher = (options = {}) => {
1921
- (0, import_sdk17.assertTimerMs)("timeoutMs", options.timeoutMs);
2465
+ (0, import_sdk19.assertTimerMs)("timeoutMs", options.timeoutMs);
1922
2466
  if (options.timeoutMs === 0) throw new Error("timeoutMs must be positive");
1923
2467
  const seen = /* @__PURE__ */ new Map();
1924
2468
  return {
@@ -1939,12 +2483,12 @@ var init_nostr = __esm({
1939
2483
  timer = setTimeout(resolve, timeoutMs);
1940
2484
  subscription = pool.subscribeMany(
1941
2485
  relays,
1942
- { kinds: [import_solver_discovery5.SOLVER_CARD_KIND], authors, "#d": [network] },
2486
+ { kinds: [import_solver_discovery7.SOLVER_CARD_KIND], authors, "#d": [network] },
1943
2487
  {
1944
2488
  // Relays are untrusted: re-check the filter and the signature, so a stray
1945
2489
  // or forged later event cannot shadow the real card.
1946
2490
  onevent(event) {
1947
- if (event.kind !== import_solver_discovery5.SOLVER_CARD_KIND || !asked.has(event.pubkey))
2491
+ if (event.kind !== import_solver_discovery7.SOLVER_CARD_KIND || !asked.has(event.pubkey))
1948
2492
  return;
1949
2493
  if (!(0, import_nostr_tools.verifyEvent)(event)) return;
1950
2494
  if (event.tags.find((tag) => tag[0] === "d")?.[1] !== network)
@@ -2017,6 +2561,8 @@ __export(advanced_exports, {
2017
2561
  MaxFeeExceeded: () => MaxFeeExceeded,
2018
2562
  MissingCorridorDep: () => MissingCorridorDep,
2019
2563
  NotCancellable: () => NotCancellable,
2564
+ OFFER_FILL_OWNERS: () => OFFER_FILL_OWNERS,
2565
+ OFFER_FILL_TEMPLATE: () => OFFER_FILL_TEMPLATE,
2020
2566
  OFFER_SWAP_ID_PREFIX: () => OFFER_SWAP_ID_PREFIX,
2021
2567
  ONCHAIN_CLAIM_FEE_RATE_SATVB: () => ONCHAIN_CLAIM_FEE_RATE_SATVB,
2022
2568
  ONCHAIN_DRIVE: () => ONCHAIN_DRIVE,
@@ -2043,6 +2589,7 @@ __export(advanced_exports, {
2043
2589
  bitcoinNetworkOf: () => bitcoinNetworkOf,
2044
2590
  btcAssetPart: () => btcAssetPart,
2045
2591
  btcOn: () => btcOn,
2592
+ buildOfferFillPlan: () => buildOfferFillPlan,
2046
2593
  cancelSwap: () => cancelSwap,
2047
2594
  canonicalAssetId: () => canonicalAssetId,
2048
2595
  cardMarketOf: () => cardMarketOf,
@@ -2058,6 +2605,8 @@ __export(advanced_exports, {
2058
2605
  createSwapDrive: () => createSwapDrive,
2059
2606
  decodeBolt11: () => decodeBolt11,
2060
2607
  decodeRfqAmount: () => decodeRfqAmount,
2608
+ deepFreeze: () => deepFreeze,
2609
+ digestJointGraph: () => digestJointGraph,
2061
2610
  discoveryIndex: () => discoveryIndex,
2062
2611
  eligibleMarkets: () => eligibleMarkets,
2063
2612
  encodeRfqAmount: () => encodeRfqAmount,
@@ -2083,6 +2632,7 @@ __export(advanced_exports, {
2083
2632
  formatAssetId: () => formatAssetId,
2084
2633
  fromAtomicDecimal: () => fromAtomicDecimal,
2085
2634
  fromRfqAmountSide: () => fromRfqAmountSide,
2635
+ fundingWasNotSubmitted: () => fundingWasNotSubmitted,
2086
2636
  fundsFromWallet: () => fundsFromWallet,
2087
2637
  instrumentOf: () => instrumentOf,
2088
2638
  isAddressable: () => isAddressable,
@@ -2148,9 +2698,12 @@ __export(advanced_exports, {
2148
2698
  toDiscoveryLeg: () => toDiscoveryLeg,
2149
2699
  toRfqAmountSide: () => toRfqAmountSide,
2150
2700
  toSafeNumber: () => toSafeNumber,
2701
+ unsignedPsbtBytes: () => unsignedPsbtBytes,
2151
2702
  usableMarkets: () => usableMarkets,
2152
2703
  verifiedCarrierSats: () => verifiedCarrierSats,
2153
2704
  verifyCrossAssetAmount: () => verifyCrossAssetAmount,
2705
+ verifyJointGraph: () => verifyJointGraph,
2706
+ verifyOfferFillPlan: () => verifyOfferFillPlan,
2154
2707
  verifyPair: () => verifyPair,
2155
2708
  verifyPlanLegs: () => verifyPlanLegs,
2156
2709
  verifyQuoteTtl: () => verifyQuoteTtl,
@@ -2170,134 +2723,17 @@ __export(advanced_exports, {
2170
2723
  module.exports = __toCommonJS(advanced_exports);
2171
2724
 
2172
2725
  // src/client/accept.ts
2173
- var import_base8 = require("@scure/base");
2174
- var import_sdk11 = require("@arkade-os/sdk");
2726
+ var import_base9 = require("@scure/base");
2727
+ var import_solver_discovery6 = require("@arkade-os/solver-discovery");
2728
+ var import_sdk13 = require("@arkade-os/sdk");
2175
2729
  init_offer();
2730
+ init_coverage();
2176
2731
  init_lockupContract();
2177
2732
 
2178
2733
  // src/rfqCorridors.ts
2179
2734
  var import_base5 = require("@scure/base");
2180
-
2181
- // src/rfqCorridor.ts
2182
- var RfqCorridorRegistry = class {
2183
- handlers = /* @__PURE__ */ new Map();
2184
- register(handler) {
2185
- if (this.handlers.has(handler.kind)) {
2186
- throw new Error(
2187
- `RFQ corridor handler for kind '${handler.kind}' is already registered`
2188
- );
2189
- }
2190
- this.handlers.set(handler.kind, handler);
2191
- }
2192
- /** A bare `string` on purpose: the key comes off a stored record, and narrowing it to the
2193
- * `kind` union would read as a check already made. */
2194
- get(kind) {
2195
- return this.handlers.get(kind);
2196
- }
2197
- /** The handler for a kind, or a loud failure naming the registered kinds. */
2198
- getOrThrow(kind) {
2199
- const handler = this.get(kind);
2200
- if (!handler) {
2201
- throw new Error(
2202
- `no RFQ corridor handler registered for kind '${kind}'; registered: ${this.registeredKinds().join(", ") || "none"}`
2203
- );
2204
- }
2205
- return handler;
2206
- }
2207
- registeredKinds() {
2208
- return [...this.handlers.keys()];
2209
- }
2210
- /** Test seam, mirroring the contract registry's. */
2211
- unregister(kind) {
2212
- return this.handlers.delete(kind);
2213
- }
2214
- };
2215
- var rfqCorridorHandlers = new RfqCorridorRegistry();
2216
-
2217
- // src/rfqProfileParts.ts
2218
- init_store();
2219
- var rfqSecretsProfile = (secrets, paymentHash) => {
2220
- const { signingDescriptor, ...preimage } = swapSecretsToRecord(secrets);
2221
- return {
2222
- signer: { signingDescriptor },
2223
- ...paymentHash ? { hashlock: { paymentHash, ...preimage } } : {}
2224
- };
2225
- };
2226
- var parseHex32 = (value, field) => {
2227
- if (typeof value !== "string" || !/^[0-9a-fA-F]{64}$/.test(value)) {
2228
- throw new Error(`${field} must be 32 bytes of hex, got ${JSON.stringify(value)}`);
2229
- }
2230
- return value.toLowerCase();
2231
- };
2232
- var parseSigner = (value) => {
2233
- const signingDescriptor = value?.signingDescriptor;
2234
- if (typeof signingDescriptor !== "string" || signingDescriptor.length === 0) {
2235
- throw new Error(
2236
- `rfq profile.signer carries no signingDescriptor (got ${JSON.stringify(signingDescriptor)})`
2237
- );
2238
- }
2239
- return { signingDescriptor };
2240
- };
2241
- var parsePayoutAddress = (value, kind) => {
2242
- if (typeof value !== "string" || value.length === 0) {
2243
- throw new Error(
2244
- `this ${kind} record's claim destination is unusable: expected an Arkade address, got ${JSON.stringify(value)}`
2245
- );
2246
- }
2247
- return value;
2248
- };
2249
- var parseHashlock = (value) => {
2250
- const raw = value ?? {};
2251
- const hashlock = {
2252
- paymentHash: parseHex32(raw.paymentHash, "rfq profile.hashlock.paymentHash")
2253
- };
2254
- if (raw.preimageHex !== void 0) {
2255
- hashlock.preimageHex = parseHex32(raw.preimageHex, "rfq profile.hashlock.preimageHex");
2256
- }
2257
- if (raw.preimageSaltHex !== void 0) {
2258
- hashlock.preimageSaltHex = parseHex32(
2259
- raw.preimageSaltHex,
2260
- "rfq profile.hashlock.preimageSaltHex"
2261
- );
2262
- }
2263
- return hashlock;
2264
- };
2265
- var hydrateHashlock = (profile) => {
2266
- try {
2267
- return { paymentHash: parseHashlock(profile.hashlock).paymentHash };
2268
- } catch (cause) {
2269
- throw new Error(
2270
- `rfq record carries no usable hashlock; it cannot verify a preimage: ${String(cause)}`,
2271
- { cause }
2272
- );
2273
- }
2274
- };
2275
- var rfqSignerOf = (record) => {
2276
- const signer = record.profile.signer;
2277
- if (signer === void 0) return void 0;
2278
- return parseSigner(signer);
2279
- };
2280
- var rfqClaimSecretOf = (record) => {
2281
- const handler = rfqCorridorHandlers.getOrThrow(record.kind);
2282
- if (!handler.claimSecret) return void 0;
2283
- try {
2284
- const claim = handler.claimSecret(record.profile);
2285
- return { ...parseSigner(claim), ...parseHashlock(claim) };
2286
- } catch (cause) {
2287
- throw new PreimageNotRecoverableError(
2288
- "malformed-record",
2289
- `this ${record.kind} record's claim secret is unreadable: ${String(cause)}`,
2290
- { cause }
2291
- );
2292
- }
2293
- };
2294
- var rfqClaimDestinationOf = (record) => {
2295
- const handler = rfqCorridorHandlers.getOrThrow(record.kind);
2296
- if (!handler.claimDestination) return void 0;
2297
- return parsePayoutAddress(handler.claimDestination(record.profile), record.kind);
2298
- };
2299
-
2300
- // src/rfqCorridors.ts
2735
+ init_rfqCorridor();
2736
+ init_rfqProfileParts();
2301
2737
  init_onchainHtlc();
2302
2738
  var LightningSendCorridor = {
2303
2739
  kind: "lightning_send",
@@ -2352,7 +2788,9 @@ var OnchainSendCorridor = {
2352
2788
  return {
2353
2789
  expectedAmount: send.expectedAmount,
2354
2790
  ...send.funding ? { funding: send.funding } : {},
2355
- ...send.claimTxid ? { claimTxid: send.claimTxid } : {}
2791
+ ...send.claimTxid ? { claimTxid: send.claimTxid } : {},
2792
+ ...send.claimFeeRateSatVb === void 0 ? {} : { claimFeeRateSatVb: send.claimFeeRateSatVb },
2793
+ ...send.claimBroadcastAt === void 0 ? {} : { claimBroadcastAt: send.claimBroadcastAt }
2356
2794
  };
2357
2795
  },
2358
2796
  hydrate(profile) {
@@ -2397,7 +2835,9 @@ var OnchainSendCorridor = {
2397
2835
  // record would strand the refund it is still owed.
2398
2836
  ...profile.payoutPkScript ? { payoutPkScript: import_base5.hex.decode(profile.payoutPkScript) } : {},
2399
2837
  ...profile.funding ? { funding: profile.funding } : {},
2400
- ...profile.claimTxid ? { claimTxid: profile.claimTxid } : {}
2838
+ ...profile.claimTxid ? { claimTxid: profile.claimTxid } : {},
2839
+ ...typeof profile.claimFeeRateSatVb === "number" ? { claimFeeRateSatVb: profile.claimFeeRateSatVb } : {},
2840
+ ...typeof profile.claimBroadcastAt === "number" ? { claimBroadcastAt: profile.claimBroadcastAt } : {}
2401
2841
  };
2402
2842
  },
2403
2843
  // The trader claims the L1 HTLC with P, so this leg's preimage material is
@@ -2482,6 +2922,7 @@ rfqCorridorHandlers.register(OnchainSendCorridor);
2482
2922
  rfqCorridorHandlers.register(OnchainReceiveCorridor);
2483
2923
 
2484
2924
  // src/client/accept.ts
2925
+ init_rfqProfileParts();
2485
2926
  init_store();
2486
2927
 
2487
2928
  // src/client/assetId.ts
@@ -2713,10 +3154,10 @@ var QuoteExpired = class extends Error {
2713
3154
  name = "QuoteExpired";
2714
3155
  };
2715
3156
  var MaxFeeExceeded = class extends Error {
2716
- constructor(quoteId, asset7, fee, maxFee) {
2717
- super(`fee ${fee} of ${asset7} exceeds the ${maxFee} ceiling`);
3157
+ constructor(quoteId, asset8, fee, maxFee) {
3158
+ super(`fee ${fee} of ${asset8} exceeds the ${maxFee} ceiling`);
2718
3159
  this.quoteId = quoteId;
2719
- this.asset = asset7;
3160
+ this.asset = asset8;
2720
3161
  this.fee = fee;
2721
3162
  this.maxFee = maxFee;
2722
3163
  }
@@ -2727,11 +3168,11 @@ var MaxFeeExceeded = class extends Error {
2727
3168
  name = "MaxFeeExceeded";
2728
3169
  };
2729
3170
  var InsufficientFunds = class extends Error {
2730
- constructor(asset7, required, available) {
3171
+ constructor(asset8, required, available) {
2731
3172
  super(
2732
- `funding needs ${required} of ${asset7}` + (available === void 0 ? "" : `, wallet holds ${available}`)
3173
+ `funding needs ${required} of ${asset8}` + (available === void 0 ? "" : `, wallet holds ${available}`)
2733
3174
  );
2734
- this.asset = asset7;
3175
+ this.asset = asset8;
2735
3176
  this.required = required;
2736
3177
  this.available = available;
2737
3178
  }
@@ -2769,9 +3210,9 @@ var NotCancellable = class extends Error {
2769
3210
  name = "NotCancellable";
2770
3211
  };
2771
3212
  var InconsistentRoute = class extends Error {
2772
- constructor(asset7, destination) {
2773
- super(`destination ${JSON.stringify(destination)} is not on ${asset7}'s chain`);
2774
- this.asset = asset7;
3213
+ constructor(asset8, destination) {
3214
+ super(`destination ${JSON.stringify(destination)} is not on ${asset8}'s chain`);
3215
+ this.asset = asset8;
2775
3216
  this.destination = destination;
2776
3217
  }
2777
3218
  asset;
@@ -2824,9 +3265,9 @@ function isSwapError(e, name) {
2824
3265
  // src/client/aliases.ts
2825
3266
  var toDiscoveryLeg = (id) => {
2826
3267
  const { rail, reference, assetNamespace, assetReference } = parseAssetId(id);
2827
- const asset7 = `${assetNamespace}:${assetReference}`;
3268
+ const asset8 = `${assetNamespace}:${assetReference}`;
2828
3269
  const isBtc = isBtcAsset(id);
2829
- if (!isBtc && rail !== "eip155" && (asset7 === "slip44:0" || asset7 === "slip44:1")) {
3270
+ if (!isBtc && rail !== "eip155" && (asset8 === "slip44:0" || asset8 === "slip44:1")) {
2830
3271
  const expected = btcOn(rail, reference);
2831
3272
  throw new UnsupportedRoute(`${id} is not BTC on ${reference}: BTC there is ${expected}`);
2832
3273
  }
@@ -2835,15 +3276,15 @@ var toDiscoveryLeg = (id) => {
2835
3276
  if (assetNamespace === ARKADE_ASSET_NAMESPACE) {
2836
3277
  return { corridor: "arkade", assetId: assetReference, marketId: id };
2837
3278
  }
2838
- throw new UnsupportedRoute(`the arkade corridor has no ${asset7}`);
3279
+ throw new UnsupportedRoute(`the arkade corridor has no ${asset8}`);
2839
3280
  }
2840
3281
  if (rail === "bolt11") {
2841
3282
  if (isBtc) return { corridor: "lightning", assetId: BTC_ASSET_ID, marketId: id };
2842
- throw new UnsupportedRoute(`the lightning corridor carries BTC only, not ${asset7}`);
3283
+ throw new UnsupportedRoute(`the lightning corridor carries BTC only, not ${asset8}`);
2843
3284
  }
2844
3285
  if (rail === "bitcoin") {
2845
3286
  if (isBtc) return { corridor: "onchain", assetId: BTC_ASSET_ID, marketId: id };
2846
- throw new UnsupportedRoute(`the onchain corridor carries BTC only, not ${asset7}`);
3287
+ throw new UnsupportedRoute(`the onchain corridor carries BTC only, not ${asset8}`);
2847
3288
  }
2848
3289
  throw new UnsupportedRoute(`no corridor serves ${id}`);
2849
3290
  };
@@ -2874,19 +3315,542 @@ var canonicalAssetId = (input, table) => {
2874
3315
  return matches[0].id;
2875
3316
  };
2876
3317
 
2877
- // src/client/corridors/lightning.ts
3318
+ // src/client/assetPayment.ts
2878
3319
  var import_sdk9 = require("@arkade-os/sdk");
2879
- var INVOICE_HRPS = [
2880
- ["lnbcrt", ["regtest"]],
2881
- ["lntbs", ["signet", "mutinynet"]],
2882
- ["lnbc", ["bitcoin"]],
2883
- ["lntb", ["testnet"]]
2884
- ];
2885
- var networksOfInvoiceHrp = (raw) => {
2886
- const lower = raw.toLowerCase();
2887
- return INVOICE_HRPS.find(([hrp]) => lower.startsWith(hrp))?.[1];
2888
- };
2889
- var PAYMENT_HASH = /^[0-9a-f]{64}$/;
3320
+ var import_solver_discovery3 = require("@arkade-os/solver-discovery");
3321
+ var DECIMAL = /^(0|[1-9][0-9]*)$/;
3322
+ var MAX_SATS = 2100000000000000n;
3323
+ var asRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
3324
+ var CARRIER_QUOTE_ID_MAX = 128;
3325
+ var CARRIER_TAXI_URL_MAX = 512;
3326
+ var XONLY_HEX = /^[0-9a-f]{64}$/;
3327
+ var MAX_BITCOIN_SATS_DECIMAL = MAX_SATS.toString();
3328
+ var parseSatsField = (value, field) => {
3329
+ if (typeof value !== "string" || !DECIMAL.test(value)) {
3330
+ throw new Error("carrier echo " + field + " must be a canonical decimal string");
3331
+ }
3332
+ if (value.length > MAX_BITCOIN_SATS_DECIMAL.length || value.length === MAX_BITCOIN_SATS_DECIMAL.length && value > MAX_BITCOIN_SATS_DECIMAL) {
3333
+ throw new Error("carrier echo " + field + " exceeds the Bitcoin supply");
3334
+ }
3335
+ return BigInt(value);
3336
+ };
3337
+ var parseTopLevelCarrierSats = (value) => {
3338
+ if (typeof value === "number") {
3339
+ if (!Number.isSafeInteger(value) || value < 0) {
3340
+ throw new Error("top-level carrier_sats must be a non-negative safe integer");
3341
+ }
3342
+ if (value > Number(MAX_SATS)) {
3343
+ throw new Error("top-level carrier_sats exceeds the Bitcoin supply");
3344
+ }
3345
+ return BigInt(value);
3346
+ }
3347
+ return parseSatsField(value, "top-level carrier_sats");
3348
+ };
3349
+ var parseExpiresAt = (value) => {
3350
+ if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
3351
+ throw new Error("carrier echo expires_at must be a safe positive unix time");
3352
+ }
3353
+ return value;
3354
+ };
3355
+ function validateReceiverPaidQuoteShape(q) {
3356
+ if (!q || typeof q !== "object") throw new Error("carrier receiver-paid quote is required");
3357
+ if (typeof q.quoteId !== "string" || !q.quoteId.length || q.quoteId.length > CARRIER_QUOTE_ID_MAX) {
3358
+ throw new Error("carrier receiver-paid quoteId must be 1..128 chars");
3359
+ }
3360
+ if (typeof q.receiveAddress !== "string" || !q.receiveAddress.length) {
3361
+ throw new Error("carrier receiver-paid quote needs a receiveAddress");
3362
+ }
3363
+ if (typeof q.senderKey !== "string" || !XONLY_HEX.test(q.senderKey)) {
3364
+ throw new Error("carrier receiver-paid quote senderKey must be lowercase x-only hex");
3365
+ }
3366
+ if (typeof q.assetId !== "string" || !q.assetId.length) {
3367
+ throw new Error("carrier receiver-paid quote needs an assetId");
3368
+ }
3369
+ try {
3370
+ import_sdk9.asset.AssetId.fromString(q.assetId);
3371
+ } catch {
3372
+ throw new Error("carrier receiver-paid quote assetId is not a valid SDK asset id");
3373
+ }
3374
+ const amounts = [
3375
+ ["physicalSats", q.physicalSats],
3376
+ ["loanSats", q.loanSats]
3377
+ ];
3378
+ for (const [name, v] of amounts) {
3379
+ if (typeof v !== "bigint" || v < 0n) {
3380
+ throw new Error(
3381
+ "carrier receiver-paid quote " + name + " must be a non-negative bigint"
3382
+ );
3383
+ }
3384
+ if (v > MAX_SATS) {
3385
+ throw new Error("carrier receiver-paid quote " + name + " exceeds the Bitcoin supply");
3386
+ }
3387
+ }
3388
+ if (q.physicalSats <= 0n)
3389
+ throw new Error("carrier receiver-paid quote physicalSats must be positive");
3390
+ if (q.loanSats !== q.physicalSats) {
3391
+ throw new Error("carrier receiver-paid quote loanSats must equal physical");
3392
+ }
3393
+ if (!Number.isSafeInteger(q.expiresAt) || q.expiresAt <= 0) {
3394
+ throw new Error("carrier receiver-paid quote expiresAt must be safe positive unix time");
3395
+ }
3396
+ }
3397
+ function encodeCarrierRequest(choice) {
3398
+ if (!asRecord(choice)) throw new Error("carrier request must be an object");
3399
+ if (choice.mode !== "purchase" && choice.mode !== "recycle_receiver") {
3400
+ throw new Error("carrier request mode must be purchase or recycle_receiver");
3401
+ }
3402
+ const allowed = choice.mode === "purchase" ? /* @__PURE__ */ new Set(["mode"]) : /* @__PURE__ */ new Set(["mode", "quoteId", "taxiUrl", "taxiKey"]);
3403
+ for (const key of Object.keys(choice)) {
3404
+ if (!allowed.has(key)) throw new Error("carrier request carries unknown field " + key);
3405
+ }
3406
+ if (choice.mode === "purchase") return { mode: "purchase" };
3407
+ if (typeof choice.quoteId !== "string" || !choice.quoteId.length || choice.quoteId.length > CARRIER_QUOTE_ID_MAX) {
3408
+ throw new Error(`carrier ${choice.mode} quoteId must be 1..128 chars`);
3409
+ }
3410
+ if (typeof choice.taxiUrl !== "string" || !choice.taxiUrl.length || choice.taxiUrl.length > CARRIER_TAXI_URL_MAX) {
3411
+ throw new Error("carrier recycle_receiver taxiUrl must be 1..512 chars");
3412
+ }
3413
+ if (typeof choice.taxiKey !== "string" || !XONLY_HEX.test(choice.taxiKey)) {
3414
+ throw new Error("carrier recycle_receiver taxiKey must be 64 lowercase hex chars");
3415
+ }
3416
+ return {
3417
+ mode: "recycle_receiver",
3418
+ quote_id: choice.quoteId,
3419
+ taxi_url: choice.taxiUrl,
3420
+ taxi_key: choice.taxiKey
3421
+ };
3422
+ }
3423
+ function parseCarrierEcho(raw, expected) {
3424
+ const r = asRecord(raw);
3425
+ if (!r) throw new Error("carrier echo must be an object");
3426
+ if (r.mode !== expected.mode) throw new Error("carrier echo mode differs from the request");
3427
+ const keys = new Set(Object.keys(r));
3428
+ const base = /* @__PURE__ */ new Set([
3429
+ "mode",
3430
+ "physical_sats",
3431
+ "loan_sats",
3432
+ "receipt_sats",
3433
+ "service_fare_sats",
3434
+ "priced_sats",
3435
+ "expires_at"
3436
+ ]);
3437
+ const allowed = expected.mode === "recycle_receiver" ? /* @__PURE__ */ new Set([...base, "quote_id", "taxi_url", "taxi_key"]) : base;
3438
+ for (const k of keys) {
3439
+ if (!allowed.has(k)) throw new Error("carrier echo carries unknown field " + k);
3440
+ }
3441
+ for (const k of allowed) {
3442
+ if (!keys.has(k)) throw new Error("carrier echo is missing " + k);
3443
+ }
3444
+ let quoteId;
3445
+ if (expected.mode === "recycle_receiver") {
3446
+ const qid = r.quote_id;
3447
+ if (typeof qid !== "string" || !qid.length || qid.length > CARRIER_QUOTE_ID_MAX) {
3448
+ throw new Error("carrier echo quote_id must be 1..128 chars");
3449
+ }
3450
+ if (qid !== expected.quoteId)
3451
+ throw new Error("carrier echo quote_id differs from the request");
3452
+ quoteId = qid;
3453
+ const taxiUrl = r.taxi_url;
3454
+ if (typeof taxiUrl !== "string" || !taxiUrl.length || taxiUrl.length > CARRIER_TAXI_URL_MAX) {
3455
+ throw new Error("carrier echo taxi_url must be 1..512 chars");
3456
+ }
3457
+ if (taxiUrl !== expected.taxiUrl)
3458
+ throw new Error("carrier echo taxi_url differs from the request");
3459
+ const taxiKey = r.taxi_key;
3460
+ if (typeof taxiKey !== "string" || !XONLY_HEX.test(taxiKey)) {
3461
+ throw new Error("carrier echo taxi_key must be 64 lowercase hex chars");
3462
+ }
3463
+ if (taxiKey !== expected.taxiKey)
3464
+ throw new Error("carrier echo taxi_key differs from the request");
3465
+ }
3466
+ const physical = parseSatsField(r.physical_sats, "physical_sats");
3467
+ const loan = parseSatsField(r.loan_sats, "loan_sats");
3468
+ const receipt = parseSatsField(r.receipt_sats, "receipt_sats");
3469
+ const serviceFare = parseSatsField(r.service_fare_sats, "service_fare_sats");
3470
+ const priced = parseSatsField(r.priced_sats, "priced_sats");
3471
+ const expiresAt = parseExpiresAt(r.expires_at);
3472
+ if (physical <= 0n) throw new Error("carrier echo physical_sats must be positive");
3473
+ if (expected.mode === "purchase") {
3474
+ if (loan !== 0n || receipt !== 0n || serviceFare !== 0n) {
3475
+ throw new Error("carrier purchase echo must carry zero loan/receipt/fare");
3476
+ }
3477
+ if (priced !== physical) throw new Error("carrier purchase priced must equal physical");
3478
+ } else {
3479
+ if (loan !== physical) {
3480
+ throw new Error("carrier receiver-paid echo loan must equal physical");
3481
+ }
3482
+ if (receipt !== 0n) {
3483
+ throw new Error("carrier receiver-paid echo must carry a zero receipt");
3484
+ }
3485
+ if (serviceFare !== 0n) {
3486
+ throw new Error("carrier receiver-paid echo must carry a zero service fare");
3487
+ }
3488
+ if (priced !== 0n) {
3489
+ throw new Error("carrier receiver-paid echo must carry a zero priced_sats");
3490
+ }
3491
+ }
3492
+ return {
3493
+ mode: expected.mode,
3494
+ physicalSats: physical,
3495
+ loanSats: loan,
3496
+ receiptSats: receipt,
3497
+ serviceFareSats: serviceFare,
3498
+ pricedSats: priced,
3499
+ expiresAt,
3500
+ ...quoteId !== void 0 ? { quoteId, taxiUrl: r.taxi_url, taxiKey: r.taxi_key } : {}
3501
+ };
3502
+ }
3503
+ function assertReceiverPaidEchoMatchesExpected(echo, expected) {
3504
+ if (echo.mode !== "recycle_receiver" || echo.quoteId !== expected.quoteId) {
3505
+ throw new Error("carrier echo quote differs from the expected descriptor");
3506
+ }
3507
+ if (echo.physicalSats !== expected.physicalSats || echo.loanSats !== expected.loanSats || echo.receiptSats !== 0n || echo.serviceFareSats !== 0n || echo.pricedSats !== 0n) {
3508
+ throw new Error("carrier echo amounts differ from the expected descriptor");
3509
+ }
3510
+ if (echo.expiresAt > expected.expiresAt) {
3511
+ throw new Error("carrier echo must not extend the expected expiry");
3512
+ }
3513
+ }
3514
+ var captureAssetPayment = (input) => {
3515
+ if (input === void 0) return void 0;
3516
+ const receiveAddress = input.receiveAddress;
3517
+ const carrier = input.carrier;
3518
+ if (receiveAddress !== void 0 && (typeof receiveAddress !== "string" || receiveAddress.length === 0))
3519
+ throw new Error("receiveAddress must be an Arkade address");
3520
+ if (carrier === void 0) return { receiveAddress };
3521
+ if (carrier.mode === "purchase") return { receiveAddress, carrier: { mode: "purchase" } };
3522
+ if (carrier.mode !== "recycleReceiver")
3523
+ throw new Error("carrier request mode must be purchase or recycleReceiver");
3524
+ const quote = { ...carrier.quote };
3525
+ validateReceiverPaidQuoteShape(quote);
3526
+ const taxi = { ...carrier.taxi };
3527
+ encodeCarrierRequest({
3528
+ mode: "recycle_receiver",
3529
+ quoteId: quote.quoteId,
3530
+ taxiUrl: taxi.url,
3531
+ taxiKey: taxi.operatorKey
3532
+ });
3533
+ if (receiveAddress !== void 0 && receiveAddress !== quote.receiveAddress)
3534
+ throw new Error("receiveAddress must match the carrier quote receiveAddress");
3535
+ const inputExpiryFloor = carrier.inputExpiryFloor === void 0 ? void 0 : { ...carrier.inputExpiryFloor };
3536
+ if (inputExpiryFloor === void 0 || inputExpiryFloor.kind !== "time" && inputExpiryFloor.kind !== "height" || typeof inputExpiryFloor.value !== "bigint" || inputExpiryFloor.value <= 0n)
3537
+ throw new Error("invalid carrier inputExpiryFloor");
3538
+ return {
3539
+ receiveAddress: quote.receiveAddress,
3540
+ carrier: {
3541
+ mode: "recycleReceiver",
3542
+ quote,
3543
+ taxi,
3544
+ inputExpiryFloor
3545
+ }
3546
+ };
3547
+ };
3548
+ var recordAssetPayment = (terms) => {
3549
+ const { carrier, inputExpiryFloor, ...rest } = terms;
3550
+ return {
3551
+ ...rest,
3552
+ ...carrier === void 0 ? {} : {
3553
+ carrier: {
3554
+ ...carrier,
3555
+ physicalSats: carrier.physicalSats.toString(),
3556
+ loanSats: carrier.loanSats.toString(),
3557
+ receiptSats: carrier.receiptSats.toString(),
3558
+ serviceFareSats: carrier.serviceFareSats.toString(),
3559
+ pricedSats: carrier.pricedSats.toString()
3560
+ }
3561
+ },
3562
+ ...inputExpiryFloor === void 0 ? {} : {
3563
+ inputExpiryFloor: {
3564
+ kind: inputExpiryFloor.kind,
3565
+ value: inputExpiryFloor.value.toString()
3566
+ }
3567
+ }
3568
+ };
3569
+ };
3570
+ var storedFundingBounds = (stored, quoteExpiry) => {
3571
+ if (stored === void 0) return {};
3572
+ if (!Number.isSafeInteger(stored.validUntil) || stored.validUntil <= 0 || stored.validUntil > quoteExpiry)
3573
+ throw new Error("invalid stored asset payment funding deadline");
3574
+ const floor = stored.inputExpiryFloor;
3575
+ if (stored.carrier?.mode === "recycle_receiver" && floor === void 0)
3576
+ throw new Error("stored receiver carrier has no inputExpiryFloor");
3577
+ if (floor !== void 0 && (floor.kind !== "time" && floor.kind !== "height" || typeof floor.value !== "string" || !/^(0|[1-9][0-9]*)$/.test(floor.value) || floor.value === "0"))
3578
+ throw new Error("invalid stored asset payment inputExpiryFloor");
3579
+ return {
3580
+ validUntil: stored.validUntil,
3581
+ ...floor === void 0 ? {} : { inputExpiryFloor: { kind: floor.kind, value: BigInt(floor.value) } }
3582
+ };
3583
+ };
3584
+ var assetPaymentFacts = (terms) => {
3585
+ if (terms === void 0) return void 0;
3586
+ const { validUntil, ...facts } = terms;
3587
+ return (0, import_solver_discovery3.stableStringify)(facts);
3588
+ };
3589
+ var assetPaymentOf = (stored, quoteExpiry) => {
3590
+ const bounds = storedFundingBounds(stored, quoteExpiry);
3591
+ const { carrier, inputExpiryFloor, ...rest } = stored;
3592
+ return {
3593
+ ...rest,
3594
+ ...bounds.inputExpiryFloor === void 0 ? {} : { inputExpiryFloor: bounds.inputExpiryFloor },
3595
+ ...carrier === void 0 ? {} : {
3596
+ carrier: {
3597
+ ...carrier,
3598
+ physicalSats: parseSatsField(carrier.physicalSats, "physicalSats"),
3599
+ loanSats: parseSatsField(carrier.loanSats, "loanSats"),
3600
+ receiptSats: parseSatsField(carrier.receiptSats, "receiptSats"),
3601
+ serviceFareSats: parseSatsField(carrier.serviceFareSats, "serviceFareSats"),
3602
+ pricedSats: parseSatsField(carrier.pricedSats, "pricedSats")
3603
+ }
3604
+ }
3605
+ };
3606
+ };
3607
+
3608
+ // src/client/fundingNotSubmitted.ts
3609
+ var import_sdk10 = require("@arkade-os/sdk");
3610
+ var import_base8 = require("@scure/base");
3611
+ init_coverage();
3612
+ init_repository();
3613
+
3614
+ // src/client/amount.ts
3615
+ var import_solver_discovery4 = require("@arkade-os/solver-discovery");
3616
+ var AmountFormatError = class extends Error {
3617
+ constructor(reason, message) {
3618
+ super(message);
3619
+ this.reason = reason;
3620
+ }
3621
+ reason;
3622
+ name = "AmountFormatError";
3623
+ };
3624
+ var SCALED_DECIMAL = /^([0-9]+)(?:\.([0-9]+))?$/;
3625
+ var ATOMIC_CEILING = 10n ** 30n;
3626
+ var MAX_SIGNIFICANT_DIGITS = 64;
3627
+ var assertDecimals = (decimals) => {
3628
+ if (!Number.isInteger(decimals) || decimals < 0 || decimals > import_solver_discovery4.MAX_ASSET_DECIMALS) {
3629
+ throw new AmountFormatError(
3630
+ "invalid_decimals",
3631
+ `decimals must be an integer in [0, ${import_solver_discovery4.MAX_ASSET_DECIMALS}], got ${decimals}`
3632
+ );
3633
+ }
3634
+ };
3635
+ var assertRepresentable = (value, what) => {
3636
+ if (value >= ATOMIC_CEILING) {
3637
+ throw new AmountFormatError(
3638
+ "too_large",
3639
+ `${what} does not fit the canonical 30-digit encoding`
3640
+ );
3641
+ }
3642
+ };
3643
+ var Amount = {
3644
+ /**
3645
+ * A human decimal into atomic units.
3646
+ *
3647
+ * `string` only, no exponent: a `number` makes `100000` ambiguous between sats and BTC, and the
3648
+ * ambiguity resolves only after funding. Refuses rather than rounds input finer than the asset
3649
+ * (a truncated amount is a swap for the wrong size), and refuses results that would not survive
3650
+ * the record boundary.
3651
+ */
3652
+ parse(display, asset8) {
3653
+ assertDecimals(asset8.decimals);
3654
+ const parts = SCALED_DECIMAL.exec(display);
3655
+ if (!parts) {
3656
+ throw new AmountFormatError(
3657
+ "not_decimal",
3658
+ `not an unsigned decimal amount: ${JSON.stringify(display)} (write 0.5, not .5; no sign, exponent, separator or space)`
3659
+ );
3660
+ }
3661
+ const [, whole, fraction = ""] = parts;
3662
+ if (fraction.length > asset8.decimals) {
3663
+ throw new AmountFormatError(
3664
+ "too_precise",
3665
+ `${display} has more precision than ${asset8.decimals} decimals allow`
3666
+ );
3667
+ }
3668
+ if (whole.length + fraction.length > MAX_SIGNIFICANT_DIGITS) {
3669
+ throw new AmountFormatError("too_large", `${display} has too many digits`);
3670
+ }
3671
+ const value = (0, import_solver_discovery4.toAtomic)(display, asset8.decimals);
3672
+ assertRepresentable(value, `${display} at ${asset8.decimals} decimals`);
3673
+ return value;
3674
+ },
3675
+ /** Atomic units into a human decimal, trailing zeros trimmed. Refuses a negative: every amount
3676
+ * here is an obligation, so a negative one is an upstream defect. */
3677
+ format(value, asset8) {
3678
+ assertDecimals(asset8.decimals);
3679
+ if (value < 0n) {
3680
+ throw new AmountFormatError("negative", `amount must be non-negative, got ${value}`);
3681
+ }
3682
+ assertRepresentable(value, `${value}`);
3683
+ return (0, import_solver_discovery4.fromAtomic)(value, asset8.decimals);
3684
+ }
3685
+ };
3686
+ var toAtomicDecimal = (value) => {
3687
+ if (value < 0n) {
3688
+ throw new AmountFormatError("negative", `amount must be non-negative, got ${value}`);
3689
+ }
3690
+ assertRepresentable(value, `${value}`);
3691
+ return value.toString();
3692
+ };
3693
+ var fromAtomicDecimal = (text) => {
3694
+ if (!(0, import_solver_discovery4.isAmount)(text)) {
3695
+ throw new AmountFormatError(
3696
+ "not_canonical",
3697
+ `not a canonical atomic amount: ${JSON.stringify(text)}`
3698
+ );
3699
+ }
3700
+ return BigInt(text);
3701
+ };
3702
+ var isAtomicDecimal = (value) => typeof value === "string" && import_solver_discovery4.AMOUNT_PATTERN.test(value);
3703
+
3704
+ // src/client/record.ts
3705
+ var assetSwapIdOf = (family, quoteId) => `${family}:${quoteId}`;
3706
+ var OFFER_SWAP_ID_PREFIX = "offer:";
3707
+ var RFQ_SWAP_ID_PREFIX = "rfq:";
3708
+ var familyOfSwapId = (swapId) => swapId.startsWith(OFFER_SWAP_ID_PREFIX) ? "offer" : swapId.startsWith(RFQ_SWAP_ID_PREFIX) ? "rfq" : void 0;
3709
+ var quoteIdOfSwapId = (swapId) => {
3710
+ const family = familyOfSwapId(swapId);
3711
+ return family === void 0 ? swapId : swapId.slice(`${family}:`.length);
3712
+ };
3713
+ var recordEndpoint = (endpoint2) => ({
3714
+ corridor: endpoint2.corridor,
3715
+ asset: endpoint2.asset,
3716
+ instrument: recordInstrument(endpoint2.instrument)
3717
+ });
3718
+ var recordInstrument = (instrument) => {
3719
+ switch (instrument.kind) {
3720
+ case "wallet":
3721
+ return { kind: "wallet" };
3722
+ case "address":
3723
+ return { kind: "address", address: instrument.address };
3724
+ case "invoice":
3725
+ return {
3726
+ kind: "invoice",
3727
+ bolt11: instrument.bolt11,
3728
+ paymentHash: instrument.paymentHash,
3729
+ ...instrument.amount === void 0 ? {} : { amount: toAtomicDecimal(instrument.amount) },
3730
+ expiresAt: instrument.expiresAt
3731
+ };
3732
+ }
3733
+ };
3734
+ var instrumentOf = (instrument) => {
3735
+ switch (instrument.kind) {
3736
+ case "wallet":
3737
+ return { kind: "wallet" };
3738
+ case "address":
3739
+ return { kind: "address", address: instrument.address };
3740
+ case "invoice":
3741
+ return {
3742
+ kind: "invoice",
3743
+ bolt11: instrument.bolt11,
3744
+ paymentHash: instrument.paymentHash,
3745
+ ...instrument.amount === void 0 ? {} : { amount: fromAtomicDecimal(instrument.amount) },
3746
+ expiresAt: instrument.expiresAt
3747
+ };
3748
+ }
3749
+ };
3750
+ var recordArtifact = (artifact) => artifact.kind === "invoice" ? { kind: "invoice", bolt11: artifact.bolt11 } : {
3751
+ kind: "deposit",
3752
+ corridor: artifact.corridor,
3753
+ address: artifact.address,
3754
+ asset: artifact.asset,
3755
+ amount: toAtomicDecimal(artifact.amount),
3756
+ ...artifact.expiresAt === void 0 ? {} : { expiresAt: artifact.expiresAt }
3757
+ };
3758
+ var artifactOf = (artifact) => artifact.kind === "invoice" ? { kind: "invoice", bolt11: artifact.bolt11 } : {
3759
+ kind: "deposit",
3760
+ corridor: artifact.corridor,
3761
+ address: artifact.address,
3762
+ asset: artifact.asset,
3763
+ amount: fromAtomicDecimal(artifact.amount),
3764
+ ...artifact.expiresAt === void 0 ? {} : { expiresAt: artifact.expiresAt }
3765
+ };
3766
+ var recordLeg = (leg) => ({
3767
+ asset: leg.asset,
3768
+ amount: toAtomicDecimal(leg.amount)
3769
+ });
3770
+ var legOf = (leg) => ({
3771
+ asset: leg.asset,
3772
+ amount: fromAtomicDecimal(leg.amount)
3773
+ });
3774
+ var swapOf = (record, outcome) => ({
3775
+ id: assetSwapIdOf(record.family, record.id),
3776
+ ...record.assetPayment === void 0 ? {} : { assetPayment: assetPaymentOf(record.assetPayment, record.expiresAt) },
3777
+ family: record.family,
3778
+ outcome,
3779
+ route: {
3780
+ give: {
3781
+ corridor: record.route.give.corridor,
3782
+ asset: record.route.give.asset,
3783
+ instrument: instrumentOf(record.route.give.instrument)
3784
+ },
3785
+ take: {
3786
+ corridor: record.route.take.corridor,
3787
+ asset: record.route.take.asset,
3788
+ instrument: instrumentOf(record.route.take.instrument)
3789
+ }
3790
+ },
3791
+ give: legOf(record.give),
3792
+ take: legOf(record.take),
3793
+ fee: legOf(record.fee),
3794
+ market: record.market,
3795
+ ...record.solver === void 0 ? {} : { solver: record.solver },
3796
+ ...record.family === "rfq" ? { lock: record.lock, refundLocktime: record.refundLocktime } : {},
3797
+ ...record.artifact === void 0 ? {} : { artifact: artifactOf(record.artifact) },
3798
+ expiresAt: record.expiresAt,
3799
+ ...record.fundingTxid === void 0 ? {} : { fundingTxid: record.fundingTxid },
3800
+ ...record.failure === void 0 ? {} : { failure: record.failure },
3801
+ ...record.blockedReason === void 0 ? {} : { blockedReason: record.blockedReason },
3802
+ createdAt: record.createdAt,
3803
+ updatedAt: record.updatedAt
3804
+ });
3805
+ var fundsFromWallet = (route) => route.give.instrument.kind === "wallet";
3806
+ var fundingWasNotSubmitted = (record) => {
3807
+ const proof = record.fundingNotSubmitted;
3808
+ return proof?.reason === "send_deadline" && Number.isSafeInteger(proof.validUntil) && proof.validUntil > 0 && Number.isSafeInteger(record.expiresAt) && proof.validUntil <= record.expiresAt && record.fundingTxid === void 0 && record.route?.give?.instrument?.kind === "wallet" && (record.family === "offer" ? record.status === "cancelled" : record.state === "failed");
3809
+ };
3810
+
3811
+ // src/client/fundingNotSubmitted.ts
3812
+ var retireUnsubmittedFunding = async (wallet, repository, record, contracts) => {
3813
+ if (!fundingWasNotSubmitted(record)) return;
3814
+ const script = record.family === "offer" ? record.swapPkScript : record.lockupPkScript;
3815
+ try {
3816
+ await retireOfferContract(
3817
+ contracts ?? await wallet.getContractManager(),
3818
+ async () => {
3819
+ const records = await collectSwapRecords(repository);
3820
+ const native = records.map((row) => ({
3821
+ id: row.id,
3822
+ swapPkScript: row.family === "offer" ? row.swapPkScript : row.lockupPkScript,
3823
+ createdAt: row.createdAt * 1e3,
3824
+ status: row.family === "offer" ? row.status : fundingWasNotSubmitted(row) ? "cancelled" : row.state === "settled" || row.state === "refunded" ? "fulfilled" : "pending"
3825
+ }));
3826
+ const legacy = (await collectRfqSwaps(repository)).map((row) => ({
3827
+ swapPkScript: import_base8.hex.encode(import_sdk10.ArkAddress.decode(row.lockupAddress).pkScript),
3828
+ createdAt: row.createdAt * 1e3,
3829
+ status: row.state === "settled" || row.state === "refunded" ? "fulfilled" : "pending"
3830
+ }));
3831
+ return [...native, ...legacy];
3832
+ },
3833
+ script,
3834
+ { scope: wallet }
3835
+ );
3836
+ } catch (error) {
3837
+ console.warn(`[swap] could not retire unsent funding for ${record.id}`, error);
3838
+ }
3839
+ };
3840
+
3841
+ // src/client/corridors/lightning.ts
3842
+ var import_sdk11 = require("@arkade-os/sdk");
3843
+ var INVOICE_HRPS = [
3844
+ ["lnbcrt", ["regtest"]],
3845
+ ["lntbs", ["signet", "mutinynet"]],
3846
+ ["lnbc", ["bitcoin"]],
3847
+ ["lntb", ["testnet"]]
3848
+ ];
3849
+ var networksOfInvoiceHrp = (raw) => {
3850
+ const lower = raw.toLowerCase();
3851
+ return INVOICE_HRPS.find(([hrp]) => lower.startsWith(hrp))?.[1];
3852
+ };
3853
+ var PAYMENT_HASH = /^[0-9a-f]{64}$/;
2890
3854
  var LIGHTNING_DRIVE = {
2891
3855
  give: {
2892
3856
  lockups: [{ covenant: "arkade_lockup", owner: "solver", deadline: "refund_locktime" }],
@@ -2905,7 +3869,7 @@ var lightningCorridor = Object.assign(
2905
3869
  deps,
2906
3870
  drive: LIGHTNING_DRIVE,
2907
3871
  matches(raw) {
2908
- const invoice = (0, import_sdk9.invoiceTarget)(raw);
3872
+ const invoice = (0, import_sdk11.invoiceTarget)(raw);
2909
3873
  if (invoice === void 0) return void 0;
2910
3874
  const networks2 = networksOfInvoiceHrp(invoice);
2911
3875
  if (networks2 === void 0) {
@@ -2951,11 +3915,11 @@ var lightningCorridor = Object.assign(
2951
3915
  };
2952
3916
  }
2953
3917
  }),
2954
- { target: import_sdk9.invoiceTarget }
3918
+ { target: import_sdk11.invoiceTarget }
2955
3919
  );
2956
3920
 
2957
3921
  // src/client/corridors/onchain.ts
2958
- var import_sdk10 = require("@arkade-os/sdk");
3922
+ var import_sdk12 = require("@arkade-os/sdk");
2959
3923
  var btc2 = __toESM(require("@scure/btc-signer"), 1);
2960
3924
  init_onchainHtlc();
2961
3925
  init_rfq();
@@ -2985,14 +3949,14 @@ var onchainCorridor = Object.assign(
2985
3949
  deps,
2986
3950
  drive: ONCHAIN_DRIVE,
2987
3951
  matches(raw) {
2988
- const target = (0, import_sdk10.btcTarget)(raw);
3952
+ const target = (0, import_sdk12.btcTarget)(raw);
2989
3953
  if (target === void 0) return void 0;
2990
3954
  try {
2991
3955
  btc2.Address(L1_NETWORKS[l1]).decode(target);
2992
3956
  } catch {
2993
3957
  return { refused: `this is not a ${l1} address` };
2994
3958
  }
2995
- const amount = import_sdk10.BIP21.amountSats(raw);
3959
+ const amount = import_sdk12.BIP21.amountSats(raw);
2996
3960
  return {
2997
3961
  claimed: {
2998
3962
  kind: "address",
@@ -3003,7 +3967,7 @@ var onchainCorridor = Object.assign(
3003
3967
  }
3004
3968
  };
3005
3969
  },
3006
- { target: import_sdk10.btcTarget }
3970
+ { target: import_sdk12.btcTarget }
3007
3971
  );
3008
3972
 
3009
3973
  // src/client/outcome.ts
@@ -3060,6 +4024,8 @@ var OFFER_OUTCOME = {
3060
4024
  };
3061
4025
  var offerOutcome = (status) => OFFER_OUTCOME[status];
3062
4026
  var recordOutcome = (record) => {
4027
+ if (record.route !== void 0 && fundingWasNotSubmitted(record))
4028
+ return "cancelled";
3063
4029
  if (record.fundingTxid === void 0) return "accepted";
3064
4030
  if (record.family === "rfq") return "funding";
3065
4031
  return record.status === void 0 ? "funding" : offerOutcome(record.status);
@@ -3083,98 +4049,8 @@ var ACTIVITY_TOKEN = {
3083
4049
  failed: "failed"
3084
4050
  };
3085
4051
 
3086
- // src/client/amount.ts
3087
- var import_solver_discovery3 = require("@arkade-os/solver-discovery");
3088
- var AmountFormatError = class extends Error {
3089
- constructor(reason, message) {
3090
- super(message);
3091
- this.reason = reason;
3092
- }
3093
- reason;
3094
- name = "AmountFormatError";
3095
- };
3096
- var SCALED_DECIMAL = /^([0-9]+)(?:\.([0-9]+))?$/;
3097
- var ATOMIC_CEILING = 10n ** 30n;
3098
- var MAX_SIGNIFICANT_DIGITS = 64;
3099
- var assertDecimals = (decimals) => {
3100
- if (!Number.isInteger(decimals) || decimals < 0 || decimals > import_solver_discovery3.MAX_ASSET_DECIMALS) {
3101
- throw new AmountFormatError(
3102
- "invalid_decimals",
3103
- `decimals must be an integer in [0, ${import_solver_discovery3.MAX_ASSET_DECIMALS}], got ${decimals}`
3104
- );
3105
- }
3106
- };
3107
- var assertRepresentable = (value, what) => {
3108
- if (value >= ATOMIC_CEILING) {
3109
- throw new AmountFormatError(
3110
- "too_large",
3111
- `${what} does not fit the canonical 30-digit encoding`
3112
- );
3113
- }
3114
- };
3115
- var Amount = {
3116
- /**
3117
- * A human decimal into atomic units.
3118
- *
3119
- * `string` only, no exponent: a `number` makes `100000` ambiguous between sats and BTC, and the
3120
- * ambiguity resolves only after funding. Refuses rather than rounds input finer than the asset
3121
- * (a truncated amount is a swap for the wrong size), and refuses results that would not survive
3122
- * the record boundary.
3123
- */
3124
- parse(display, asset7) {
3125
- assertDecimals(asset7.decimals);
3126
- const parts = SCALED_DECIMAL.exec(display);
3127
- if (!parts) {
3128
- throw new AmountFormatError(
3129
- "not_decimal",
3130
- `not an unsigned decimal amount: ${JSON.stringify(display)} (write 0.5, not .5; no sign, exponent, separator or space)`
3131
- );
3132
- }
3133
- const [, whole, fraction = ""] = parts;
3134
- if (fraction.length > asset7.decimals) {
3135
- throw new AmountFormatError(
3136
- "too_precise",
3137
- `${display} has more precision than ${asset7.decimals} decimals allow`
3138
- );
3139
- }
3140
- if (whole.length + fraction.length > MAX_SIGNIFICANT_DIGITS) {
3141
- throw new AmountFormatError("too_large", `${display} has too many digits`);
3142
- }
3143
- const value = (0, import_solver_discovery3.toAtomic)(display, asset7.decimals);
3144
- assertRepresentable(value, `${display} at ${asset7.decimals} decimals`);
3145
- return value;
3146
- },
3147
- /** Atomic units into a human decimal, trailing zeros trimmed. Refuses a negative: every amount
3148
- * here is an obligation, so a negative one is an upstream defect. */
3149
- format(value, asset7) {
3150
- assertDecimals(asset7.decimals);
3151
- if (value < 0n) {
3152
- throw new AmountFormatError("negative", `amount must be non-negative, got ${value}`);
3153
- }
3154
- assertRepresentable(value, `${value}`);
3155
- return (0, import_solver_discovery3.fromAtomic)(value, asset7.decimals);
3156
- }
3157
- };
3158
- var toAtomicDecimal = (value) => {
3159
- if (value < 0n) {
3160
- throw new AmountFormatError("negative", `amount must be non-negative, got ${value}`);
3161
- }
3162
- assertRepresentable(value, `${value}`);
3163
- return value.toString();
3164
- };
3165
- var fromAtomicDecimal = (text) => {
3166
- if (!(0, import_solver_discovery3.isAmount)(text)) {
3167
- throw new AmountFormatError(
3168
- "not_canonical",
3169
- `not a canonical atomic amount: ${JSON.stringify(text)}`
3170
- );
3171
- }
3172
- return BigInt(text);
3173
- };
3174
- var isAtomicDecimal = (value) => typeof value === "string" && import_solver_discovery3.AMOUNT_PATTERN.test(value);
3175
-
3176
4052
  // src/client/rfqAmount.ts
3177
- var import_solver_discovery4 = require("@arkade-os/solver-discovery");
4053
+ var import_solver_discovery5 = require("@arkade-os/solver-discovery");
3178
4054
  var toRfqAmountSide = (on) => on === "give" ? "from" : "to";
3179
4055
  var fromRfqAmountSide = (side) => side === "from" ? "give" : "take";
3180
4056
  var encodeRfqAmount = (value, field) => {
@@ -3191,7 +4067,7 @@ var encodeRfqAmount = (value, field) => {
3191
4067
  };
3192
4068
  var decodeRfqAmount = (raw, field) => {
3193
4069
  if (typeof raw === "string") {
3194
- if (!(0, import_solver_discovery4.isAmount)(raw)) {
4070
+ if (!(0, import_solver_discovery5.isAmount)(raw)) {
3195
4071
  throw new AmountEncodingUnsupported(
3196
4072
  field,
3197
4073
  raw,
@@ -3227,108 +4103,6 @@ var toSafeNumber = (value, field) => {
3227
4103
  return Number(value);
3228
4104
  };
3229
4105
 
3230
- // src/client/record.ts
3231
- var assetSwapIdOf = (family, quoteId) => `${family}:${quoteId}`;
3232
- var OFFER_SWAP_ID_PREFIX = "offer:";
3233
- var RFQ_SWAP_ID_PREFIX = "rfq:";
3234
- var familyOfSwapId = (swapId) => swapId.startsWith(OFFER_SWAP_ID_PREFIX) ? "offer" : swapId.startsWith(RFQ_SWAP_ID_PREFIX) ? "rfq" : void 0;
3235
- var quoteIdOfSwapId = (swapId) => {
3236
- const family = familyOfSwapId(swapId);
3237
- return family === void 0 ? swapId : swapId.slice(`${family}:`.length);
3238
- };
3239
- var recordEndpoint = (endpoint2) => ({
3240
- corridor: endpoint2.corridor,
3241
- asset: endpoint2.asset,
3242
- instrument: recordInstrument(endpoint2.instrument)
3243
- });
3244
- var recordInstrument = (instrument) => {
3245
- switch (instrument.kind) {
3246
- case "wallet":
3247
- return { kind: "wallet" };
3248
- case "address":
3249
- return { kind: "address", address: instrument.address };
3250
- case "invoice":
3251
- return {
3252
- kind: "invoice",
3253
- bolt11: instrument.bolt11,
3254
- paymentHash: instrument.paymentHash,
3255
- ...instrument.amount === void 0 ? {} : { amount: toAtomicDecimal(instrument.amount) },
3256
- expiresAt: instrument.expiresAt
3257
- };
3258
- }
3259
- };
3260
- var instrumentOf = (instrument) => {
3261
- switch (instrument.kind) {
3262
- case "wallet":
3263
- return { kind: "wallet" };
3264
- case "address":
3265
- return { kind: "address", address: instrument.address };
3266
- case "invoice":
3267
- return {
3268
- kind: "invoice",
3269
- bolt11: instrument.bolt11,
3270
- paymentHash: instrument.paymentHash,
3271
- ...instrument.amount === void 0 ? {} : { amount: fromAtomicDecimal(instrument.amount) },
3272
- expiresAt: instrument.expiresAt
3273
- };
3274
- }
3275
- };
3276
- var recordArtifact = (artifact) => artifact.kind === "invoice" ? { kind: "invoice", bolt11: artifact.bolt11 } : {
3277
- kind: "deposit",
3278
- corridor: artifact.corridor,
3279
- address: artifact.address,
3280
- asset: artifact.asset,
3281
- amount: toAtomicDecimal(artifact.amount),
3282
- ...artifact.expiresAt === void 0 ? {} : { expiresAt: artifact.expiresAt }
3283
- };
3284
- var artifactOf = (artifact) => artifact.kind === "invoice" ? { kind: "invoice", bolt11: artifact.bolt11 } : {
3285
- kind: "deposit",
3286
- corridor: artifact.corridor,
3287
- address: artifact.address,
3288
- asset: artifact.asset,
3289
- amount: fromAtomicDecimal(artifact.amount),
3290
- ...artifact.expiresAt === void 0 ? {} : { expiresAt: artifact.expiresAt }
3291
- };
3292
- var recordLeg = (leg) => ({
3293
- asset: leg.asset,
3294
- amount: toAtomicDecimal(leg.amount)
3295
- });
3296
- var legOf = (leg) => ({
3297
- asset: leg.asset,
3298
- amount: fromAtomicDecimal(leg.amount)
3299
- });
3300
- var swapOf = (record, outcome) => ({
3301
- id: assetSwapIdOf(record.family, record.id),
3302
- family: record.family,
3303
- outcome,
3304
- route: {
3305
- give: {
3306
- corridor: record.route.give.corridor,
3307
- asset: record.route.give.asset,
3308
- instrument: instrumentOf(record.route.give.instrument)
3309
- },
3310
- take: {
3311
- corridor: record.route.take.corridor,
3312
- asset: record.route.take.asset,
3313
- instrument: instrumentOf(record.route.take.instrument)
3314
- }
3315
- },
3316
- give: legOf(record.give),
3317
- take: legOf(record.take),
3318
- fee: legOf(record.fee),
3319
- market: record.market,
3320
- ...record.solver === void 0 ? {} : { solver: record.solver },
3321
- ...record.family === "rfq" ? { lock: record.lock, refundLocktime: record.refundLocktime } : {},
3322
- ...record.artifact === void 0 ? {} : { artifact: artifactOf(record.artifact) },
3323
- expiresAt: record.expiresAt,
3324
- ...record.fundingTxid === void 0 ? {} : { fundingTxid: record.fundingTxid },
3325
- ...record.failure === void 0 ? {} : { failure: record.failure },
3326
- ...record.blockedReason === void 0 ? {} : { blockedReason: record.blockedReason },
3327
- createdAt: record.createdAt,
3328
- updatedAt: record.updatedAt
3329
- });
3330
- var fundsFromWallet = (route) => route.give.instrument.kind === "wallet";
3331
-
3332
4106
  // src/client/accept.ts
3333
4107
  var acceptLocks = /* @__PURE__ */ new Map();
3334
4108
  var runSerialized = (id, body) => {
@@ -3364,6 +4138,7 @@ var conflictingFields = (record, quote) => {
3364
4138
  const incoming = recordedFacts(quote);
3365
4139
  const stored = {
3366
4140
  "route.pair": `${record.route.give.corridor}->${record.route.take.corridor}`,
4141
+ assetPayment: assetPaymentFacts(record.assetPayment),
3367
4142
  "give.asset": record.route.give.asset,
3368
4143
  "take.asset": record.route.take.asset,
3369
4144
  "give.amount": record.give.amount,
@@ -3387,6 +4162,9 @@ var conflictingFields = (record, quote) => {
3387
4162
  };
3388
4163
  var recordedFacts = (quote) => ({
3389
4164
  "route.pair": `${quote.route.give.corridor}->${quote.route.take.corridor}`,
4165
+ assetPayment: assetPaymentFacts(
4166
+ quote.assetPayment === void 0 ? void 0 : recordAssetPayment(quote.assetPayment)
4167
+ ),
3390
4168
  "give.asset": quote.route.give.asset,
3391
4169
  "take.asset": quote.route.take.asset,
3392
4170
  "give.amount": recordLeg(quote.give).amount,
@@ -3409,6 +4187,7 @@ var assertFundable2 = async (wallet, quote) => {
3409
4187
  };
3410
4188
  var commonOf = (quote, now) => ({
3411
4189
  id: quote.id,
4190
+ ...quote.assetPayment === void 0 ? {} : { assetPayment: recordAssetPayment(quote.assetPayment) },
3412
4191
  route: {
3413
4192
  give: recordEndpoint(quote.route.give),
3414
4193
  take: recordEndpoint(quote.route.take)
@@ -3434,7 +4213,7 @@ var corridorRecord = (quote, preparation, now) => {
3434
4213
  kind: KIND_OF[preparation.route],
3435
4214
  rfqId: preparation.rfqId,
3436
4215
  lockupAddress: preparation.lockup.address,
3437
- lockupPkScript: import_base8.hex.encode(preparation.lockup.pkScript),
4216
+ lockupPkScript: import_base9.hex.encode(preparation.lockup.pkScript),
3438
4217
  lock: { hash: quote.lock.hash },
3439
4218
  refundLocktime: quote.refundLocktime,
3440
4219
  profile: profileOf(preparation, quote.lock.hash)
@@ -3497,6 +4276,7 @@ var acceptQuoteBody = async (input) => {
3497
4276
  if (fields.length > 0) {
3498
4277
  throw new AcceptConflict(quote.id, stored.id, fields);
3499
4278
  }
4279
+ if (fundingWasNotSubmitted(stored)) return answer(stored);
3500
4280
  if (stored.fundingTxid !== void 0) return answer(stored);
3501
4281
  if (!fundsFromWallet(stored.route)) return answer(stored);
3502
4282
  const found = await reconcileFunding({ wallet }, stored);
@@ -3504,7 +4284,13 @@ var acceptQuoteBody = async (input) => {
3504
4284
  return answer(await stampFunding(repository, stored, found, now));
3505
4285
  }
3506
4286
  if (expired) throw new QuoteExpired(quote.id, quote.expiresAt, now);
3507
- return answer(await fundAndStamp({ wallet, now }, stored, repository));
4287
+ return answer(
4288
+ await fundAndStamp(
4289
+ { wallet, now, validUntil: input.validUntil, drive: input.drive },
4290
+ stored,
4291
+ repository
4292
+ )
4293
+ );
3508
4294
  }
3509
4295
  if (expired) throw new QuoteExpired(quote.id, quote.expiresAt, now);
3510
4296
  const preparation = input.preparation;
@@ -3518,48 +4304,114 @@ var acceptQuoteBody = async (input) => {
3518
4304
  const record = preparation.backend === "feed" ? await registeredOfferRecord(input, preparation) : preparation.route === "arkade->arkade" ? await registeredAssetRecord(input, preparation) : await registeredCorridorRecord(input, preparation);
3519
4305
  await repository.saveSwapRecord(record);
3520
4306
  if (!funds) return answer(record);
3521
- return answer(await fundAndStamp({ wallet, now }, record, repository));
4307
+ return answer(
4308
+ await fundAndStamp(
4309
+ {
4310
+ wallet,
4311
+ now,
4312
+ validUntil: input.validUntil,
4313
+ drive: input.drive,
4314
+ firstFundingAttempt: true
4315
+ },
4316
+ record,
4317
+ repository
4318
+ )
4319
+ );
3522
4320
  };
3523
4321
  var registeredOfferRecord = async (input, preparation) => {
3524
4322
  const { quote, wallet, corridors, now } = input;
3525
4323
  const { plan } = preparation;
3526
4324
  const arkade2 = corridors.get("arkade").deps;
3527
4325
  const receiveIsBtc = plan.receive.asset.id === BTC_ASSET_ID;
3528
- const offer = await createOffer(wallet, {
3529
- // Keyed on the receive side: the covenant binds what the fill delivers.
3530
- wantAmount: plan.receive.atomic,
3531
- ...receiveIsBtc ? { offerAsset: import_sdk11.asset.AssetId.fromString(plan.deposit.asset.id) } : { wantAsset: import_sdk11.asset.AssetId.fromString(plan.receive.asset.id) },
3532
- emulatorPubkey: arkade2.emulatorPubkey
3533
- });
4326
+ const offer = await createOffer(
4327
+ wallet,
4328
+ {
4329
+ // Keyed on the receive side: the covenant binds what the fill delivers.
4330
+ wantAmount: plan.receive.atomic,
4331
+ ...receiveIsBtc ? { offerAsset: import_sdk13.asset.AssetId.fromString(plan.deposit.asset.id) } : { wantAsset: import_sdk13.asset.AssetId.fromString(plan.receive.asset.id) },
4332
+ emulatorPubkey: arkade2.emulatorPubkey
4333
+ },
4334
+ { coverageId: quote.id }
4335
+ );
3534
4336
  return {
3535
4337
  ...commonOf(quote, now),
3536
4338
  family: "offer",
3537
4339
  status: "pending",
3538
4340
  offerHex: offer.offerHex,
3539
4341
  swapAddress: offer.address,
3540
- swapPkScript: import_base8.hex.encode(offer.swapPkScript)
4342
+ swapPkScript: import_base9.hex.encode(offer.swapPkScript)
3541
4343
  };
3542
4344
  };
3543
4345
  var registeredAssetRecord = async (input, preparation) => {
3544
- await registerDerivedOffer(input.wallet, preparation.offer);
4346
+ if ((0, import_solver_discovery6.stableStringify)(
4347
+ input.quote.assetPayment === void 0 ? void 0 : recordAssetPayment(input.quote.assetPayment)
4348
+ ) !== (0, import_solver_discovery6.stableStringify)(
4349
+ preparation.assetPayment === void 0 ? void 0 : recordAssetPayment(preparation.assetPayment)
4350
+ ))
4351
+ throw new Error("asset payment differs from verified quote preparation");
4352
+ if (preparation.assetPaymentRecipient !== void 0 && (0, import_solver_discovery6.stableStringify)(input.quote.route.take.instrument) !== (0, import_solver_discovery6.stableStringify)(preparation.assetPaymentRecipient))
4353
+ throw new Error("asset payment recipient differs from verified quote preparation");
4354
+ await registerDerivedOffer(input.wallet, preparation.offer, { coverageId: input.quote.id });
3545
4355
  return {
3546
4356
  ...commonOf(input.quote, input.now),
4357
+ ...preparation.assetPayment === void 0 ? {} : { assetPayment: recordAssetPayment(preparation.assetPayment) },
3547
4358
  family: "offer",
3548
4359
  status: "pending",
3549
4360
  offerHex: preparation.offer.offerHex,
3550
4361
  swapAddress: preparation.offer.address,
3551
- swapPkScript: import_base8.hex.encode(preparation.offer.swapPkScript),
4362
+ swapPkScript: import_base9.hex.encode(preparation.offer.swapPkScript),
3552
4363
  ...preparation.carrierSats === void 0 ? {} : { carrierSats: preparation.carrierSats.toString() }
3553
4364
  };
3554
4365
  };
3555
4366
  var registeredCorridorRecord = async (input, preparation) => {
3556
4367
  const contracts = await input.wallet.getContractManager();
3557
- await registerLockupContract(contracts, preparation.lockup.script, preparation.lockup.address);
4368
+ await registerLockupContract(contracts, preparation.lockup.script, preparation.lockup.address, {
4369
+ coverageId: input.quote.id,
4370
+ scope: input.wallet
4371
+ });
4372
+ await promoteOfferContract(
4373
+ contracts,
4374
+ import_base9.hex.encode(preparation.lockup.script.pkScript),
4375
+ void 0,
4376
+ {
4377
+ coverageId: input.quote.id,
4378
+ scope: input.wallet
4379
+ }
4380
+ );
3558
4381
  return corridorRecord(input.quote, preparation, input.now);
3559
4382
  };
3560
4383
  var fundAndStamp = async (input, record, repository) => {
3561
- const txid = await fund(input, record);
3562
- return stampFunding(repository, record, txid, input.now);
4384
+ const bounds = storedFundingBounds(record.assetPayment, record.expiresAt);
4385
+ const cap = input.validUntil === void 0 ? bounds.validUntil : Math.min(input.validUntil, bounds.validUntil ?? record.expiresAt);
4386
+ const validUntil = cap === void 0 ? void 0 : Math.min(cap, record.expiresAt);
4387
+ if (input.firstFundingAttempt && record.assetPayment !== void 0 && validUntil !== void 0 && validUntil < record.assetPayment.validUntil) {
4388
+ record = { ...record, assetPayment: { ...record.assetPayment, validUntil } };
4389
+ await repository.saveSwapRecord(record);
4390
+ }
4391
+ try {
4392
+ const txid = await fund({ ...input, ...bounds, validUntil }, record);
4393
+ return stampFunding(repository, record, txid, input.now);
4394
+ } catch (error) {
4395
+ if (input.firstFundingAttempt && validUntil !== void 0 && error instanceof import_sdk13.SendDeadlineExceededError) {
4396
+ const stopped = {
4397
+ ...record,
4398
+ ...record.family === "offer" ? { status: "cancelled" } : { state: "failed" },
4399
+ fundingNotSubmitted: { reason: "send_deadline", validUntil },
4400
+ updatedAt: Math.floor(Date.now() / 1e3)
4401
+ };
4402
+ try {
4403
+ await repository.saveSwapRecord(stopped);
4404
+ input.drive?.ingest(stopped);
4405
+ await retireUnsubmittedFunding(input.wallet, repository, stopped);
4406
+ } catch (cause) {
4407
+ console.warn(
4408
+ `[swap] could not finish unsent funding cleanup for ${record.id}`,
4409
+ cause
4410
+ );
4411
+ }
4412
+ }
4413
+ throw error;
4414
+ }
3563
4415
  };
3564
4416
  var stampFunding = async (repository, record, fundingTxid, now) => {
3565
4417
  const stamped = { ...record, fundingTxid, updatedAt: now };
@@ -3572,10 +4424,15 @@ var stampFunding = async (repository, record, fundingTxid, now) => {
3572
4424
  };
3573
4425
  var fund = async (input, record) => {
3574
4426
  const { wallet } = input;
4427
+ const send = (recipient) => input.validUntil === void 0 && input.inputExpiryFloor === void 0 ? wallet.send(recipient) : wallet.send({
4428
+ recipients: [recipient],
4429
+ ...input.validUntil === void 0 ? {} : { validUntil: input.validUntil },
4430
+ ...input.inputExpiryFloor === void 0 ? {} : { inputExpiryFloor: input.inputExpiryFloor }
4431
+ });
3575
4432
  if (record.family === "offer") {
3576
4433
  const amount = fromAtomicDecimal(record.give.amount);
3577
4434
  const depositIsBtc = isBtcAssetLenient(record.route.give.asset);
3578
- return wallet.send({
4435
+ return send({
3579
4436
  address: record.swapAddress,
3580
4437
  // An asset deposit rides a dust-sat carrier: the solver's published one when the record
3581
4438
  // names it (the fill is priced against it), else the SDK default.
@@ -3591,20 +4448,20 @@ var fund = async (input, record) => {
3591
4448
  if (record.kind === "lightning_receive" || record.kind === "onchain_receive") {
3592
4449
  throw new Error(`receive swap ${record.id} funds nothing from this wallet`);
3593
4450
  }
3594
- return wallet.send({
4451
+ return send({
3595
4452
  address: record.lockupAddress,
3596
4453
  amount: toSafeNumber(fromAtomicDecimal(record.give.amount), "give.amount")
3597
4454
  });
3598
4455
  };
3599
4456
  var offerExtensionOf = (record) => ({
3600
4457
  type: OFFER_PACKET_TYPE,
3601
- payload: import_base8.hex.decode(record.offerHex)
4458
+ payload: import_base9.hex.decode(record.offerHex)
3602
4459
  });
3603
4460
  var reconcileFunding = async (input, record) => {
3604
4461
  const script = record.family === "offer" ? record.swapPkScript : record.lockupPkScript;
3605
4462
  const expected = BigInt(record.give.amount);
3606
4463
  const reader = await input.wallet.getArkadeReader();
3607
- const vtxos = await (0, import_sdk11.getAllNormalizedVtxos)(reader, [script]);
4464
+ const vtxos = await (0, import_sdk13.getAllNormalizedVtxos)(reader, [script]);
3608
4465
  const deposit = vtxos.find((vtxo) => depositMatches(vtxo, record, expected));
3609
4466
  return deposit?.txid;
3610
4467
  };
@@ -3632,9 +4489,9 @@ var LEGACY_CORRIDORS = {
3632
4489
  };
3633
4490
  var assetOf = (market, side) => side === "base" ? market.base_asset : market.quote_asset;
3634
4491
  var marketAssetId = (market, side) => {
3635
- const asset7 = assetOf(market, side);
3636
- if (typeof asset7?.caip19_id === "string") return asset7.caip19_id;
3637
- return typeof asset7?.id === "string" ? asset7.id : void 0;
4492
+ const asset8 = assetOf(market, side);
4493
+ if (typeof asset8?.caip19_id === "string") return asset8.caip19_id;
4494
+ return typeof asset8?.id === "string" ? asset8.id : void 0;
3638
4495
  };
3639
4496
  var chainNamespaceOf = (id) => {
3640
4497
  if (id === void 0) return void 0;
@@ -3705,13 +4562,14 @@ var scopedToRail = (table, rail) => ({
3705
4562
  });
3706
4563
 
3707
4564
  // src/client/client.ts
3708
- var import_base19 = require("@scure/base");
4565
+ var import_base21 = require("@scure/base");
4566
+ var import_sdk36 = require("@arkade-os/sdk");
3709
4567
  init_repository();
3710
4568
 
3711
4569
  // src/refund.ts
3712
- var import_base9 = require("@scure/base");
4570
+ var import_base10 = require("@scure/base");
3713
4571
  var import_sha24 = require("@noble/hashes/sha2.js");
3714
- var import_sdk12 = require("@arkade-os/sdk");
4572
+ var import_sdk14 = require("@arkade-os/sdk");
3715
4573
  init_onchainHtlc();
3716
4574
  init_rfq();
3717
4575
  var walletOperator = (wallet) => {
@@ -3743,13 +4601,13 @@ var LockupNeedsRecoveryError = class extends Error {
3743
4601
  };
3744
4602
  async function findLockupVtxos(contracts, swapPkScript) {
3745
4603
  const [row] = await contracts.getContractsWithVtxos({
3746
- script: import_base9.hex.encode(swapPkScript)
4604
+ script: import_base10.hex.encode(swapPkScript)
3747
4605
  });
3748
4606
  const seen = /* @__PURE__ */ new Set();
3749
4607
  const out = [];
3750
4608
  for (const vtxo of row?.vtxos ?? []) {
3751
4609
  if (vtxo.isUnrolled) continue;
3752
- if ((0, import_sdk12.isVtxoSpent)(vtxo)) continue;
4610
+ if ((0, import_sdk14.isVtxoSpent)(vtxo)) continue;
3753
4611
  const key = `${vtxo.txid}:${vtxo.vout}`;
3754
4612
  if (seen.has(key)) continue;
3755
4613
  seen.add(key);
@@ -3762,16 +4620,16 @@ async function findLockupVtxos(contracts, swapPkScript) {
3762
4620
  }
3763
4621
  return out;
3764
4622
  }
3765
- var hashesTo = (candidate, paymentHash) => import_base9.hex.encode((0, import_sha24.sha256)(candidate)) === paymentHash;
4623
+ var hashesTo = (candidate, paymentHash) => import_base10.hex.encode((0, import_sha24.sha256)(candidate)) === paymentHash;
3766
4624
  var candidateWitnessItems = (tx, inputIndex) => [
3767
- ...(0, import_sdk12.getArkPsbtFields)(tx, inputIndex, import_sdk12.ConditionWitness).flat(),
4625
+ ...(0, import_sdk14.getArkPsbtFields)(tx, inputIndex, import_sdk14.ConditionWitness).flat(),
3768
4626
  ...tx.getInput(inputIndex).finalScriptWitness ?? []
3769
4627
  ];
3770
4628
  async function readLockupFate(indexer, input) {
3771
- const { vtxos } = await indexer.getVtxos({ scripts: [import_base9.hex.encode(input.swapPkScript)] });
4629
+ const { vtxos } = await indexer.getVtxos({ scripts: [import_base10.hex.encode(input.swapPkScript)] });
3772
4630
  const all = vtxos ?? [];
3773
4631
  if (all.length === 0) return { fate: "unknown" };
3774
- const exited = all.filter((vtxo) => vtxo.isUnrolled && !(0, import_sdk12.isVtxoSpent)(vtxo));
4632
+ const exited = all.filter((vtxo) => vtxo.isUnrolled && !(0, import_sdk14.isVtxoSpent)(vtxo));
3775
4633
  if (exited.length > 0) {
3776
4634
  return {
3777
4635
  fate: "exited",
@@ -3780,8 +4638,13 @@ async function readLockupFate(indexer, input) {
3780
4638
  }
3781
4639
  const spentBy = /* @__PURE__ */ new Map();
3782
4640
  let everySpendNamed = true;
4641
+ let sweptLeft = false;
3783
4642
  for (const vtxo of all) {
3784
- if (!(0, import_sdk12.isVtxoSpent)(vtxo)) return { fate: "open" };
4643
+ if (!(0, import_sdk14.isVtxoSpent)(vtxo)) {
4644
+ if (!(input.receiver && vtxo.isSwept)) return { fate: "open" };
4645
+ sweptLeft = true;
4646
+ continue;
4647
+ }
3785
4648
  if (vtxo.spentBy)
3786
4649
  spentBy.set(vtxo.spentBy, {
3787
4650
  checkpointTxid: vtxo.spentBy,
@@ -3795,7 +4658,7 @@ async function readLockupFate(indexer, input) {
3795
4658
  for (const raw of txs) {
3796
4659
  let tx;
3797
4660
  try {
3798
- tx = import_sdk12.Transaction.fromPSBT(import_base9.base64.decode(raw));
4661
+ tx = import_sdk14.Transaction.fromPSBT(import_base10.base64.decode(raw));
3799
4662
  } catch {
3800
4663
  continue;
3801
4664
  }
@@ -3803,7 +4666,7 @@ async function readLockupFate(indexer, input) {
3803
4666
  for (let i = 0; i < tx.inputsLength; i++) {
3804
4667
  const spent = tx.getInput(i);
3805
4668
  if (!spent.txid) continue;
3806
- const txid = import_base9.hex.encode(spent.txid);
4669
+ const txid = import_base10.hex.encode(spent.txid);
3807
4670
  if (!all.some((vtxo) => vtxo.txid === txid && vtxo.vout === spent.index)) continue;
3808
4671
  for (const candidate of candidateWitnessItems(tx, i)) {
3809
4672
  if (hashesTo(candidate, input.paymentHash)) {
@@ -3812,6 +4675,7 @@ async function readLockupFate(indexer, input) {
3812
4675
  }
3813
4676
  }
3814
4677
  }
4678
+ if (sweptLeft) return { fate: "open" };
3815
4679
  return everySpendNamed && observed.size === spentBy.size ? { fate: "returned", spends } : { fate: "unknown" };
3816
4680
  }
3817
4681
  var assertNoneSwept = (vtxos, contract) => {
@@ -3825,13 +4689,15 @@ var assertNoneSwept = (vtxos, contract) => {
3825
4689
  };
3826
4690
  var operatorUnrollScript = async (operator, network) => {
3827
4691
  const info = await operator.getInfo();
3828
- return (0, import_sdk12.assertValidServerUnrollScript)(
4692
+ return (0, import_sdk14.assertValidServerUnrollScript)(
3829
4693
  info.checkpointTapscript,
3830
- (0, import_sdk12.resolveCheckpointExitDelayPolicy)(network ?? (0, import_sdk12.networkFromArkadeInfo)(info), {
3831
- advertisedForfeitPubkey: (0, import_sdk12.toXOnly)(import_base9.hex.decode(info.forfeitPubkey), "forfeit key")
4694
+ (0, import_sdk14.resolveCheckpointExitDelayPolicy)(network ?? (0, import_sdk14.networkFromArkadeInfo)(info), {
4695
+ advertisedForfeitPubkey: (0, import_sdk14.toXOnly)(import_base10.hex.decode(info.forfeitPubkey), "forfeit key")
3832
4696
  })
3833
4697
  );
3834
4698
  };
4699
+ var MAX_LOCKUP_SPEND_INPUTS = 16;
4700
+ var boundedLockupSpend = (vtxos) => [...vtxos].sort((a, b) => b.value - a.value).slice(0, MAX_LOCKUP_SPEND_INPUTS);
3835
4701
  var lockupInputs = (vtxos, contract, leaf) => {
3836
4702
  const tapTree = contract.encode();
3837
4703
  return vtxos.map((vtxo) => ({
@@ -3853,38 +4719,44 @@ async function pushRefundWithoutReceiver(operator, input) {
3853
4719
  }
3854
4720
  const serverUnrollScript = await operatorUnrollScript(operator, input.network);
3855
4721
  const leaf = input.contract.refundWithoutReceiver();
3856
- const amount = input.vtxos.reduce((sum, vtxo) => sum + vtxo.value, 0);
3857
- const { arkTx: tx, checkpoints } = (0, import_sdk12.buildOffchainTx)(
3858
- lockupInputs(input.vtxos, input.contract, leaf),
4722
+ const vtxos = boundedLockupSpend(input.vtxos);
4723
+ const amount = vtxos.reduce((sum, vtxo) => sum + vtxo.value, 0);
4724
+ const { arkTx: tx, checkpoints } = (0, import_sdk14.buildOffchainTx)(
4725
+ lockupInputs(vtxos, input.contract, leaf),
3859
4726
  [{ script: refundPkScript, amount: BigInt(amount) }],
3860
4727
  serverUnrollScript
3861
4728
  );
3862
4729
  const signedTx = await input.sender.sign(tx);
3863
4730
  const submitted = await operator.submitTx(
3864
- import_base9.base64.encode(signedTx.toPSBT()),
3865
- checkpoints.map((c) => import_base9.base64.encode(c.toPSBT()))
4731
+ import_base10.base64.encode(signedTx.toPSBT()),
4732
+ checkpoints.map((c) => import_base10.base64.encode(c.toPSBT()))
3866
4733
  );
3867
- (0, import_sdk12.assertSubmittedArkTxid)(submitted, signedTx, "refundWithoutReceiver");
3868
- const matched = (0, import_sdk12.matchServerCheckpoints)(
4734
+ (0, import_sdk14.assertSubmittedArkTxid)(submitted, signedTx, "refundWithoutReceiver");
4735
+ const matched = (0, import_sdk14.matchServerCheckpoints)(
3869
4736
  submitted.signedCheckpointTxs,
3870
4737
  checkpoints,
3871
4738
  "refundWithoutReceiver"
3872
4739
  );
3873
4740
  const finalCheckpoints = await Promise.all(
3874
4741
  matched.map(
3875
- async ({ server }) => import_base9.base64.encode((await input.sender.sign(server, [0])).toPSBT())
4742
+ async ({ server }) => import_base10.base64.encode((await input.sender.sign(server, [0])).toPSBT())
3876
4743
  )
3877
4744
  );
3878
4745
  await operator.finalizeTx(submitted.arkTxid, finalCheckpoints);
3879
- return { txid: submitted.arkTxid, amount };
4746
+ return {
4747
+ txid: submitted.arkTxid,
4748
+ amount,
4749
+ left: input.vtxos.length - vtxos.length,
4750
+ spent: vtxos
4751
+ };
3880
4752
  }
3881
4753
  var REFUND_MTP_LAG_SECONDS = 2 * 60 * 60;
3882
4754
 
3883
4755
  // src/client/corridors/registry.ts
3884
- var import_sdk16 = require("@arkade-os/sdk");
4756
+ var import_sdk18 = require("@arkade-os/sdk");
3885
4757
 
3886
4758
  // src/client/corridors/arkade.ts
3887
- var import_sdk13 = require("@arkade-os/sdk");
4759
+ var import_sdk15 = require("@arkade-os/sdk");
3888
4760
  var ARKADE_DRIVE = {};
3889
4761
  var messageOf = (error) => error instanceof Error ? error.message : String(error);
3890
4762
  var arkadeCorridor = Object.assign(
@@ -3893,11 +4765,11 @@ var arkadeCorridor = Object.assign(
3893
4765
  deps,
3894
4766
  drive: ARKADE_DRIVE,
3895
4767
  matches(raw) {
3896
- const target = (0, import_sdk13.arkTarget)(raw);
4768
+ const target = (0, import_sdk15.arkTarget)(raw);
3897
4769
  if (target === void 0) return void 0;
3898
4770
  try {
3899
- const address = import_sdk13.ArkAddress.decode(target);
3900
- (0, import_sdk13.assertRecipientArkadeAddress)(target, address, {
4771
+ const address = import_sdk15.ArkAddress.decode(target);
4772
+ (0, import_sdk15.assertRecipientArkadeAddress)(target, address, {
3901
4773
  hrp: deps.network.hrp,
3902
4774
  signerSet: deps.signerSet
3903
4775
  });
@@ -3907,11 +4779,11 @@ var arkadeCorridor = Object.assign(
3907
4779
  return { claimed: { kind: "address", address: target } };
3908
4780
  }
3909
4781
  }),
3910
- { target: import_sdk13.arkTarget }
4782
+ { target: import_sdk15.arkTarget }
3911
4783
  );
3912
4784
 
3913
4785
  // src/client/corridors/deps.ts
3914
- var import_sdk15 = require("@arkade-os/sdk");
4786
+ var import_sdk17 = require("@arkade-os/sdk");
3915
4787
  init_onchainHtlc();
3916
4788
  init_rfq();
3917
4789
 
@@ -3942,9 +4814,9 @@ var decodeBolt11 = (invoice) => {
3942
4814
  };
3943
4815
 
3944
4816
  // src/client/corridors/chainSource.ts
3945
- var import_base10 = require("@scure/base");
4817
+ var import_base11 = require("@scure/base");
3946
4818
  var btc3 = __toESM(require("@scure/btc-signer"), 1);
3947
- var import_sdk14 = require("@arkade-os/sdk");
4819
+ var import_sdk16 = require("@arkade-os/sdk");
3948
4820
  var addressOfScript = (script, network) => btc3.Address(network).encode(btc3.OutScript.decode(script));
3949
4821
  var chainSourceOver = (backend, network) => {
3950
4822
  const spenderFromVins = async (txid, vout, pkScript) => {
@@ -3982,13 +4854,19 @@ var chainSourceOver = (backend, network) => {
3982
4854
  if (!outspend?.spent) return null;
3983
4855
  const spender = outspend.txid || await spenderFromVins(txid, vout, pkScript);
3984
4856
  if (!spender) return null;
3985
- return { txHex: import_base10.hex.encode(await backend.provider.getRawTransaction(spender)) };
4857
+ return { txHex: import_base11.hex.encode(await backend.provider.getRawTransaction(spender)) };
3986
4858
  },
3987
4859
  broadcast(txHex) {
3988
4860
  return backend.provider.broadcastTransaction(txHex);
3989
4861
  },
3990
4862
  async getMtp() {
3991
4863
  return (await backend.tip()).mtp;
4864
+ },
4865
+ async getTxStatus(txid) {
4866
+ return (await backend.provider.getTxStatus(txid)).confirmed ? "confirmed" : "unconfirmed";
4867
+ },
4868
+ getFeeRate() {
4869
+ return backend.provider.getFeeRate();
3992
4870
  }
3993
4871
  };
3994
4872
  };
@@ -4006,7 +4884,7 @@ var esploraTip = async (esploraUrl, fetchImpl) => {
4006
4884
  };
4007
4885
  var esploraChainSource = (input) => chainSourceOver(
4008
4886
  {
4009
- provider: new import_sdk14.EsploraProvider(input.esploraUrl),
4887
+ provider: new import_sdk16.EsploraProvider(input.esploraUrl),
4010
4888
  tip: () => esploraTip(input.esploraUrl, input.fetchImpl)
4011
4889
  },
4012
4890
  input.network
@@ -4032,10 +4910,10 @@ var refusedIfMalformed = (value, dep) => {
4032
4910
  };
4033
4911
  var emulatorPubkeyFor = (base) => {
4034
4912
  if (base.emulatorPubkey !== void 0) {
4035
- return (0, import_sdk15.resolveEmulatorPubkey)(base.network, base.emulatorPubkey);
4913
+ return (0, import_sdk17.resolveEmulatorPubkey)(base.network, base.emulatorPubkey);
4036
4914
  }
4037
4915
  try {
4038
- return (0, import_sdk15.defaultEmulatorPubkey)(base.network);
4916
+ return (0, import_sdk17.defaultEmulatorPubkey)(base.network);
4039
4917
  } catch {
4040
4918
  throw new MissingCorridorDep(
4041
4919
  "arkade",
@@ -4085,7 +4963,7 @@ function resolveCorridorDeps(corridor, overrides, base) {
4085
4963
  return {
4086
4964
  networkName: base.networkName,
4087
4965
  chain: esploraChainSource({
4088
- esploraUrl: chain?.esploraUrl ?? import_sdk15.ESPLORA_URL[base.networkName],
4966
+ esploraUrl: chain?.esploraUrl ?? import_sdk17.ESPLORA_URL[base.networkName],
4089
4967
  network: L1_NETWORKS[l1NetworkFromArk(base.networkName)],
4090
4968
  fetchImpl: base.fetchImpl
4091
4969
  }),
@@ -4115,8 +4993,8 @@ var resolveCorridorBase = async (input) => {
4115
4993
  wallet: input.wallet,
4116
4994
  operator: input.operator,
4117
4995
  networkName,
4118
- network: (0, import_sdk15.getNetwork)(networkName),
4119
- signerSet: (0, import_sdk15.signerSetFromInfo)(info),
4996
+ network: (0, import_sdk17.getNetwork)(networkName),
4997
+ signerSet: (0, import_sdk17.signerSetFromInfo)(info),
4120
4998
  emulatorPubkey: input.emulatorPubkey,
4121
4999
  fetchImpl: input.fetchImpl,
4122
5000
  repository: input.repository
@@ -4146,7 +5024,7 @@ var corridorSet = (base, overrides) => {
4146
5024
  (corridor) => CORRIDOR_FACTORIES[corridor].target(raw) !== void 0
4147
5025
  );
4148
5026
  if (owners.length === 0) {
4149
- if ((0, import_sdk16.isLnurl)(raw)) return void 0;
5027
+ if ((0, import_sdk18.isLnurl)(raw)) return void 0;
4150
5028
  throw new AmbiguousDestination(raw, "no corridor recognises this destination");
4151
5029
  }
4152
5030
  const claims = [];
@@ -4170,15 +5048,15 @@ var corridorSet = (base, overrides) => {
4170
5048
  };
4171
5049
 
4172
5050
  // src/client/discovery.ts
4173
- var import_solver_discovery7 = require("@arkade-os/solver-discovery");
5051
+ var import_solver_discovery9 = require("@arkade-os/solver-discovery");
4174
5052
 
4175
5053
  // src/markets.ts
4176
- var import_solver_discovery6 = require("@arkade-os/solver-discovery");
4177
- var import_sdk18 = require("@arkade-os/sdk");
5054
+ var import_solver_discovery8 = require("@arkade-os/solver-discovery");
5055
+ var import_sdk20 = require("@arkade-os/sdk");
4178
5056
  init_store();
4179
5057
  var QUOTE_OPTIONS = { safetyBps: 0 };
4180
5058
  var makeCachedFeedFetch = (ttlMs = 3e4, fetchImpl = fetch) => {
4181
- (0, import_sdk18.assertNonNegativeMs)("ttlMs", ttlMs);
5059
+ (0, import_sdk20.assertNonNegativeMs)("ttlMs", ttlMs);
4182
5060
  const cache = /* @__PURE__ */ new Map();
4183
5061
  const inflight = /* @__PURE__ */ new Map();
4184
5062
  return async (input, init) => {
@@ -4245,7 +5123,7 @@ var nostrCards = {
4245
5123
  }
4246
5124
  };
4247
5125
  var transportCardsOf = (option) => option === void 0 ? nostrCards : option ?? void 0;
4248
- var UNDELIVERED_CARRY_MS = import_solver_discovery6.MAX_CARD_AGE_SECONDS * 1e3;
5126
+ var UNDELIVERED_CARRY_MS = import_solver_discovery8.MAX_CARD_AGE_SECONDS * 1e3;
4249
5127
  var DEGRADED_RETRY_MS = 6e4;
4250
5128
  var trackDelivery = (fetcher) => {
4251
5129
  let undelivered = /* @__PURE__ */ new Set();
@@ -4293,7 +5171,7 @@ var REGISTRY_URL = {
4293
5171
  };
4294
5172
  var HEX_64 = /^[0-9a-f]{64}$/;
4295
5173
  var LEGACY_ASSET_ID = /^(?:btc|[0-9a-f]{68})$/;
4296
- var isRelayList = (value) => Array.isArray(value) && value.length > 0 && value.length <= import_solver_discovery7.MAX_RELAYS && value.every((relay) => typeof relay === "string" && relay.startsWith("wss://"));
5174
+ var isRelayList = (value) => Array.isArray(value) && value.length > 0 && value.length <= import_solver_discovery9.MAX_RELAYS && value.every((relay) => typeof relay === "string" && relay.startsWith("wss://"));
4297
5175
  var isCorridorField = (value) => value === void 0 || CORRIDORS.includes(value);
4298
5176
  var isUsableCard = (value) => {
4299
5177
  const card = value;
@@ -4305,7 +5183,7 @@ var isUsableCard = (value) => {
4305
5183
  const id = marketAssetId(card, side);
4306
5184
  if (id === void 0 || !isAssetId(id) && !LEGACY_ASSET_ID.test(id)) return false;
4307
5185
  }
4308
- if ((0, import_solver_discovery7.isRfqMarket)(card)) {
5186
+ if ((0, import_solver_discovery9.isRfqMarket)(card)) {
4309
5187
  if (typeof card.discovery_pubkey !== "string" || !HEX_64.test(card.discovery_pubkey)) {
4310
5188
  return false;
4311
5189
  }
@@ -4373,7 +5251,7 @@ var discoveryIndex = (input) => {
4373
5251
  }
4374
5252
  const { network: indexed, registry: url } = sources();
4375
5253
  if (indexed && url && config.localCards?.length) {
4376
- const { markets } = await (0, import_solver_discovery7.discover)({
5254
+ const { markets } = await (0, import_solver_discovery9.discover)({
4377
5255
  registries: [],
4378
5256
  localCards: [...config.localCards],
4379
5257
  network: indexed
@@ -4393,7 +5271,7 @@ var discoveryIndex = (input) => {
4393
5271
  return unavailable(whyUnavailable());
4394
5272
  }
4395
5273
  const delivery = trackDelivery(transportCardsOf(config.transportCards));
4396
- const result = await (0, import_solver_discovery7.discover)({
5274
+ const result = await (0, import_solver_discovery9.discover)({
4397
5275
  registries: [url],
4398
5276
  localCards: [...config.localCards ?? []],
4399
5277
  network: indexed,
@@ -4442,14 +5320,14 @@ var discoveryIndex = (input) => {
4442
5320
  };
4443
5321
 
4444
5322
  // src/client/cancel.ts
4445
- var import_base14 = require("@scure/base");
4446
- var import_sdk22 = require("@arkade-os/sdk");
5323
+ var import_base15 = require("@scure/base");
5324
+ var import_sdk24 = require("@arkade-os/sdk");
4447
5325
  init_coverage();
4448
5326
  init_offer();
4449
5327
 
4450
5328
  // src/restore.ts
4451
- var import_base11 = require("@scure/base");
4452
- var import_sdk19 = require("@arkade-os/sdk");
5329
+ var import_base12 = require("@scure/base");
5330
+ var import_sdk21 = require("@arkade-os/sdk");
4453
5331
  init_offer();
4454
5332
  init_store();
4455
5333
  var TXS_PER_REQUEST = 50;
@@ -4474,7 +5352,7 @@ async function fetchParsedTxs(indexer, txids) {
4474
5352
  if (result.status !== "fulfilled") continue;
4475
5353
  for (const psbt of result.value) {
4476
5354
  try {
4477
- const parsed = import_sdk19.Transaction.fromPSBT(import_base11.base64.decode(psbt));
5355
+ const parsed = import_sdk21.Transaction.fromPSBT(import_base12.base64.decode(psbt));
4478
5356
  parsedByTxid.set(parsed.id, parsed);
4479
5357
  } catch {
4480
5358
  }
@@ -4489,7 +5367,7 @@ function classifySpend(offer, operatorPubkey, spendTx, deposit) {
4489
5367
  let leaves;
4490
5368
  try {
4491
5369
  const script = offerContract(offer, operatorPubkey);
4492
- if (import_base11.hex.encode(script.pkScript) !== import_base11.hex.encode(offer.swapPkScript)) return "indeterminate";
5370
+ if (import_base12.hex.encode(script.pkScript) !== import_base12.hex.encode(offer.swapPkScript)) return "indeterminate";
4493
5371
  leaves = {
4494
5372
  // `exit` is absent on an offer with no exit closure, and drops out here
4495
5373
  returned: ["cancel", "exit"].map((name) => script.functionByName(name)?.leafScript).filter((leaf) => leaf !== void 0),
@@ -4501,11 +5379,11 @@ function classifySpend(offer, operatorPubkey, spendTx, deposit) {
4501
5379
  for (let i = 0; i < spendTx.inputsLength; i++) {
4502
5380
  const input = spendTx.getInput(i);
4503
5381
  if (!input.txid || input.index !== deposit.vout) continue;
4504
- if (import_base11.hex.encode(input.txid) !== deposit.txid) continue;
5382
+ if (import_base12.hex.encode(input.txid) !== deposit.txid) continue;
4505
5383
  for (const leaf of input.tapLeafScript ?? []) {
4506
- const spent = import_base11.hex.encode((0, import_sdk19.scriptFromTapLeafScript)(leaf));
4507
- if (leaves.returned.some((back) => spent === import_base11.hex.encode(back))) return "cancelled";
4508
- if (leaves.fulfill && spent === import_base11.hex.encode(leaves.fulfill)) return "fulfilled";
5384
+ const spent = import_base12.hex.encode((0, import_sdk21.scriptFromTapLeafScript)(leaf));
5385
+ if (leaves.returned.some((back) => spent === import_base12.hex.encode(back))) return "cancelled";
5386
+ if (leaves.fulfill && spent === import_base12.hex.encode(leaves.fulfill)) return "fulfilled";
4509
5387
  }
4510
5388
  }
4511
5389
  return "indeterminate";
@@ -4531,7 +5409,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
4531
5409
  try {
4532
5410
  reopened.push({
4533
5411
  fundingTx: { type: "sent", redeemTxid: swap.fundingTxid },
4534
- offer: decodeOffer(import_base11.hex.decode(swap.offerHex)),
5412
+ offer: decodeOffer(import_base12.hex.decode(swap.offerHex)),
4535
5413
  offerHex: swap.offerHex,
4536
5414
  existing: swap
4537
5415
  });
@@ -4557,19 +5435,19 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
4557
5435
  if (!fundingTx) continue;
4558
5436
  fetchedTxids.push(txid);
4559
5437
  try {
4560
- const packet = import_sdk19.Extension.fromTx(parsed).getPacketByType(OFFER_PACKET_TYPE);
5438
+ const packet = import_sdk21.Extension.fromTx(parsed).getPacketByType(OFFER_PACKET_TYPE);
4561
5439
  if (!packet) continue;
4562
5440
  const payload = packet.serialize();
4563
5441
  found.push({
4564
5442
  fundingTx,
4565
5443
  offer: decodeOffer(payload),
4566
- offerHex: import_base11.hex.encode(payload)
5444
+ offerHex: import_base12.hex.encode(payload)
4567
5445
  });
4568
5446
  } catch {
4569
5447
  }
4570
5448
  }
4571
5449
  if (found.length === 0) return { restored: [], scannedTxids: fetchedTxids };
4572
- const scripts = [...new Set(found.map((f) => import_base11.hex.encode(f.offer.swapPkScript)))];
5450
+ const scripts = [...new Set(found.map((f) => import_base12.hex.encode(f.offer.swapPkScript)))];
4573
5451
  const { vtxos } = await indexer.getVtxos({ scripts });
4574
5452
  const vtxoByScriptAndTxid = new Map(vtxos.map((v) => [`${v.script}:${v.txid}`, v]));
4575
5453
  const txByAnyId = /* @__PURE__ */ new Map();
@@ -4581,7 +5459,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
4581
5459
  const spendTxids = /* @__PURE__ */ new Set();
4582
5460
  for (const { fundingTx, offer } of found) {
4583
5461
  const vtxo = vtxoByScriptAndTxid.get(
4584
- `${import_base11.hex.encode(offer.swapPkScript)}:${fundingTx.redeemTxid}`
5462
+ `${import_base12.hex.encode(offer.swapPkScript)}:${fundingTx.redeemTxid}`
4585
5463
  );
4586
5464
  if (!vtxo?.isSpent) continue;
4587
5465
  for (const txid of spendTxidsOf(vtxo)) spendTxids.add(txid);
@@ -4590,7 +5468,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
4590
5468
  const restored = [];
4591
5469
  const unresolved = /* @__PURE__ */ new Set();
4592
5470
  for (const { fundingTx, offer, offerHex, existing } of found) {
4593
- const swapPkScript = import_base11.hex.encode(offer.swapPkScript);
5471
+ const swapPkScript = import_base12.hex.encode(offer.swapPkScript);
4594
5472
  const vtxo = vtxoByScriptAndTxid.get(`${swapPkScript}:${fundingTx.redeemTxid}`);
4595
5473
  if (!vtxo) {
4596
5474
  unresolved.add(fundingTx.redeemTxid);
@@ -4637,7 +5515,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
4637
5515
  let swapAddress = "";
4638
5516
  try {
4639
5517
  const compiled = offerContract(offer, operatorPubkey);
4640
- if (import_base11.hex.encode(compiled.pkScript) !== swapPkScript) {
5518
+ if (import_base12.hex.encode(compiled.pkScript) !== swapPkScript) {
4641
5519
  unresolved.add(fundingTx.redeemTxid);
4642
5520
  continue;
4643
5521
  }
@@ -4674,8 +5552,8 @@ init_repository();
4674
5552
  init_repository();
4675
5553
 
4676
5554
  // src/rfqRecord.ts
4677
- var import_sdk20 = require("@arkade-os/sdk");
4678
- var import_base12 = require("@scure/base");
5555
+ var import_sdk22 = require("@arkade-os/sdk");
5556
+ var import_base13 = require("@scure/base");
4679
5557
 
4680
5558
  // src/rfqSwapState.ts
4681
5559
  var RFQ_SWAP_TERMINAL_STATES = ["settled", "refunded", "failed"];
@@ -4688,6 +5566,7 @@ var RFQ_SWAP_ACTIVE_STATES = [
4688
5566
  var isRfqSwapTerminal = (state) => RFQ_SWAP_TERMINAL_STATES.includes(state);
4689
5567
 
4690
5568
  // src/rfqRecord.ts
5569
+ init_rfqCorridor();
4691
5570
  var RFQ_SWAP_RETENTION_SECONDS = 30 * 24 * 60 * 60;
4692
5571
  function renameLegacyClaimTxid(profile) {
4693
5572
  const { claimArkTxid, ...rest } = profile;
@@ -4729,8 +5608,8 @@ function assertSameSwap(origin, swap) {
4729
5608
  `rfq swap record is a ${origin.kind} origin paired with a ${swap.kind} swap`
4730
5609
  );
4731
5610
  }
4732
- const funded = import_base12.hex.encode(import_sdk20.ArkAddress.decode(origin.lockupAddress).pkScript);
4733
- const watched = import_base12.hex.encode(swap.lockupPkScript);
5611
+ const funded = import_base13.hex.encode(import_sdk22.ArkAddress.decode(origin.lockupAddress).pkScript);
5612
+ const watched = import_base13.hex.encode(swap.lockupPkScript);
4734
5613
  if (funded !== watched) {
4735
5614
  throw new Error(
4736
5615
  `rfq swap record's lockup address holds ${funded}, but the swap watches ${watched} \u2014 these are not the same swap`
@@ -4776,11 +5655,11 @@ function rfqSwapOriginOf(record) {
4776
5655
  };
4777
5656
  }
4778
5657
  function lockupScript(params, lockupAddress) {
4779
- const script = import_sdk20.VHTLCV2ContractHandler.createScript(params);
4780
- const funded = import_sdk20.ArkAddress.decode(lockupAddress).pkScript;
4781
- if (import_base12.hex.encode(funded) !== import_base12.hex.encode(script.pkScript)) {
5658
+ const script = import_sdk22.VHTLCV2ContractHandler.createScript(params);
5659
+ const funded = import_sdk22.ArkAddress.decode(lockupAddress).pkScript;
5660
+ if (import_base13.hex.encode(funded) !== import_base13.hex.encode(script.pkScript)) {
4782
5661
  throw new Error(
4783
- `rfq swap covenant params derive ${import_base12.hex.encode(script.pkScript)}, but the record's lockup address holds ${import_base12.hex.encode(funded)} \u2014 these params are not this swap's`
5662
+ `rfq swap covenant params derive ${import_base13.hex.encode(script.pkScript)}, but the record's lockup address holds ${import_base13.hex.encode(funded)} \u2014 these params are not this swap's`
4784
5663
  );
4785
5664
  }
4786
5665
  return script;
@@ -4814,9 +5693,9 @@ function shouldRetainRfqSwap(record, now) {
4814
5693
 
4815
5694
  // src/client/driveRecords.ts
4816
5695
  init_store();
4817
- var import_sdk21 = require("@arkade-os/sdk");
5696
+ var import_sdk23 = require("@arkade-os/sdk");
4818
5697
  var import_sha25 = require("@noble/hashes/sha2.js");
4819
- var import_base13 = require("@scure/base");
5698
+ var import_base14 = require("@scure/base");
4820
5699
  var splitRecords = (records) => {
4821
5700
  const corridor = [];
4822
5701
  const offer = [];
@@ -4869,7 +5748,7 @@ var pageRfqRecords = (records, filter, page) => {
4869
5748
  ).sort(
4870
5749
  (a, b) => a.updatedAt - b.updatedAt || (a.rfqId < b.rfqId ? -1 : a.rfqId > b.rfqId ? 1 : 0)
4871
5750
  ).slice(0, page.limit + 1);
4872
- return (0, import_sdk21.pageResult)(rows, page.limit, (record) => ({
5751
+ return (0, import_sdk23.pageResult)(rows, page.limit, (record) => ({
4873
5752
  updatedAt: record.updatedAt,
4874
5753
  rfqId: record.rfqId
4875
5754
  }));
@@ -4895,7 +5774,7 @@ var corridorRecordStore = (repository, onRecord = () => {
4895
5774
  index,
4896
5775
  quoteIdOf: (rfqId) => byRfqId.get(rfqId),
4897
5776
  async getRfqSwapsPage(filter, page) {
4898
- (0, import_sdk21.assertPageRequest)(page);
5777
+ (0, import_sdk23.assertPageRequest)(page);
4899
5778
  assertRfqSwapPageFilter(filter);
4900
5779
  const { corridor } = splitRecords(await collectSwapRecords(repository));
4901
5780
  for (const record of corridor) index(record);
@@ -4922,13 +5801,12 @@ var corridorRecordStore = (repository, onRecord = () => {
4922
5801
  };
4923
5802
  var offerFactsOf = (record) => ({
4924
5803
  id: record.id,
5804
+ coverageId: record.id,
4925
5805
  status: record.status,
4926
5806
  offerHex: record.offerHex,
4927
5807
  swapPkScript: record.swapPkScript,
4928
5808
  ...record.fundingTxid === void 0 ? {} : { fundingTxid: record.fundingTxid },
4929
5809
  ...record.spentTxid === void 0 ? {} : { spentTxid: record.spentTxid },
4930
- // milliseconds: `coverage.ts` compares against `Date.now()`, and seconds would leave every
4931
- // issued script outstanding for the life of the process
4932
5810
  createdAt: record.createdAt * 1e3
4933
5811
  });
4934
5812
  var offerRecordSource = (repository, onRecord = () => {
@@ -5004,7 +5882,7 @@ var restoredOfferRecord = (swap, network, now) => {
5004
5882
  now
5005
5883
  );
5006
5884
  };
5007
- var restoredAssetId = (network, id) => id === BTC_ASSET_ID ? btcOn("arkade", network) : arkadeAsset(network, import_sdk21.asset.AssetId.fromString(id));
5885
+ var restoredAssetId = (network, id) => id === BTC_ASSET_ID ? btcOn("arkade", network) : arkadeAsset(network, import_sdk23.asset.AssetId.fromString(id));
5008
5886
  var RESTORED_CORRIDORS = {
5009
5887
  lightning_send: ["arkade", "lightning"],
5010
5888
  lightning_receive: ["lightning", "arkade"],
@@ -5014,7 +5892,7 @@ var RESTORED_CORRIDORS = {
5014
5892
  var restoredCorridorRecord = (stored, network, refundLocktime) => {
5015
5893
  const v1 = normalizeRfqSwapRecord(stored);
5016
5894
  const hashlock = v1.profile.hashlock;
5017
- const hash = typeof hashlock?.paymentHash === "string" ? hashlock.paymentHash : v1.settlementPreimageHex === void 0 ? void 0 : import_base13.hex.encode((0, import_sha25.sha256)(import_base13.hex.decode(v1.settlementPreimageHex)));
5895
+ const hash = typeof hashlock?.paymentHash === "string" ? hashlock.paymentHash : v1.settlementPreimageHex === void 0 ? void 0 : import_base14.hex.encode((0, import_sha25.sha256)(import_base14.hex.decode(v1.settlementPreimageHex)));
5018
5896
  if (hash === void 0) throw new Error(`v1 rfq swap ${v1.rfqId} has no payment hash`);
5019
5897
  const [giveCorridor, takeCorridor] = RESTORED_CORRIDORS[v1.kind];
5020
5898
  const give = btcOn(railOfCorridor(giveCorridor), network);
@@ -5036,7 +5914,7 @@ var restoredCorridorRecord = (stored, network, refundLocktime) => {
5036
5914
  kind: v1.kind,
5037
5915
  rfqId: v1.rfqId,
5038
5916
  lockupAddress: v1.lockupAddress,
5039
- lockupPkScript: import_base13.hex.encode(import_sdk21.ArkAddress.decode(v1.lockupAddress).pkScript),
5917
+ lockupPkScript: import_base14.hex.encode(import_sdk23.ArkAddress.decode(v1.lockupAddress).pkScript),
5040
5918
  lock: { hash },
5041
5919
  refundLocktime,
5042
5920
  profile: v1.profile,
@@ -5120,7 +5998,7 @@ var cancelSwap = async (input) => {
5120
5998
  return { outcome: "cancelled" };
5121
5999
  };
5122
6000
  var reconcileDepositSpend = async (record, indexer) => {
5123
- const offer = decodeOffer(import_base14.hex.decode(record.offerHex));
6001
+ const offer = decodeOffer(import_base15.hex.decode(record.offerHex));
5124
6002
  const { vtxos } = await indexer.getVtxos({ scripts: [record.swapPkScript] });
5125
6003
  const all = vtxos ?? [];
5126
6004
  const deposit = record.fundingTxid === void 0 ? all.length === 1 ? all[0] : void 0 : all.find((vtxo) => vtxo.txid === record.fundingTxid);
@@ -5132,12 +6010,12 @@ var reconcileDepositSpend = async (record, indexer) => {
5132
6010
  const { txs } = await indexer.getVirtualTxs(candidates);
5133
6011
  const parsed = txs.map((psbt) => {
5134
6012
  try {
5135
- return import_sdk22.Transaction.fromPSBT(import_base14.base64.decode(psbt));
6013
+ return import_sdk24.Transaction.fromPSBT(import_base15.base64.decode(psbt));
5136
6014
  } catch {
5137
6015
  return void 0;
5138
6016
  }
5139
6017
  }).filter((tx) => tx !== void 0);
5140
- const operatorPubkey = import_sdk22.ArkAddress.decode(record.swapAddress).serverPubKey;
6018
+ const operatorPubkey = import_sdk24.ArkAddress.decode(record.swapAddress).serverPubKey;
5141
6019
  const kind = classifyDepositSpend(offer, operatorPubkey, parsed, {
5142
6020
  txid: deposit.txid,
5143
6021
  vout: deposit.vout
@@ -5167,7 +6045,8 @@ var retireOfferScripts = async (wallet, repository, record) => {
5167
6045
  await retireOfferContract(
5168
6046
  await wallet.getContractManager(),
5169
6047
  offer.map(offerFactsOf),
5170
- record.swapPkScript
6048
+ record.swapPkScript,
6049
+ { scope: wallet }
5171
6050
  );
5172
6051
  } catch (error) {
5173
6052
  console.warn(`[swap] could not retire offer script for ${record.id}`, error);
@@ -5175,11 +6054,11 @@ var retireOfferScripts = async (wallet, repository, record) => {
5175
6054
  };
5176
6055
 
5177
6056
  // src/client/drive.ts
5178
- var import_sdk28 = require("@arkade-os/sdk");
5179
- var import_base17 = require("@scure/base");
6057
+ var import_sdk30 = require("@arkade-os/sdk");
6058
+ var import_base18 = require("@scure/base");
5180
6059
 
5181
6060
  // src/claim.ts
5182
- var import_sdk23 = require("@arkade-os/sdk");
6061
+ var import_sdk25 = require("@arkade-os/sdk");
5183
6062
  init_onchainHtlc();
5184
6063
  var LockupAmountMismatchError = class extends Error {
5185
6064
  name = "LockupAmountMismatchError";
@@ -5200,28 +6079,31 @@ var assertFiniteAmount = (value, reason, label) => {
5200
6079
  };
5201
6080
  async function pushClaim(operator, input) {
5202
6081
  if (input.vtxos.length === 0) throw new Error("nothing to claim: no funded outputs");
5203
- assertNoneSwept(input.vtxos, input.contract);
5204
- const locked = input.vtxos.reduce((sum, vtxo) => sum + vtxo.value, 0);
5205
- assertFiniteAmount(locked, "lockup_malformed", "the lockup's summed value");
6082
+ const live = input.vtxos.filter((vtxo) => !vtxo.recoverable);
6083
+ if (live.length === 0) assertNoneSwept(input.vtxos, input.contract);
6084
+ const funded = live.reduce((sum, vtxo) => sum + vtxo.value, 0);
6085
+ assertFiniteAmount(funded, "lockup_malformed", "the lockup's summed value");
5206
6086
  if (!input.partiallyClaimed) {
5207
6087
  assertFiniteAmount(input.expectedAmount, "invalid_gate_input", "expectedAmount");
5208
- if (locked < input.expectedAmount) {
5209
- throw new LockupAmountMismatchError(input.expectedAmount, locked);
6088
+ if (funded < input.expectedAmount) {
6089
+ throw new LockupAmountMismatchError(input.expectedAmount, funded);
5210
6090
  }
5211
6091
  }
6092
+ const vtxos = boundedLockupSpend(live);
6093
+ const locked = vtxos.reduce((sum, vtxo) => sum + vtxo.value, 0);
5212
6094
  assertPreimageMatches(input.preimage, input.contract.options.preimageHash);
5213
6095
  const serverUnrollScript = await operatorUnrollScript(operator, input.network);
5214
6096
  const leaf = input.contract.claim();
5215
- const txid = await (0, import_sdk23.signAndSubmitOffchainTx)({
5216
- identity: (0, import_sdk23.claimWithPreimageIdentity)(input.receiver, input.preimage),
6097
+ const txid = await (0, import_sdk25.signAndSubmitOffchainTx)({
6098
+ identity: (0, import_sdk25.claimWithPreimageIdentity)(input.receiver, input.preimage),
5217
6099
  provider: operator,
5218
- inputs: lockupInputs(input.vtxos, input.contract, leaf),
6100
+ inputs: lockupInputs(vtxos, input.contract, leaf),
5219
6101
  // One aggregate output: this leaf inspects nothing about the output set.
5220
6102
  outputs: [{ script: input.destinationPkScript, amount: BigInt(locked) }],
5221
6103
  serverUnrollScript,
5222
6104
  verifyServerSignatures: { serverPubkey: input.contract.options.server }
5223
6105
  });
5224
- return { txid, amount: locked };
6106
+ return { txid, amount: locked, left: live.length - vtxos.length, spent: vtxos };
5225
6107
  }
5226
6108
 
5227
6109
  // src/client/drive.ts
@@ -5231,7 +6113,7 @@ init_offer();
5231
6113
  init_lockupContract();
5232
6114
 
5233
6115
  // src/refundBlocked.ts
5234
- var import_sdk24 = require("@arkade-os/sdk");
6116
+ var import_sdk26 = require("@arkade-os/sdk");
5235
6117
  var RefundNotLocallyPossibleError = class extends Error {
5236
6118
  constructor(reason, message, options) {
5237
6119
  super(message, options);
@@ -5248,16 +6130,16 @@ async function senderIdentityForSwapRecord(wallet, record) {
5248
6130
  );
5249
6131
  }
5250
6132
  try {
5251
- return await (0, import_sdk24.contractSigner)(wallet, record.signingDescriptor);
6133
+ return await (0, import_sdk26.contractSigner)(wallet, record.signingDescriptor);
5252
6134
  } catch (cause) {
5253
- if (cause instanceof import_sdk24.WalletCannotSignError) {
6135
+ if (cause instanceof import_sdk26.WalletCannotSignError) {
5254
6136
  throw new RefundNotLocallyPossibleError(
5255
6137
  "unsignable-wallet",
5256
6138
  `this wallet holds ${record.signingDescriptor} but cannot sign with it; attach its signer`,
5257
6139
  { cause }
5258
6140
  );
5259
6141
  }
5260
- if (cause instanceof import_sdk24.ForeignDescriptorError) {
6142
+ if (cause instanceof import_sdk26.ForeignDescriptorError) {
5261
6143
  throw new RefundNotLocallyPossibleError(
5262
6144
  "foreign-descriptor",
5263
6145
  `this wallet cannot derive ${record.signingDescriptor}; the swap was created on another wallet`,
@@ -5269,7 +6151,10 @@ async function senderIdentityForSwapRecord(wallet, record) {
5269
6151
  }
5270
6152
 
5271
6153
  // src/arkadeRefunder.ts
6154
+ init_rfqProfileParts();
5272
6155
  function arkadeRefunder(deps) {
6156
+ const spentBy = /* @__PURE__ */ new Map();
6157
+ const keyOf = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
5273
6158
  return async (swap) => {
5274
6159
  const contract = swap.lockup?.script;
5275
6160
  if (!contract) {
@@ -5277,7 +6162,10 @@ function arkadeRefunder(deps) {
5277
6162
  `swap ${swap.rfqId} carries no lockup covenant, so its refund cannot be built`
5278
6163
  );
5279
6164
  }
5280
- const vtxos = await findLockupVtxos(deps.contracts, swap.lockupPkScript);
6165
+ const done = spentBy.get(swap.rfqId);
6166
+ const vtxos = (await findLockupVtxos(deps.contracts, swap.lockupPkScript)).filter(
6167
+ (vtxo) => !done?.has(keyOf(vtxo))
6168
+ );
5281
6169
  if (vtxos.length === 0) return null;
5282
6170
  const record = await deps.repository.getRfqSwap(swap.rfqId);
5283
6171
  if (!record) {
@@ -5287,22 +6175,27 @@ function arkadeRefunder(deps) {
5287
6175
  );
5288
6176
  }
5289
6177
  const sender = await senderIdentityForSwapRecord(deps.wallet, rfqSignerOf(record) ?? {});
5290
- return pushRefundWithoutReceiver(deps.operator, {
6178
+ const result = await pushRefundWithoutReceiver(deps.operator, {
5291
6179
  contract,
5292
6180
  sender,
5293
6181
  vtxos,
5294
6182
  network: await deps.network?.()
5295
6183
  });
6184
+ if (result.left > 0 || done) {
6185
+ spentBy.set(swap.rfqId, /* @__PURE__ */ new Set([...done ?? [], ...result.spent.map(keyOf)]));
6186
+ }
6187
+ return result;
5296
6188
  };
5297
6189
  }
5298
6190
 
5299
6191
  // src/client/drive.ts
6192
+ init_rfqProfileParts();
5300
6193
  init_store();
5301
6194
  init_repository();
5302
6195
 
5303
6196
  // src/swapManager.ts
5304
- var import_base15 = require("@scure/base");
5305
- var import_sdk25 = require("@arkade-os/sdk");
6197
+ var import_base16 = require("@scure/base");
6198
+ var import_sdk27 = require("@arkade-os/sdk");
5306
6199
  init_onchainHtlc();
5307
6200
  init_lockupContract();
5308
6201
  init_repository();
@@ -5433,7 +6326,7 @@ var RfqSwapManager = class _RfqSwapManager {
5433
6326
  timer = null;
5434
6327
  running = false;
5435
6328
  constructor(deps, config = {}) {
5436
- (0, import_sdk25.assertTimerMs)("pollIntervalMs", config.pollIntervalMs);
6329
+ (0, import_sdk27.assertTimerMs)("pollIntervalMs", config.pollIntervalMs);
5437
6330
  this.deps = deps;
5438
6331
  this.config = {
5439
6332
  enableAutoActions: config.enableAutoActions ?? true,
@@ -5738,7 +6631,7 @@ var RfqSwapManager = class _RfqSwapManager {
5738
6631
  }
5739
6632
  if (!swap) throw new Error(`swap ${rfqId} is not monitored`);
5740
6633
  if (swap.state === "failed") throw new Error(swap.failure ?? `swap ${rfqId} failed`);
5741
- if (isPayoutDecided(swap)) return outcomeOf(swap);
6634
+ if (isPayoutDecided(swap, this.reportsConfirmations)) return outcomeOf(swap);
5742
6635
  return new Promise((resolve, reject) => {
5743
6636
  const set = this.waiters.get(rfqId) ?? /* @__PURE__ */ new Set();
5744
6637
  set.add({ resolve, reject });
@@ -5748,13 +6641,13 @@ var RfqSwapManager = class _RfqSwapManager {
5748
6641
  // ── internals ────────────────────────────────────────────────────────────
5749
6642
  track(swap) {
5750
6643
  this.monitored.set(swap.rfqId, swap);
5751
- this.byLockupScript.set(import_base15.hex.encode(swap.lockupPkScript), swap);
6644
+ this.byLockupScript.set(import_base16.hex.encode(swap.lockupPkScript), swap);
5752
6645
  }
5753
6646
  /** Drops the swap from BOTH indexes. `pollSwap`'s `monitored` check also stops a late
5754
6647
  * event, deliberately redundant so neither change alone re-drives a removed swap. */
5755
6648
  untrack(rfqId) {
5756
6649
  const swap = this.monitored.get(rfqId);
5757
- if (swap) this.byLockupScript.delete(import_base15.hex.encode(swap.lockupPkScript));
6650
+ if (swap) this.byLockupScript.delete(import_base16.hex.encode(swap.lockupPkScript));
5758
6651
  this.monitored.delete(rfqId);
5759
6652
  this.refundRefused.delete(rfqId);
5760
6653
  this.claimedOutpoints.delete(rfqId);
@@ -5777,7 +6670,7 @@ var RfqSwapManager = class _RfqSwapManager {
5777
6670
  });
5778
6671
  return;
5779
6672
  }
5780
- if (!(0, import_sdk25.isContractVtxoEvent)(event)) return;
6673
+ if (!(0, import_sdk27.isContractVtxoEvent)(event)) return;
5781
6674
  const swap = this.byLockupScript.get(event.contractScript);
5782
6675
  if (!swap) return;
5783
6676
  void this.pollSwap(swap).catch(() => {
@@ -5800,7 +6693,7 @@ var RfqSwapManager = class _RfqSwapManager {
5800
6693
  if (!lockup) {
5801
6694
  try {
5802
6695
  const [existing] = await contracts.getContracts({
5803
- script: import_base15.hex.encode(swap.lockupPkScript)
6696
+ script: import_base16.hex.encode(swap.lockupPkScript)
5804
6697
  });
5805
6698
  if (existing) {
5806
6699
  this.registered.set(swap.rfqId, true);
@@ -5819,13 +6712,13 @@ var RfqSwapManager = class _RfqSwapManager {
5819
6712
  );
5820
6713
  return;
5821
6714
  }
5822
- const script = import_base15.hex.encode(lockup.script.pkScript);
5823
- if (script !== import_base15.hex.encode(swap.lockupPkScript)) {
6715
+ const script = import_base16.hex.encode(lockup.script.pkScript);
6716
+ if (script !== import_base16.hex.encode(swap.lockupPkScript)) {
5824
6717
  this.registered.set(swap.rfqId, false);
5825
6718
  this.emitFailed(
5826
6719
  swap,
5827
6720
  new Error(
5828
- `swap ${swap.rfqId} lockup script ${script} does not match its lockupPkScript ${import_base15.hex.encode(swap.lockupPkScript)}`
6721
+ `swap ${swap.rfqId} lockup script ${script} does not match its lockupPkScript ${import_base16.hex.encode(swap.lockupPkScript)}`
5829
6722
  )
5830
6723
  );
5831
6724
  return;
@@ -5842,7 +6735,7 @@ var RfqSwapManager = class _RfqSwapManager {
5842
6735
  retireContract(swap) {
5843
6736
  if (!this.deps.contracts || !this.registered.get(swap.rfqId)) return;
5844
6737
  if (!LOCKUP_RETIRABLE.includes(swap.state)) return;
5845
- void this.deps.contracts.setContractWatchState(import_base15.hex.encode(swap.lockupPkScript), "retained").catch((error) => this.emitFailed(swap, error));
6738
+ void this.deps.contracts.setContractWatchState(import_base16.hex.encode(swap.lockupPkScript), "retained").catch((error) => this.emitFailed(swap, error));
5846
6739
  }
5847
6740
  arm() {
5848
6741
  if (!this.running) return;
@@ -5890,7 +6783,8 @@ var RfqSwapManager = class _RfqSwapManager {
5890
6783
  try {
5891
6784
  fate = await readLockupFate(this.deps.indexer, {
5892
6785
  swapPkScript: swap.lockupPkScript,
5893
- paymentHash: swap.paymentHash
6786
+ paymentHash: swap.paymentHash,
6787
+ receiver: swap.kind === "lightning_receive" || swap.kind === "onchain_receive"
5894
6788
  });
5895
6789
  } catch {
5896
6790
  fate = { fate: "unknown" };
@@ -5899,6 +6793,9 @@ var RfqSwapManager = class _RfqSwapManager {
5899
6793
  if (fate.fate === "claimed" || fate.fate === "returned") {
5900
6794
  this.stampLockupSpends(swap, fate.spends);
5901
6795
  if (fate.fate === "claimed") this.stampSettlementPreimage(swap, fate.preimage);
6796
+ if (swap.kind === "onchain_send" && fate.fate === "claimed" && this.deps.chain) {
6797
+ return this.driveOnchainPayout(swap);
6798
+ }
5902
6799
  this.setState(swap, fate.fate === "claimed" ? "settled" : "refunded");
5903
6800
  return;
5904
6801
  }
@@ -5908,7 +6805,7 @@ var RfqSwapManager = class _RfqSwapManager {
5908
6805
  if (this.config.now() >= swap.refundLocktime) return this.driveReceiveClaim(swap);
5909
6806
  return;
5910
6807
  }
5911
- if (swap.kind === "onchain_send" && swap.state !== "claimed") {
6808
+ if (swap.kind === "onchain_send") {
5912
6809
  if (await this.driveOnchain(swap) === "handled") return;
5913
6810
  }
5914
6811
  if (fate.fate === "exited") {
@@ -5970,7 +6867,8 @@ var RfqSwapManager = class _RfqSwapManager {
5970
6867
  async claimIfFunded(swap, vtxos) {
5971
6868
  if (vtxos.length === 0) return this.unblock(swap);
5972
6869
  const partiallyClaimed = swap.claimTxid !== void 0;
5973
- if (partiallyClaimed && !this.hasUnclaimedOutpoint(swap.rfqId, vtxos)) {
6870
+ const toClaim = partiallyClaimed ? this.unclaimed(swap.rfqId, vtxos) : vtxos;
6871
+ if (toClaim.length === 0) {
5974
6872
  return;
5975
6873
  }
5976
6874
  if (!partiallyClaimed) {
@@ -5997,16 +6895,18 @@ var RfqSwapManager = class _RfqSwapManager {
5997
6895
  this.setState(swap, "claimable");
5998
6896
  if (!this.config.enableAutoActions) return;
5999
6897
  try {
6000
- const { txid } = await this.callbacks.claimLockup(swap, vtxos, { partiallyClaimed });
6898
+ const { txid, spent } = await this.callbacks.claimLockup(swap, toClaim, {
6899
+ partiallyClaimed
6900
+ });
6001
6901
  delete swap.claimFailure;
6002
- this.rememberClaimed(swap.rfqId, vtxos);
6902
+ this.rememberClaimed(swap.rfqId, spent ?? toClaim);
6003
6903
  swap.claimTxid = txid;
6004
6904
  this.touch(swap);
6005
6905
  this.setState(swap, "claimed");
6006
6906
  this.emitAction(swap, "claimLockup");
6007
6907
  } catch (error) {
6008
- const ark = (0, import_sdk25.isArkError)(error) ? error : (0, import_sdk25.maybeArkError)(error);
6009
- if ((0, import_sdk25.isArkError)(ark, import_sdk25.ArkErrorName.VTXO_ALREADY_SPENT)) {
6908
+ const ark = (0, import_sdk27.isArkError)(error) ? error : (0, import_sdk27.maybeArkError)(error);
6909
+ if ((0, import_sdk27.isArkError)(ark, import_sdk27.ArkErrorName.VTXO_ALREADY_SPENT)) {
6010
6910
  if (swap.claimFailure !== void 0) {
6011
6911
  delete swap.claimFailure;
6012
6912
  this.touch(swap);
@@ -6106,7 +7006,51 @@ var RfqSwapManager = class _RfqSwapManager {
6106
7006
  }
6107
7007
  return { verdict: "live", attempted: true };
6108
7008
  }
6109
- /** `handled` ends the pass; `continue` falls through to the refund gate. */
7009
+ /** The solver has `P` and the lockup; the trader's payout is the L1 claim alone. */
7010
+ async driveOnchainPayout(swap) {
7011
+ const l1 = await this.driveOnchain(swap);
7012
+ if (isRfqSwapTerminal(swap.state)) return;
7013
+ if (l1 === "swept") {
7014
+ return this.fail(
7015
+ swap,
7016
+ new Error(
7017
+ `the solver claimed the Arkade lockup and its L1 refund took the fill \u2014 the claim ${swap.claimTxid ?? ""} was replaced before it confirmed`
7018
+ )
7019
+ );
7020
+ }
7021
+ const confirmed = await this.readClaimConfirmed(swap);
7022
+ if (this.reportsConfirmations ? confirmed !== true : confirmed === false) return;
7023
+ this.setState(swap, "settled");
7024
+ }
7025
+ get reportsConfirmations() {
7026
+ return this.deps.chain?.getTxStatus !== void 0;
7027
+ }
7028
+ async claimVanished(txid) {
7029
+ const chain = this.deps.chain;
7030
+ if (!chain?.getTxStatus) return false;
7031
+ try {
7032
+ return await chain.getTxStatus(txid) === "missing";
7033
+ } catch {
7034
+ return true;
7035
+ }
7036
+ }
7037
+ /** Stamped on the swap for {@link isPayoutDecided}; `undefined` when it cannot be read. */
7038
+ async readClaimConfirmed(swap) {
7039
+ const chain = this.deps.chain;
7040
+ if (!chain?.getTxStatus || !swap.claimTxid) return void 0;
7041
+ let confirmed;
7042
+ try {
7043
+ confirmed = await chain.getTxStatus(swap.claimTxid) === "confirmed";
7044
+ } catch {
7045
+ confirmed = false;
7046
+ }
7047
+ if (confirmed !== swap.claimConfirmed) {
7048
+ swap.claimConfirmed = confirmed;
7049
+ this.touch(swap);
7050
+ }
7051
+ return confirmed;
7052
+ }
7053
+ /** `handled` ends the pass; `continue` and `swept` fall through to the refund gate. */
6110
7054
  async driveOnchain(swap) {
6111
7055
  if (!this.deps.chain) {
6112
7056
  this.fail(
@@ -6127,17 +7071,27 @@ var RfqSwapManager = class _RfqSwapManager {
6127
7071
  } catch {
6128
7072
  return "continue";
6129
7073
  }
6130
- if ("utxo" in phase && !swap.funding) {
6131
- swap.funding = { txid: phase.utxo.txid, vout: phase.utxo.vout };
7074
+ if ("utxo" in phase && swap.funding?.amount === void 0) {
7075
+ swap.funding = {
7076
+ txid: phase.utxo.txid,
7077
+ vout: phase.utxo.vout,
7078
+ amount: Number(phase.utxo.amount)
7079
+ };
6132
7080
  this.touch(swap);
6133
7081
  }
7082
+ if (swap.claimTxid && (phase.phase === "claimable" || phase.phase === "refundable")) {
7083
+ const due = this.reportsConfirmations && this.config.now() - (swap.claimBroadcastAt ?? 0) >= ONCHAIN_CLAIM_BUMP_SECONDS;
7084
+ if (due || await this.claimVanished(swap.claimTxid)) {
7085
+ await this.pushOnchainClaim(swap, phase.utxo, due);
7086
+ }
7087
+ return "continue";
7088
+ }
6134
7089
  const action = nextOnchainAction({
6135
7090
  phase,
6136
7091
  htlcLocktime: swap.htlc.refundLocktime,
6137
7092
  now: this.config.now()
6138
7093
  });
6139
7094
  if (action === "claim" && phase.phase === "claimable") {
6140
- if (swap.claimTxid) return "continue";
6141
7095
  if (!Number.isSafeInteger(swap.expectedAmount) || swap.expectedAmount <= 0) {
6142
7096
  this.block(
6143
7097
  swap,
@@ -6158,26 +7112,55 @@ var RfqSwapManager = class _RfqSwapManager {
6158
7112
  return "handled";
6159
7113
  }
6160
7114
  this.setOnchainState(swap, "claimable");
6161
- if (!this.config.enableAutoActions || !this.callbacks?.claimOnchain) return "handled";
6162
- try {
6163
- const { txid } = await this.callbacks.claimOnchain(swap, phase.utxo);
6164
- swap.claimTxid = txid;
6165
- this.setOnchainState(swap, "claimed");
6166
- this.emitAction(swap, "claimOnchain");
6167
- } catch (error) {
6168
- this.emitFailed(swap, error);
6169
- }
6170
- return "handled";
7115
+ return this.pushOnchainClaim(swap, phase.utxo, false);
6171
7116
  }
6172
7117
  if (action === "claimed" && phase.phase === "claimed") {
6173
- if (!swap.claimTxid) {
7118
+ if (swap.claimTxid !== phase.txid) {
6174
7119
  swap.claimTxid = phase.txid;
6175
7120
  this.touch(swap);
6176
7121
  }
6177
7122
  this.setOnchainState(swap, "claimed");
7123
+ await this.bumpOnchainClaim(swap);
7124
+ return "continue";
6178
7125
  }
7126
+ if (phase.phase === "swept") return "swept";
6179
7127
  return "continue";
6180
7128
  }
7129
+ /** Build and broadcast a claim. The bump clock restarts on every broadcast, same-txid
7130
+ * re-publications included, or a claim at the dust ceiling would go out every pass. */
7131
+ async pushOnchainClaim(swap, utxo, bump) {
7132
+ if (!this.config.enableAutoActions || !this.callbacks?.claimOnchain) return "handled";
7133
+ try {
7134
+ const { txid, feeRateSatVb } = await this.callbacks.claimOnchain(
7135
+ swap,
7136
+ utxo,
7137
+ bump ? { bump } : void 0
7138
+ );
7139
+ swap.claimTxid = txid;
7140
+ swap.claimBroadcastAt = this.config.now();
7141
+ delete swap.claimConfirmed;
7142
+ if (feeRateSatVb !== void 0) swap.claimFeeRateSatVb = feeRateSatVb;
7143
+ this.touch(swap);
7144
+ this.setOnchainState(swap, "claimed");
7145
+ this.emitAction(swap, "claimOnchain");
7146
+ } catch (error) {
7147
+ this.emitFailed(swap, error);
7148
+ }
7149
+ return "handled";
7150
+ }
7151
+ /** Replace a claim that is not confirming, before median-time-past opens the solver's
7152
+ * refund leaf. Needs `getTxStatus`: blind, it would replace claims that already landed. */
7153
+ async bumpOnchainClaim(swap) {
7154
+ if (await this.readClaimConfirmed(swap) !== false) return;
7155
+ const funding = swap.funding;
7156
+ if (funding?.amount === void 0) return;
7157
+ if (this.config.now() - (swap.claimBroadcastAt ?? 0) < ONCHAIN_CLAIM_BUMP_SECONDS) return;
7158
+ await this.pushOnchainClaim(
7159
+ swap,
7160
+ { ...funding, amount: BigInt(funding.amount), confirmations: 0 },
7161
+ true
7162
+ );
7163
+ }
6181
7164
  async driveArkadeRefund(swap) {
6182
7165
  const now = this.config.now();
6183
7166
  const refusal = await this.probeRefusal(swap);
@@ -6203,6 +7186,7 @@ var RfqSwapManager = class _RfqSwapManager {
6203
7186
  if (pushed) {
6204
7187
  swap.refundTxid = pushed.txid;
6205
7188
  this.touch(swap);
7189
+ if (pushed.left) return;
6206
7190
  } else if (now < swap.refundLocktime + REFUND_MTP_LAG_SECONDS) {
6207
7191
  return;
6208
7192
  }
@@ -6213,6 +7197,8 @@ var RfqSwapManager = class _RfqSwapManager {
6213
7197
  this.refundRefused.add(swap.rfqId);
6214
7198
  return this.block(swap, error.message);
6215
7199
  }
7200
+ const ark = (0, import_sdk27.isArkError)(error) ? error : (0, import_sdk27.maybeArkError)(error);
7201
+ if ((0, import_sdk27.isArkError)(ark, import_sdk27.ArkErrorName.VTXO_ALREADY_SPENT)) return;
6216
7202
  this.emitFailed(swap, error);
6217
7203
  if (now >= swap.refundLocktime + REFUND_MTP_LAG_SECONDS) {
6218
7204
  swap.failure = errorMessage(error);
@@ -6220,12 +7206,10 @@ var RfqSwapManager = class _RfqSwapManager {
6220
7206
  }
6221
7207
  }
6222
7208
  }
6223
- /** Whether any output was never handed to the claim callback (the only reason to
6224
- * claim twice). */
6225
- hasUnclaimedOutpoint(rfqId, vtxos) {
7209
+ /** The outputs no claim of ours has taken yet (the only reason to claim twice). */
7210
+ unclaimed(rfqId, vtxos) {
6226
7211
  const claimed = this.claimedOutpoints.get(rfqId);
6227
- if (!claimed) return true;
6228
- return vtxos.some((vtxo) => !claimed.has(outpointKey(vtxo)));
7212
+ return claimed ? vtxos.filter((vtxo) => !claimed.has(outpointKey(vtxo))) : vtxos;
6229
7213
  }
6230
7214
  rememberClaimed(rfqId, vtxos) {
6231
7215
  const claimed = this.claimedOutpoints.get(rfqId) ?? /* @__PURE__ */ new Set();
@@ -6283,7 +7267,7 @@ var RfqSwapManager = class _RfqSwapManager {
6283
7267
  */
6284
7268
  stampSettlementPreimage(swap, preimage) {
6285
7269
  if (swap.kind !== "lightning_send") return;
6286
- swap.settlementPreimageHex = import_base15.hex.encode(preimage);
7270
+ swap.settlementPreimageHex = import_base16.hex.encode(preimage);
6287
7271
  this.touch(swap);
6288
7272
  }
6289
7273
  touch(swap) {
@@ -6375,7 +7359,7 @@ var RfqSwapManager = class _RfqSwapManager {
6375
7359
  if (swap.state === "failed") {
6376
7360
  const error = new Error(swap.failure ?? `swap ${swap.rfqId} failed`);
6377
7361
  for (const waiter of waiting) waiter.reject(error);
6378
- } else if (isPayoutDecided(swap)) {
7362
+ } else if (isPayoutDecided(swap, this.reportsConfirmations)) {
6379
7363
  const outcome = outcomeOf(swap);
6380
7364
  for (const waiter of waiting) waiter.resolve(outcome);
6381
7365
  } else {
@@ -6385,7 +7369,7 @@ var RfqSwapManager = class _RfqSwapManager {
6385
7369
  }
6386
7370
  };
6387
7371
  var traderClaimTxid = (swap) => swap.kind === "lightning_send" ? void 0 : swap.claimTxid;
6388
- var isPayoutDecided = (swap) => swap.state === "settled" || swap.state === "refunded" || swap.kind === "onchain_send" && swap.claimTxid !== void 0;
7372
+ var isPayoutDecided = (swap, confirmations = false) => swap.state === "settled" || swap.state === "refunded" || swap.kind === "onchain_send" && swap.claimTxid !== void 0 && (confirmations ? swap.claimConfirmed === true : true);
6389
7373
  var outcomeOf = (swap) => {
6390
7374
  const lostReceive = (swap.kind === "lightning_receive" || swap.kind === "onchain_receive") && swap.state === "refunded";
6391
7375
  return {
@@ -6406,8 +7390,8 @@ var errorMessage = (error) => error instanceof Error ? error.message : String(er
6406
7390
  var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
6407
7391
 
6408
7392
  // src/watch.ts
6409
- var import_base16 = require("@scure/base");
6410
- var import_sdk26 = require("@arkade-os/sdk");
7393
+ var import_base17 = require("@scure/base");
7394
+ var import_sdk28 = require("@arkade-os/sdk");
6411
7395
  init_coverage();
6412
7396
  init_offer();
6413
7397
  init_store();
@@ -6442,7 +7426,7 @@ async function watchOfferSwaps({
6442
7426
  wallet.getAddress(),
6443
7427
  wallet.getArkadeReader()
6444
7428
  ]);
6445
- const operatorPubkey = import_sdk26.ArkAddress.decode(address).serverPubKey;
7429
+ const operatorPubkey = import_sdk28.ArkAddress.decode(address).serverPubKey;
6446
7430
  let queue = Promise.resolve();
6447
7431
  const enqueue = (task) => {
6448
7432
  queue = queue.then(task).catch(() => {
@@ -6455,9 +7439,9 @@ async function watchOfferSwaps({
6455
7439
  if (candidates.length === 0) return "indeterminate";
6456
7440
  const { txs } = await indexer.getVirtualTxs(candidates);
6457
7441
  return classifyDepositSpend(
6458
- decodeOffer(import_base16.hex.decode(swap.offerHex)),
7442
+ decodeOffer(import_base17.hex.decode(swap.offerHex)),
6459
7443
  operatorPubkey,
6460
- txs.map((psbt) => import_sdk26.Transaction.fromPSBT(import_base16.base64.decode(psbt))),
7444
+ txs.map((psbt) => import_sdk28.Transaction.fromPSBT(import_base17.base64.decode(psbt))),
6461
7445
  { txid: vtxo.txid, vout: vtxo.vout }
6462
7446
  );
6463
7447
  } catch {
@@ -6480,12 +7464,12 @@ async function watchOfferSwaps({
6480
7464
  if (!persisted) continue;
6481
7465
  onUpdate?.(swaps.find((s) => s.id === swap.id) ?? swap);
6482
7466
  if (changes.status && RETIRABLE.includes(changes.status)) {
6483
- await retireOfferContract(manager, swaps, event.contractScript);
7467
+ await retireOfferContract(manager, swaps, event.contractScript, { scope: wallet });
6484
7468
  }
6485
7469
  }
6486
7470
  };
6487
7471
  const unsubscribe = manager.onContractEvent((event) => {
6488
- if (!(0, import_sdk26.isContractVtxoEvent)(event) || event.type !== "vtxo_spent") return;
7472
+ if (!(0, import_sdk28.isContractVtxoEvent)(event) || event.type !== "vtxo_spent") return;
6489
7473
  enqueue(() => handleSpend(event));
6490
7474
  });
6491
7475
  return {
@@ -6495,7 +7479,7 @@ async function watchOfferSwaps({
6495
7479
  }
6496
7480
 
6497
7481
  // src/client/legacyRecords.ts
6498
- var import_sdk27 = require("@arkade-os/sdk");
7482
+ var import_sdk29 = require("@arkade-os/sdk");
6499
7483
  init_repository();
6500
7484
  var readLegacyRfqSwaps = async (repository, filter = {}) => {
6501
7485
  try {
@@ -6512,7 +7496,7 @@ var withLegacyRfqSwaps = (bridge, repository, admits) => {
6512
7496
  index: bridge.index,
6513
7497
  quoteIdOf: bridge.quoteIdOf,
6514
7498
  async getRfqSwapsPage(filter, page) {
6515
- (0, import_sdk27.assertPageRequest)(page);
7499
+ (0, import_sdk29.assertPageRequest)(page);
6516
7500
  assertRfqSwapPageFilter(filter);
6517
7501
  const v2 = await collectRfqSwaps(bridge, filter);
6518
7502
  const held = new Set(
@@ -6588,6 +7572,13 @@ var OFFER_LIVE = (status) => status === "pending" || status === "cancelling";
6588
7572
  var traderClaimTxid2 = (swap) => swap.kind === "lightning_send" ? void 0 : swap.claimTxid;
6589
7573
  var readableRecord = (record) => {
6590
7574
  if (typeof record?.id !== "string" || record.route?.give === void 0) return false;
7575
+ if (record.assetPayment !== void 0) {
7576
+ try {
7577
+ assetPaymentOf(record.assetPayment, record.expiresAt);
7578
+ } catch {
7579
+ return false;
7580
+ }
7581
+ }
6591
7582
  if (record.family === "rfq") {
6592
7583
  return typeof record.rfqId === "string" && typeof record.lockupAddress === "string";
6593
7584
  }
@@ -6665,6 +7656,7 @@ var createSwapDrive = (config) => {
6665
7656
  return traderClaimTxid2(swap) ? "claimed" : "pending";
6666
7657
  };
6667
7658
  const outcomeOfEntry = (record, current) => {
7659
+ if (fundingWasNotSubmitted(record)) return "cancelled";
6668
7660
  if (record.family === "offer") return recordOutcome(record);
6669
7661
  if (current === void 0) {
6670
7662
  if (isRfqSwapTerminal(record.state)) return corridorOutcome(record.kind, record.state);
@@ -6692,7 +7684,7 @@ var createSwapDrive = (config) => {
6692
7684
  };
6693
7685
  const updateFor = (id) => {
6694
7686
  const record = records.get(id);
6695
- if (record === void 0) return void 0;
7687
+ if (record === void 0 || !readableRecord(record)) return void 0;
6696
7688
  const current = live.get(id);
6697
7689
  const outcome = outcomeOfEntry(record, current);
6698
7690
  return {
@@ -6742,8 +7734,15 @@ var createSwapDrive = (config) => {
6742
7734
  touch(swap.rfqId, swap);
6743
7735
  });
6744
7736
  let onchainSeams;
7737
+ const liveFeeRate = async (chain) => {
7738
+ try {
7739
+ return await chain.getFeeRate?.();
7740
+ } catch {
7741
+ return void 0;
7742
+ }
7743
+ };
6745
7744
  const defaultOnchainClaim = (chain, feeRateSatVb) => {
6746
- return async (swap, utxo) => {
7745
+ return async (swap, utxo, options) => {
6747
7746
  const record = await corridorStore().getRfqSwap(swap.rfqId);
6748
7747
  if (!record) {
6749
7748
  throw new Error(`rfq swap ${swap.rfqId} has no stored record to claim from`);
@@ -6751,10 +7750,10 @@ var createSwapDrive = (config) => {
6751
7750
  const secret = rfqClaimSecretOf(record);
6752
7751
  if (!secret) throw new Error(`rfq swap ${swap.rfqId} carries no claim secret`);
6753
7752
  const preimage = await preimageForSwapRecord(wallet, secret);
6754
- const signer = await (0, import_sdk28.contractSigner)(wallet, await (0, import_sdk28.identityDescriptor)(wallet.identity));
7753
+ const signer = await (0, import_sdk30.contractSigner)(wallet, await (0, import_sdk30.identityDescriptor)(wallet.identity));
6755
7754
  const claimKey = record.profile.claimKey;
6756
7755
  if (typeof claimKey === "string") {
6757
- const held = import_base17.hex.encode(await signer.xOnlyPublicKey());
7756
+ const held = import_base18.hex.encode(await signer.xOnlyPublicKey());
6758
7757
  if (held !== claimKey) {
6759
7758
  throw new Error(
6760
7759
  `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`
@@ -6764,17 +7763,25 @@ var createSwapDrive = (config) => {
6764
7763
  if (!swap.payoutPkScript) {
6765
7764
  throw new Error(`rfq swap ${swap.rfqId} carries no claim payout script`);
6766
7765
  }
7766
+ const rate = nextClaimFeeRate({
7767
+ configuredSatVb: feeRateSatVb,
7768
+ utxoAmount: utxo.amount,
7769
+ estimateSatVb: await liveFeeRate(chain),
7770
+ ...swap.claimFeeRateSatVb === void 0 ? {} : { lastSatVb: swap.claimFeeRateSatVb },
7771
+ ...options?.bump ? { bump: true } : {}
7772
+ });
6767
7773
  const { txid } = await track(
6768
7774
  claimOnchainFill(chain, {
6769
7775
  htlc: swap.htlc,
6770
7776
  utxo,
6771
7777
  preimage,
6772
7778
  payoutPkScript: swap.payoutPkScript,
6773
- feeRateSatVb,
6774
- sign: (sighash) => signer.signMessage(sighash, "schnorr")
7779
+ feeRateSatVb: rate,
7780
+ sign: (sighash) => signer.signMessage(sighash, "schnorr"),
7781
+ ...swap.claimTxid ? { republish: true } : {}
6775
7782
  })
6776
7783
  );
6777
- return { txid };
7784
+ return { txid, feeRateSatVb: rate };
6778
7785
  };
6779
7786
  };
6780
7787
  const defaultOnchainRefund = (chain, feeRateSatVb) => {
@@ -6789,8 +7796,8 @@ var createSwapDrive = (config) => {
6789
7796
  `rfq swap ${swap.rfqId} carries no refund descriptor; wire the onchain corridor's refund callback to take its L1 funding back`
6790
7797
  );
6791
7798
  }
6792
- const signer = await (0, import_sdk28.contractSigner)(wallet, descriptor);
6793
- const held = import_base17.hex.encode(await signer.xOnlyPublicKey());
7799
+ const signer = await (0, import_sdk30.contractSigner)(wallet, descriptor);
7800
+ const held = import_base18.hex.encode(await signer.xOnlyPublicKey());
6794
7801
  if (held !== record.profile.refundKey) {
6795
7802
  throw new Error(
6796
7803
  `the key behind ${descriptor} is ${held}, not the refund key ${String(record.profile.refundKey)} rfq swap ${swap.rfqId}'s HTLC was derived with`
@@ -6829,7 +7836,7 @@ var createSwapDrive = (config) => {
6829
7836
  }
6830
7837
  };
6831
7838
  const drivable = async (record) => !readsChain(record.kind) || await resolveOnchain();
6832
- const pinnedNetwork = async () => (0, import_sdk28.getNetwork)(await config.network());
7839
+ const pinnedNetwork = async () => (0, import_sdk30.getNetwork)(await config.network());
6833
7840
  const claimLockup = async (swap, vtxos, { partiallyClaimed }) => {
6834
7841
  const record = await corridorStore().getRfqSwap(swap.rfqId);
6835
7842
  if (!record) throw new Error(`rfq swap ${swap.rfqId} has no stored record to claim from`);
@@ -6844,10 +7851,10 @@ var createSwapDrive = (config) => {
6844
7851
  return track(
6845
7852
  pushClaim(operator, {
6846
7853
  contract: script,
6847
- receiver: await (0, import_sdk28.contractSigner)(wallet, secret.signingDescriptor),
7854
+ receiver: await (0, import_sdk30.contractSigner)(wallet, secret.signingDescriptor),
6848
7855
  preimage: await preimageForSwapRecord(wallet, secret),
6849
7856
  vtxos,
6850
- destinationPkScript: import_sdk28.ArkAddress.decode(payoutAddress).pkScript,
7857
+ destinationPkScript: import_sdk30.ArkAddress.decode(payoutAddress).pkScript,
6851
7858
  // Passed through: `pushClaim`'s own value check decides whether `P` is published.
6852
7859
  expectedAmount: swap.expectedAmount,
6853
7860
  partiallyClaimed,
@@ -6915,7 +7922,7 @@ var createSwapDrive = (config) => {
6915
7922
  config.network()
6916
7923
  ]);
6917
7924
  const txs = history.map(toRestoreTx);
6918
- const { hrp, serverPubKey: operatorPubkey } = import_sdk28.ArkAddress.decode(address);
7925
+ const { hrp, serverPubKey: operatorPubkey } = import_sdk30.ArkAddress.decode(address);
6919
7926
  const reopened = await legacyOfferDepositsToAdopt(store);
6920
7927
  for (const txid of reopen) reopened.add(txid);
6921
7928
  const cursor = reopened.size === 0 ? scanned : new Set([...scanned].filter((txid) => !reopened.has(txid)));
@@ -6965,7 +7972,9 @@ var createSwapDrive = (config) => {
6965
7972
  await store.markTxidsScanned(scannedTxids.filter((txid) => !stillLive.has(txid)));
6966
7973
  const registry = managerDeps.contracts;
6967
7974
  if (registry) {
6968
- await retireSettledOfferContracts(registry, [...current.values()].map(offerFactsOf));
7975
+ await retireSettledOfferContracts(registry, [...current.values()].map(offerFactsOf), {
7976
+ scope: wallet
7977
+ });
6969
7978
  }
6970
7979
  return [...current.values()];
6971
7980
  };
@@ -6974,6 +7983,7 @@ var createSwapDrive = (config) => {
6974
7983
  getContractsWithVtxos: async (filter) => (await contractsOf()).getContractsWithVtxos(filter)
6975
7984
  };
6976
7985
  const registerCorridorSwap = async (record) => {
7986
+ if (fundingWasNotSubmitted(record)) return;
6977
7987
  if (mode === "readonly") return;
6978
7988
  if (!await drivable(record)) {
6979
7989
  undrivable.add(record.id);
@@ -7055,7 +8065,23 @@ var createSwapDrive = (config) => {
7055
8065
  await adoptLegacyRfqSwaps(repository);
7056
8066
  const all = await collectSwapRecords(repository);
7057
8067
  const { corridor, offer } = splitRecords(all.filter(readableRecord));
7058
- for (const record of [...corridor, ...offer]) records.set(record.id, record);
8068
+ const retiredScripts = /* @__PURE__ */ new Set();
8069
+ for (const record of [...corridor, ...offer]) {
8070
+ records.set(record.id, record);
8071
+ if (mode !== "readonly" && fundingWasNotSubmitted(record)) {
8072
+ const script = record.family === "offer" ? record.swapPkScript : record.lockupPkScript;
8073
+ if (retiredScripts.has(script)) continue;
8074
+ retiredScripts.add(script);
8075
+ try {
8076
+ await retireUnsubmittedFunding(wallet, repository, record, await contractsOf());
8077
+ } catch (error) {
8078
+ console.warn(
8079
+ `[swap] could not restore unsent coverage for ${record.id}`,
8080
+ error
8081
+ );
8082
+ }
8083
+ }
8084
+ }
7059
8085
  const liveCorridor = corridor.filter((record) => !isRfqSwapTerminal(record.state));
7060
8086
  const store = corridorStore();
7061
8087
  for (const record of liveCorridor) store.index(record);
@@ -7149,7 +8175,7 @@ var createSwapDrive = (config) => {
7149
8175
  id
7150
8176
  );
7151
8177
  }
7152
- const script = import_base17.hex.decode(record.lockupPkScript);
8178
+ const script = import_base18.hex.decode(record.lockupPkScript);
7153
8179
  const before = await recoverableAt(script);
7154
8180
  if (before.length === 0) {
7155
8181
  throw new SwapDriveRefusedError(
@@ -7252,6 +8278,10 @@ var createSwapDrive = (config) => {
7252
8278
  adopt: (record) => {
7253
8279
  if (disposed) throw new ClientDisposed("accept");
7254
8280
  records.set(record.id, record);
8281
+ if (fundingWasNotSubmitted(record)) {
8282
+ emit(record.id);
8283
+ return swapView(record.id);
8284
+ }
7255
8285
  if (record.family === "rfq") {
7256
8286
  corridorStore().index(record);
7257
8287
  managerDeps.repository = corridorStore();
@@ -7271,24 +8301,24 @@ var createSwapDrive = (config) => {
7271
8301
  };
7272
8302
 
7273
8303
  // src/client/quoteOffer.ts
7274
- var import_solver_discovery9 = require("@arkade-os/solver-discovery");
8304
+ var import_solver_discovery11 = require("@arkade-os/solver-discovery");
7275
8305
  init_offer();
7276
8306
 
7277
8307
  // src/client/market.ts
7278
- var import_solver_discovery8 = require("@arkade-os/solver-discovery");
8308
+ var import_solver_discovery10 = require("@arkade-os/solver-discovery");
7279
8309
  var marketKeyOf = (card) => {
7280
- const base = (0, import_solver_discovery8.marketLegKey)(card, "base");
7281
- const quote = (0, import_solver_discovery8.marketLegKey)(card, "quote");
7282
- const baseIsArkade = (0, import_solver_discovery8.marketCorridor)(card, "base") === "arkade";
7283
- const quoteIsArkade = (0, import_solver_discovery8.marketCorridor)(card, "quote") === "arkade";
8310
+ const base = (0, import_solver_discovery10.marketLegKey)(card, "base");
8311
+ const quote = (0, import_solver_discovery10.marketLegKey)(card, "quote");
8312
+ const baseIsArkade = (0, import_solver_discovery10.marketCorridor)(card, "base") === "arkade";
8313
+ const quoteIsArkade = (0, import_solver_discovery10.marketCorridor)(card, "quote") === "arkade";
7284
8314
  if (baseIsArkade !== quoteIsArkade) {
7285
8315
  return baseIsArkade ? `${base}/${quote}` : `${quote}/${base}`;
7286
8316
  }
7287
8317
  return base <= quote ? `${base}/${quote}` : `${quote}/${base}`;
7288
8318
  };
7289
8319
  var hasRendezvous = (card) => typeof card.discovery_pubkey === "string" && (card.transports?.nostr?.relays?.length ?? 0) > 0;
7290
- var isAddressable = (card) => !(0, import_solver_discovery8.isRfqMarket)(card) || hasRendezvous(card);
7291
- var marketBackendOf = (card) => (0, import_solver_discovery8.isRfqMarket)(card) || hasRendezvous(card) ? "rfq" : "feed";
8320
+ var isAddressable = (card) => !(0, import_solver_discovery10.isRfqMarket)(card) || hasRendezvous(card);
8321
+ var marketBackendOf = (card) => (0, import_solver_discovery10.isRfqMarket)(card) || hasRendezvous(card) ? "rfq" : "feed";
7292
8322
  var usableMarkets = (snapshot, policy) => {
7293
8323
  const allowed = policy?.allowedRegistries;
7294
8324
  return (allowed ? snapshot.markets.filter((card) => allowed.includes(card.source)) : snapshot.markets).filter(isAddressable);
@@ -7305,12 +8335,12 @@ var eligibleMarkets = (snapshot, legs, policy, takeAmount) => {
7305
8335
  wantSide: side === "base" ? "quote" : "base",
7306
8336
  ...takeAmount === void 0 ? {} : { wantAmount: takeAmount }
7307
8337
  };
7308
- const canonical = (0, import_solver_discovery8.selectMarkets)([...markets], {
8338
+ const canonical = (0, import_solver_discovery10.selectMarkets)([...markets], {
7309
8339
  baseId: base.marketId,
7310
8340
  quoteId: quote.marketId,
7311
8341
  ...selection
7312
8342
  });
7313
- const legacy = (0, import_solver_discovery8.selectMarkets)([...markets], {
8343
+ const legacy = (0, import_solver_discovery10.selectMarkets)([...markets], {
7314
8344
  baseId: `${base.corridor}:${base.assetId}`,
7315
8345
  quoteId: `${quote.corridor}:${quote.assetId}`,
7316
8346
  ...selection
@@ -7369,16 +8399,16 @@ var assembleRoute = (give, take) => {
7369
8399
  }
7370
8400
  return { give, take };
7371
8401
  };
7372
- var endpoint = (corridor, asset7, instrument) => ({
8402
+ var endpoint = (corridor, asset8, instrument) => ({
7373
8403
  corridor,
7374
- asset: asset7,
8404
+ asset: asset8,
7375
8405
  ...instrument === void 0 ? {} : { instrument }
7376
8406
  });
7377
- var legFor = (asset7, expected) => {
7378
- const leg = toDiscoveryLeg(asset7);
8407
+ var legFor = (asset8, expected) => {
8408
+ const leg = toDiscoveryLeg(asset8);
7379
8409
  if (expected !== void 0 && leg.corridor !== expected) {
7380
8410
  throw new UnsupportedRoute(
7381
- `${asset7} settles on ${leg.corridor}, and this leg is ${expected}`,
8411
+ `${asset8} settles on ${leg.corridor}, and this leg is ${expected}`,
7382
8412
  { give: leg.corridor, take: expected }
7383
8413
  );
7384
8414
  }
@@ -7715,7 +8745,7 @@ var quoteFromFeed = async (input) => {
7715
8745
  if (amount === void 0) {
7716
8746
  throw new Error("an asset swap needs an amount and the side it pins");
7717
8747
  }
7718
- const plan = await (0, import_solver_discovery9.quoteOffer)(candidate.card, {
8748
+ const plan = await (0, import_solver_discovery11.quoteOffer)(candidate.card, {
7719
8749
  give: candidate.give,
7720
8750
  ...amount.on === "give" ? { giveAmount: amount.value } : { wantAmount: amount.value },
7721
8751
  // What `fund` attaches to an asset deposit and the fill pays an asset want: the plan asks
@@ -7759,7 +8789,7 @@ var quoteFromFeed = async (input) => {
7759
8789
  };
7760
8790
  var feedSpread = (plan, take, carrierSats = 0n) => {
7761
8791
  const payout = take > carrierSats ? take - carrierSats : 0n;
7762
- const fair = (0, import_solver_discovery9.computeWantAmount)({
8792
+ const fair = (0, import_solver_discovery11.computeWantAmount)({
7763
8793
  deposit: plan.deposit.atomic,
7764
8794
  give: plan.give,
7765
8795
  price: plan.price,
@@ -7777,7 +8807,7 @@ var feedExpiry = (card, feed, now) => {
7777
8807
  };
7778
8808
  var verifyPlanLegs = (plan, legs, give) => {
7779
8809
  const take = give === "base" ? "quote" : "base";
7780
- const spelled = (side) => (0, import_solver_discovery9.marketLegKey)(plan.market, side);
8810
+ const spelled = (side) => (0, import_solver_discovery11.marketLegKey)(plan.market, side);
7781
8811
  const names = (side, leg) => spelled(side) === leg.marketId || spelled(side) === `${leg.corridor}:${leg.assetId}`;
7782
8812
  if (plan.give !== give || !names(give, legs.give) || !names(take, legs.take)) {
7783
8813
  throw new QuoteVerificationFailed(
@@ -7789,9 +8819,93 @@ var verifyPlanLegs = (plan, legs, give) => {
7789
8819
  };
7790
8820
 
7791
8821
  // src/client/quoteRfq.ts
7792
- var import_base18 = require("@scure/base");
8822
+ var import_base20 = require("@scure/base");
8823
+ var import_sdk34 = require("@arkade-os/sdk");
8824
+ var import_solver_discovery12 = require("@arkade-os/solver-discovery");
8825
+
8826
+ // src/jointGraph.ts
8827
+ var import_base19 = require("@scure/base");
8828
+ var import_sha26 = require("@noble/hashes/sha2.js");
7793
8829
  var import_sdk31 = require("@arkade-os/sdk");
7794
- var import_solver_discovery10 = require("@arkade-os/solver-discovery");
8830
+ function digestJointGraph(plan, template) {
8831
+ const parts = [];
8832
+ const pushU32 = (value) => {
8833
+ const len = new Uint8Array(4);
8834
+ new DataView(len.buffer).setUint32(0, value, false);
8835
+ parts.push(len);
8836
+ };
8837
+ const pushField = (bytes) => {
8838
+ pushU32(bytes.length);
8839
+ parts.push(bytes);
8840
+ };
8841
+ pushField(new TextEncoder().encode(template));
8842
+ pushField(unsignedPsbtBytes(parseGraphTx(plan.arkTx)));
8843
+ pushU32(plan.checkpoints.length);
8844
+ for (const checkpoint of plan.checkpoints) {
8845
+ pushField(unsignedPsbtBytes(parseGraphTx(checkpoint)));
8846
+ }
8847
+ pushU32(plan.inputOwners.length);
8848
+ for (const owner of plan.inputOwners) {
8849
+ if (owner === null) {
8850
+ parts.push(new Uint8Array([0]));
8851
+ } else {
8852
+ const bytes = new TextEncoder().encode(owner);
8853
+ parts.push(new Uint8Array([1]));
8854
+ pushField(bytes);
8855
+ }
8856
+ }
8857
+ const preimage = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
8858
+ let at2 = 0;
8859
+ for (const part of parts) {
8860
+ preimage.set(part, at2);
8861
+ at2 += part.length;
8862
+ }
8863
+ return import_base19.hex.encode((0, import_sha26.sha256)(preimage));
8864
+ }
8865
+ function verifyJointGraph(plan, template) {
8866
+ try {
8867
+ if (!plan || typeof plan !== "object") return false;
8868
+ if (typeof plan.arkTx !== "string" || plan.arkTx.length === 0) return false;
8869
+ if (!Array.isArray(plan.checkpoints) || plan.checkpoints.length < 1 || plan.checkpoints.some((c) => typeof c !== "string" || c.length === 0))
8870
+ return false;
8871
+ if (!/^[0-9a-f]{64}$/.test(plan.graphId)) return false;
8872
+ if (!Array.isArray(plan.inputOwners) || plan.inputOwners.some((o) => o !== null && (typeof o !== "string" || o.length === 0)))
8873
+ return false;
8874
+ if (plan.inputOwners.length !== plan.checkpoints.length) return false;
8875
+ const arkInputs = parseGraphTx(plan.arkTx).inputsLength;
8876
+ if (plan.checkpoints.length !== arkInputs) return false;
8877
+ if (plan.inputOwners.length !== arkInputs) return false;
8878
+ return digestJointGraph(
8879
+ {
8880
+ arkTx: plan.arkTx,
8881
+ checkpoints: [...plan.checkpoints],
8882
+ inputOwners: [...plan.inputOwners]
8883
+ },
8884
+ template
8885
+ ) === plan.graphId;
8886
+ } catch {
8887
+ return false;
8888
+ }
8889
+ }
8890
+ function parseGraphTx(psbt) {
8891
+ return import_sdk31.Transaction.fromPSBT(import_base19.base64.decode(psbt));
8892
+ }
8893
+ function deepFreeze(value) {
8894
+ if (value !== null && typeof value === "object") {
8895
+ for (const child of Object.values(value)) deepFreeze(child);
8896
+ Object.freeze(value);
8897
+ }
8898
+ return value;
8899
+ }
8900
+ function unsignedPsbtBytes(tx) {
8901
+ const stripped = tx.clone();
8902
+ for (let i = 0; i < stripped.inputsLength; i++) {
8903
+ stripped.updateInput(i, { tapScriptSig: void 0 });
8904
+ }
8905
+ return stripped.toPSBT();
8906
+ }
8907
+
8908
+ // src/client/quoteRfq.ts
7795
8909
  init_claimPacket();
7796
8910
  init_offer();
7797
8911
  init_store();
@@ -7799,11 +8913,11 @@ init_onchainHtlc();
7799
8913
  init_onchainHtlc();
7800
8914
 
7801
8915
  // src/payment/onchainSwap.ts
7802
- var import_sdk30 = require("@arkade-os/sdk");
8916
+ var import_sdk33 = require("@arkade-os/sdk");
7803
8917
  init_onchainHtlc();
7804
8918
 
7805
8919
  // src/payment/swapRail.ts
7806
- var import_sdk29 = require("@arkade-os/sdk");
8920
+ var import_sdk32 = require("@arkade-os/sdk");
7807
8921
 
7808
8922
  // src/client/sats.ts
7809
8923
  var satsOf = (value, field) => {
@@ -7860,13 +8974,13 @@ var lockupOf = (derived) => ({
7860
8974
  pkScript: derived.swapPkScript
7861
8975
  });
7862
8976
  var covenantInputs = (input) => {
7863
- const network = (0, import_sdk31.networkFromArkadeInfo)(input.info);
8977
+ const network = (0, import_sdk34.networkFromArkadeInfo)(input.info);
7864
8978
  const arkade2 = input.corridors.get("arkade").deps;
7865
8979
  return {
7866
- operatorPubkey: (0, import_sdk31.toXOnly)(import_base18.hex.decode(input.info.signerPubkey), "ark signer key"),
8980
+ operatorPubkey: (0, import_sdk34.toXOnly)(import_base20.hex.decode(input.info.signerPubkey), "ark signer key"),
7867
8981
  // The resolved per-network pin, never operator-reported: it lands in a covenant leaf
7868
8982
  // that decides who can move the funds.
7869
- emulatorPubkey: (0, import_sdk31.toXOnly)(import_base18.hex.decode(arkade2.emulatorPubkey), "emulator signer key"),
8983
+ emulatorPubkey: (0, import_sdk34.toXOnly)(import_base20.hex.decode(arkade2.emulatorPubkey), "emulator signer key"),
7870
8984
  claimDelay: unilateralClaimDelay(Number(input.info.unilateralExitDelay)),
7871
8985
  hrp: network.hrp
7872
8986
  };
@@ -7874,7 +8988,7 @@ var covenantInputs = (input) => {
7874
8988
  var sealingKey = (deps) => {
7875
8989
  const configured = deps.covclaimd?.pubkey;
7876
8990
  if (configured === void 0) return void 0;
7877
- const key = import_base18.hex.decode(configured);
8991
+ const key = import_base20.hex.decode(configured);
7878
8992
  if (key.length !== 33) {
7879
8993
  throw new Error(
7880
8994
  `the covclaimd deployment key must be 33-byte compressed hex, got ${key.length} bytes`
@@ -7894,6 +9008,8 @@ var quoteViaRfq = async (input) => {
7894
9008
  expected: input.market.discoveryPubkey,
7895
9009
  pinnable: input.market.snapshot.live
7896
9010
  });
9011
+ if (input.assetPayment !== void 0 && input.route !== "arkade->arkade")
9012
+ throw new Error("assetPayment supports BTC-to-asset only");
7897
9013
  switch (input.route) {
7898
9014
  case "arkade->arkade":
7899
9015
  return quoteArkadeAsset(input);
@@ -7909,12 +9025,12 @@ var quoteViaRfq = async (input) => {
7909
9025
  };
7910
9026
  var quoteArkadeAsset = async (input) => {
7911
9027
  const pinned = pinnedFor(input);
7912
- if (pinned.on !== "give") {
7913
- throw new Error(
7914
- "an asset swap is exact-in: pin the amount on the give leg. The legs carry different assets, so there is no spread to price a take-side pin back through \u2014 the solver answers `exact_out_unsupported`"
7915
- );
7916
- }
7917
9028
  const sides = assetSidesOf(input.legs);
9029
+ if (pinned.on !== "give" && sides.wantAsset === void 0)
9030
+ throw new Error("asset-to-BTC is exact-in only");
9031
+ const payment = input.assetPayment;
9032
+ if (payment !== void 0 && sides.wantAsset === void 0)
9033
+ throw new Error("assetPayment supports BTC-to-asset only");
7918
9034
  if (input.candidate.card.price_feed === void 0) {
7919
9035
  throw new UnsupportedRoute(
7920
9036
  `card ${input.candidate.card.solver} advertises no price feed to measure an asset swap's fee against`,
@@ -7924,15 +9040,43 @@ var quoteArkadeAsset = async (input) => {
7924
9040
  const pair = rfqPairFor(input.legs.give, input.legs.take);
7925
9041
  const rfqId = newRfqId();
7926
9042
  const maker = await makerPosition(input.wallet);
7927
- const wire = await input.transport.requestQuote(
7928
- arkadeSwapRequest({
7929
- rfqId,
7930
- ...sides,
7931
- amount: pinned.value,
7932
- makerPkScript: maker.pkScript,
7933
- makerPublicKey: maker.publicKey
7934
- })
9043
+ const receiveAddress = payment?.receiveAddress;
9044
+ const receivePkScript = resolveReceivePkScript(
9045
+ receiveAddress,
9046
+ maker.pkScript,
9047
+ (0, import_sdk34.networkFromArkadeInfo)(input.info).hrp,
9048
+ (0, import_sdk34.toXOnly)(import_base20.hex.decode(input.info.signerPubkey), "ark signer key")
7935
9049
  );
9050
+ const choice = payment?.carrier;
9051
+ const carrierRequest = choice === void 0 ? void 0 : choice.mode === "purchase" ? { mode: "purchase" } : {
9052
+ mode: "recycle_receiver",
9053
+ quoteId: choice.quote.quoteId,
9054
+ taxiUrl: choice.taxi.url,
9055
+ taxiKey: choice.taxi.operatorKey
9056
+ };
9057
+ if (choice?.mode === "recycleReceiver") {
9058
+ if (choice.quote.assetId !== sides.wantAsset?.toString())
9059
+ throw new Error("carrier quote assetId differs from requested asset");
9060
+ if (choice.quote.senderKey !== import_base20.hex.encode(maker.publicKey))
9061
+ throw new Error("carrier quote senderKey differs from wallet identity");
9062
+ if (input.now >= choice.quote.expiresAt - 30)
9063
+ throw new Error("carrier quote expired before RFQ");
9064
+ }
9065
+ const request = arkadeSwapRequest({
9066
+ rfqId,
9067
+ ...sides,
9068
+ amount: pinned.value,
9069
+ amountSide: toRfqAmountSide(pinned.on),
9070
+ makerPkScript: receivePkScript,
9071
+ makerPublicKey: maker.publicKey
9072
+ });
9073
+ const wire = await input.transport.requestQuote({
9074
+ ...request,
9075
+ profile: {
9076
+ ...request.profile,
9077
+ ...carrierRequest === void 0 ? {} : { carrier: encodeCarrierRequest(carrierRequest) }
9078
+ }
9079
+ });
7936
9080
  verifyPair(wire.pair, pair);
7937
9081
  const parsed = parseRfqQuote(wire);
7938
9082
  verifyCrossAssetAmount({ pair, pinned, give: parsed.give, take: parsed.take });
@@ -7942,8 +9086,42 @@ var quoteArkadeAsset = async (input) => {
7942
9086
  now: input.now,
7943
9087
  floorSeconds: input.policy?.quoteTtlFloorSeconds
7944
9088
  });
9089
+ let assetPayment;
9090
+ if (payment !== void 0) {
9091
+ let carrier;
9092
+ if (carrierRequest !== void 0) {
9093
+ carrier = parseCarrierEcho(wire.profile?.carrier, carrierRequest);
9094
+ if (carrier.physicalSats !== input.info.dust)
9095
+ throw new Error("carrier physical differs from server dust");
9096
+ if (carrier.expiresAt > parsed.validUntil)
9097
+ throw new Error("carrier echo extends solver expiry");
9098
+ if (choice?.mode === "recycleReceiver") {
9099
+ if (wire.carrier_sats !== void 0)
9100
+ throw new Error("receiver-paid quote must publish no carrier_sats");
9101
+ assertReceiverPaidEchoMatchesExpected(carrier, choice.quote);
9102
+ } else if (parseTopLevelCarrierSats(wire.carrier_sats) !== carrier.physicalSats)
9103
+ throw new Error("carrier echo differs from carrier_sats");
9104
+ }
9105
+ const validUntil = Math.min(
9106
+ parsed.validUntil,
9107
+ carrier?.expiresAt ?? parsed.validUntil,
9108
+ choice?.mode === "recycleReceiver" ? choice.quote.expiresAt : parsed.validUntil
9109
+ ) - 30;
9110
+ if (input.now >= validUntil) throw new Error("asset payment terms lapsed before funding");
9111
+ assetPayment = {
9112
+ receiveAddress: receiveAddress ?? new import_sdk34.ArkAddress(
9113
+ (0, import_sdk34.toXOnly)(import_base20.hex.decode(input.info.signerPubkey), "ark signer key"),
9114
+ maker.pkScript.slice(2),
9115
+ (0, import_sdk34.networkFromArkadeInfo)(input.info).hrp
9116
+ ).encode(),
9117
+ validUntil,
9118
+ ...carrier === void 0 ? {} : { carrier },
9119
+ ...choice?.mode !== "recycleReceiver" || choice.inputExpiryFloor === void 0 ? {} : { inputExpiryFloor: choice.inputExpiryFloor }
9120
+ };
9121
+ }
9122
+ if (assetPayment !== void 0) deepFreeze(assetPayment);
7945
9123
  const carrierSats = sides.offerAsset === void 0 ? void 0 : verifiedCarrierSats(wire);
7946
- const reference = await (0, import_solver_discovery10.quoteOffer)(input.candidate.card, {
9124
+ const reference = await (0, import_solver_discovery12.quoteOffer)(input.candidate.card, {
7947
9125
  give: input.candidate.give,
7948
9126
  giveAmount: parsed.give,
7949
9127
  ...carrierSats === void 0 ? {} : { carrierSats },
@@ -7958,15 +9136,20 @@ var quoteArkadeAsset = async (input) => {
7958
9136
  ...terms.offerAsset === void 0 ? {} : { offerAsset: terms.offerAsset },
7959
9137
  emulatorPubkey: input.corridors.get("arkade").deps.emulatorPubkey,
7960
9138
  maker,
9139
+ ...receiveAddress === void 0 ? {} : { receiveAddress },
7961
9140
  info: input.info
7962
9141
  });
7963
9142
  verifyingDerivation(() => verifyOfferAddress(wire, offer));
7964
9143
  return {
7965
9144
  quote: {
7966
9145
  id: input.quoteId,
9146
+ ...assetPayment === void 0 ? {} : { assetPayment },
7967
9147
  route: assembleRoute(
7968
9148
  { ...input.endpoints.give, instrument: { kind: "wallet" } },
7969
- { ...input.endpoints.take, instrument: { kind: "wallet" } }
9149
+ {
9150
+ ...input.endpoints.take,
9151
+ instrument: receiveAddress === void 0 ? { kind: "wallet" } : { kind: "address", address: receiveAddress }
9152
+ }
7970
9153
  ),
7971
9154
  give: { asset: input.endpoints.give.asset, amount: parsed.give },
7972
9155
  take: { asset: input.endpoints.take.asset, amount: parsed.take },
@@ -7986,6 +9169,10 @@ var quoteArkadeAsset = async (input) => {
7986
9169
  rfqId,
7987
9170
  wire: parsed,
7988
9171
  offer,
9172
+ ...assetPayment === void 0 ? {} : {
9173
+ assetPayment,
9174
+ assetPaymentRecipient: receiveAddress === void 0 ? { kind: "wallet" } : { kind: "address", address: receiveAddress }
9175
+ },
7989
9176
  ...carrierSats === void 0 ? {} : { carrierSats }
7990
9177
  }
7991
9178
  };
@@ -8005,14 +9192,14 @@ var assetSidesOf = (legs) => {
8005
9192
  { give: "arkade", take: "arkade" }
8006
9193
  );
8007
9194
  }
8008
- return giveIsBtc ? { wantAsset: import_sdk31.asset.AssetId.fromString(legs.take.assetId) } : { offerAsset: import_sdk31.asset.AssetId.fromString(legs.give.assetId) };
9195
+ return giveIsBtc ? { wantAsset: import_sdk34.asset.AssetId.fromString(legs.take.assetId) } : { offerAsset: import_sdk34.asset.AssetId.fromString(legs.give.assetId) };
8009
9196
  };
8010
9197
  var makerPosition = async (wallet) => {
8011
9198
  const [address, publicKey] = await Promise.all([
8012
9199
  wallet.getAddress(),
8013
9200
  wallet.identity.xOnlyPublicKey()
8014
9201
  ]);
8015
- return { pkScript: import_sdk31.ArkAddress.decode(address).pkScript, publicKey };
9202
+ return { pkScript: import_sdk34.ArkAddress.decode(address).pkScript, publicKey };
8016
9203
  };
8017
9204
  var quoteLightningSend = async (input) => {
8018
9205
  const invoice = input.endpoints.take.instrument;
@@ -8021,7 +9208,7 @@ var quoteLightningSend = async (input) => {
8021
9208
  }
8022
9209
  const pair = rfqPairFor(input.legs.give, input.legs.take);
8023
9210
  const rfqId = newRfqId();
8024
- const secrets = await (0, import_sdk31.provisionRefundKey)(input.wallet);
9211
+ const secrets = await (0, import_sdk34.provisionRefundKey)(input.wallet);
8025
9212
  const wire = await input.transport.requestQuote(
8026
9213
  lightningSendRequest({
8027
9214
  rfqId,
@@ -8096,8 +9283,8 @@ var quoteLightningReceive = async (input) => {
8096
9283
  const pinned = pinnedFor(input);
8097
9284
  const pair = rfqPairFor(input.legs.give, input.legs.take);
8098
9285
  const rfqId = newRfqId();
8099
- const secrets = await (0, import_sdk31.provisionClaimSecret)(input.wallet);
8100
- const paymentHash = import_base18.hex.encode(secrets.paymentHash);
9286
+ const secrets = await (0, import_sdk34.provisionClaimSecret)(input.wallet);
9287
+ const paymentHash = import_base20.hex.encode(secrets.paymentHash);
8101
9288
  const payoutAddress = await input.wallet.getAddress();
8102
9289
  const lightning = input.corridors.get("lightning").deps;
8103
9290
  const sealTo = sealingKey(lightning);
@@ -8208,9 +9395,9 @@ var quoteOnchainSend = async (input) => {
8208
9395
  claimVsize: onchain.claimVsize
8209
9396
  }) : void 0;
8210
9397
  const quoted = claimFee === void 0 ? pinned : { on: pinned.on, value: pinned.value + claimFee, source: pinned.source };
8211
- const secrets = await (0, import_sdk31.provisionClaimSecret)(input.wallet);
8212
- const payoutKey = await (0, import_sdk31.provisionRefundKey)(input.wallet);
8213
- const paymentHash = import_base18.hex.encode(secrets.paymentHash);
9398
+ const secrets = await (0, import_sdk34.provisionClaimSecret)(input.wallet);
9399
+ const payoutKey = await (0, import_sdk34.provisionRefundKey)(input.wallet);
9400
+ const paymentHash = import_base20.hex.encode(secrets.paymentHash);
8214
9401
  const wire = await input.transport.requestQuote(
8215
9402
  withCanonicalAmount(
8216
9403
  onchainSendRequest({
@@ -8314,9 +9501,9 @@ var quoteOnchainReceive = async (input) => {
8314
9501
  const pair = rfqPairFor(input.legs.give, input.legs.take);
8315
9502
  const rfqId = newRfqId();
8316
9503
  const l1Network = l1NetworkFromArk(input.info.network);
8317
- const secrets = await (0, import_sdk31.provisionClaimSecret)(input.wallet);
8318
- const refundKey = await (0, import_sdk31.provisionRefundKey)(input.wallet);
8319
- const paymentHash = import_base18.hex.encode(secrets.paymentHash);
9504
+ const secrets = await (0, import_sdk34.provisionClaimSecret)(input.wallet);
9505
+ const refundKey = await (0, import_sdk34.provisionRefundKey)(input.wallet);
9506
+ const paymentHash = import_base20.hex.encode(secrets.paymentHash);
8320
9507
  const payoutAddress = await input.wallet.getAddress();
8321
9508
  const refundPkScript = l1ScriptForAddress(await input.wallet.getBoardingAddress(), l1Network);
8322
9509
  const wire = await input.transport.requestQuote(
@@ -8423,7 +9610,7 @@ var quoteOnchainReceive = async (input) => {
8423
9610
  };
8424
9611
 
8425
9612
  // src/client/verbs.ts
8426
- var import_sdk32 = require("@arkade-os/sdk");
9613
+ var import_sdk35 = require("@arkade-os/sdk");
8427
9614
  var enforceFeeCeiling = (quote, call, policy) => {
8428
9615
  let ceiling;
8429
9616
  for (const [source, limit] of [
@@ -8448,9 +9635,9 @@ var settle = async (deps, input, maxFee) => {
8448
9635
  return deps.accept(quote);
8449
9636
  };
8450
9637
  var pay = async (deps, destination, options = {}) => {
8451
- const arkade2 = (0, import_sdk32.arkTarget)(destination);
9638
+ const arkade2 = (0, import_sdk35.arkTarget)(destination);
8452
9639
  if (arkade2 !== void 0) {
8453
- const amount = (0, import_sdk32.resolveSendAmount)(
9640
+ const amount = (0, import_sdk35.resolveSendAmount)(
8454
9641
  "ark",
8455
9642
  destination,
8456
9643
  options.amount === void 0 ? void 0 : satsOf(options.amount, "amount")
@@ -8513,7 +9700,7 @@ var nostrTransportFactory = async (rendezvous) => {
8513
9700
 
8514
9701
  // src/client/client.ts
8515
9702
  var PREPARATIONS_HELD = 64;
8516
- var mintQuoteId = () => import_base19.hex.encode(crypto.getRandomValues(new Uint8Array(16)));
9703
+ var mintQuoteId = () => import_base21.hex.encode(crypto.getRandomValues(new Uint8Array(16)));
8517
9704
  var createSwapClient = (config) => {
8518
9705
  const { wallet } = config;
8519
9706
  const operator = config.operator ?? walletOperator(wallet);
@@ -8578,6 +9765,7 @@ var createSwapClient = (config) => {
8578
9765
  return (await route(input, "resolve")).resolution;
8579
9766
  },
8580
9767
  quote: async (input) => {
9768
+ const assetPayment = captureAssetPayment(input.assetPayment);
8581
9769
  ensureLive("quote");
8582
9770
  const { corridors, discovery } = await resolved();
8583
9771
  let resolvedRoute = await route(input, "quote");
@@ -8604,6 +9792,8 @@ var createSwapClient = (config) => {
8604
9792
  const quoteId = mintQuoteId();
8605
9793
  const now = Math.floor(Date.now() / 1e3);
8606
9794
  if (market.backend === "feed") {
9795
+ if (assetPayment !== void 0)
9796
+ throw new Error("assetPayment needs a negotiated BTC-to-asset market");
8607
9797
  const { quote, preparation } = await quoteFromFeed({
8608
9798
  quoteId,
8609
9799
  candidate: market,
@@ -8632,6 +9822,7 @@ var createSwapClient = (config) => {
8632
9822
  const { quote, preparation } = await quoteViaRfq({
8633
9823
  quoteId,
8634
9824
  route: resolvedRoute.pair,
9825
+ ...assetPayment === void 0 ? {} : { assetPayment },
8635
9826
  candidate: market,
8636
9827
  market: marketRef,
8637
9828
  legs: resolvedRoute.legs,
@@ -8652,7 +9843,8 @@ var createSwapClient = (config) => {
8652
9843
  });
8653
9844
  }
8654
9845
  },
8655
- accept: async (quote) => {
9846
+ accept: async (quote, options) => {
9847
+ const validUntil = (0, import_sdk36.captureSendDeadline)(options?.validUntil);
8656
9848
  ensureLive("accept");
8657
9849
  const { corridors } = await resolved();
8658
9850
  const drive2 = driving();
@@ -8660,6 +9852,7 @@ var createSwapClient = (config) => {
8660
9852
  const preparation = preparations.get(quote.id);
8661
9853
  return acceptQuote({
8662
9854
  quote,
9855
+ ...validUntil === void 0 ? {} : { validUntil },
8663
9856
  ...preparation === void 0 ? {} : { preparation },
8664
9857
  wallet,
8665
9858
  repository: config.repository,
@@ -8762,8 +9955,8 @@ var createSwapClient = (config) => {
8762
9955
  };
8763
9956
 
8764
9957
  // src/reveal.ts
8765
- var import_base20 = require("@scure/base");
8766
- var import_sdk33 = require("@arkade-os/sdk");
9958
+ var import_base22 = require("@scure/base");
9959
+ var import_sdk37 = require("@arkade-os/sdk");
8767
9960
  init_claimPacket();
8768
9961
  init_onchainHtlc();
8769
9962
  var CovclaimdRevealError = class extends Error {
@@ -8782,7 +9975,7 @@ var decodeKey = (value, field) => {
8782
9975
  if (typeof value !== "string") throw new Error(`covclaimd info: ${field} is not a string`);
8783
9976
  let bytes;
8784
9977
  try {
8785
- bytes = import_base20.hex.decode(value);
9978
+ bytes = import_base22.hex.decode(value);
8786
9979
  } catch {
8787
9980
  throw new Error(`covclaimd info: ${field} is not hex`);
8788
9981
  }
@@ -8805,7 +9998,7 @@ var covclaimdClient = (baseUrl, options = {}) => {
8805
9998
  const url = baseUrl.replace(/\/+$/, "");
8806
9999
  const fetchImpl = options.fetchImpl ?? fetch;
8807
10000
  const timeoutMs = options.timeoutMs ?? 3e4;
8808
- (0, import_sdk33.assertTimerMs)("timeoutMs", timeoutMs);
10001
+ (0, import_sdk37.assertTimerMs)("timeoutMs", timeoutMs);
8809
10002
  const send = async (what, path, init) => {
8810
10003
  let response;
8811
10004
  try {
@@ -8843,7 +10036,7 @@ var covclaimdClient = (baseUrl, options = {}) => {
8843
10036
  const body = await readJson("info", response);
8844
10037
  return {
8845
10038
  covclaimdPubkey: decodeKey(body?.covclaimd_pub_key, "covclaimd_pub_key"),
8846
- emulatorPubkey: import_base20.hex.encode(decodeKey(body?.emulator_pub_key, "emulator_pub_key"))
10039
+ emulatorPubkey: import_base22.hex.encode(decodeKey(body?.emulator_pub_key, "emulator_pub_key"))
8847
10040
  };
8848
10041
  },
8849
10042
  async reveal(params) {
@@ -8864,13 +10057,13 @@ function revealFieldsFromScript(script) {
8864
10057
  throw new Error("this covenant has no non-interactive claim leaf to reveal against");
8865
10058
  }
8866
10059
  return {
8867
- arkadeScript: import_base20.base64.encode(script.nonInteractiveClaimArkadeScript),
8868
- taptree: import_base20.hex.encode(script.encode())
10060
+ arkadeScript: import_base22.base64.encode(script.nonInteractiveClaimArkadeScript),
10061
+ taptree: import_base22.hex.encode(script.encode())
8869
10062
  };
8870
10063
  }
8871
10064
  async function revealClaimPacket(client, input) {
8872
10065
  const fields = revealFieldsFromScript(input.script);
8873
- if (import_base20.hex.encode(import_sdk33.ArkAddress.decode(input.address).pkScript) !== import_base20.hex.encode(input.script.pkScript)) {
10066
+ if (import_base22.hex.encode(import_sdk37.ArkAddress.decode(input.address).pkScript) !== import_base22.hex.encode(input.script.pkScript)) {
8874
10067
  throw new Error("address does not belong to this covenant");
8875
10068
  }
8876
10069
  assertPreimageMatches(input.preimage, input.script.options.preimageHash);
@@ -8882,8 +10075,152 @@ async function revealClaimPacket(client, input) {
8882
10075
  return { ciphertext };
8883
10076
  }
8884
10077
 
10078
+ // src/offerFillPlan.ts
10079
+ var import_base23 = require("@scure/base");
10080
+ var import_sdk38 = require("@arkade-os/sdk");
10081
+ init_offer();
10082
+ var OFFER_FILL_TEMPLATE = "offer-fill/1";
10083
+ var OFFER_FILL_OWNERS = [null, "solver", "sponsor"];
10084
+ async function buildOfferFillPlan(wallet, arkServerUrl, offerHex, opts) {
10085
+ const {
10086
+ fund: fund2,
10087
+ payoutScript,
10088
+ fundingTxid,
10089
+ fundingOutpoint,
10090
+ swapAddress,
10091
+ assetCarrierSats = ASSET_CARRIER_SATS,
10092
+ sponsor
10093
+ } = opts;
10094
+ const offer = decodeOffer(import_base23.hex.decode(offerHex));
10095
+ const contract = await connectFillContract(wallet, arkServerUrl, offer, { swapAddress });
10096
+ const vtxos = await contract.getUtxos();
10097
+ const vtxo = resolveDeposit(vtxos, { fundingTxid, fundingOutpoint });
10098
+ const solverPayout = payoutScript ?? import_sdk38.ArkAddress.decode(await wallet.getAddress()).pkScript;
10099
+ const sponsorLeg = sponsor !== void 0 ? normalizeSponsor(sponsor, assetCarrierSats) : void 0;
10100
+ const fill = contract.functions.fulfill();
10101
+ const layout = assembleOfferFill(fill, {
10102
+ offer,
10103
+ vtxo,
10104
+ solverFund: fund2,
10105
+ solverPayout,
10106
+ assetCarrierSats,
10107
+ sponsor: sponsorLeg
10108
+ });
10109
+ const { arkTx, checkpoints } = await fill.build();
10110
+ for (const [i, input] of layout.inputs.entries()) {
10111
+ if (!OFFER_FILL_OWNERS.includes(input.owner)) {
10112
+ throw new Error(`fill plan input ${i} names unknown owner ${input.owner}`);
10113
+ }
10114
+ }
10115
+ return toJointGraph(arkTx, checkpoints, layout, offer.wantAsset?.toString());
10116
+ }
10117
+ function normalizeSponsor(sponsor, assetCarrierSats) {
10118
+ return {
10119
+ fund: sponsor.fund,
10120
+ netContributionSats: sponsor.netContributionSats,
10121
+ fare: sponsor.fare !== void 0 ? {
10122
+ ...sponsor.fare.assetId !== void 0 ? { assetId: sponsor.fare.assetId, amount: sponsor.fare.amount } : {},
10123
+ script: sponsor.fare.script,
10124
+ sats: sponsor.fare.sats ?? assetCarrierSats
10125
+ } : void 0,
10126
+ changeScript: sponsor.changeScript,
10127
+ combineSatsFareWithChange: sponsor.combineSatsFareWithChange
10128
+ };
10129
+ }
10130
+ function toJointGraph(arkTx, checkpoints, layout, wantedAssetId) {
10131
+ if (arkTx.inputsLength !== layout.inputs.length) {
10132
+ throw new Error(
10133
+ `fill plan built ${arkTx.inputsLength} inputs, expected ${layout.inputs.length}`
10134
+ );
10135
+ }
10136
+ if (checkpoints.length !== layout.inputs.length) {
10137
+ throw new Error(
10138
+ `fill plan built ${checkpoints.length} checkpoints, expected ${layout.inputs.length}`
10139
+ );
10140
+ }
10141
+ layout.inputs.forEach((input, i) => {
10142
+ const spent = checkpoints[i].getInput(0);
10143
+ if (!(spent.txid instanceof Uint8Array) || import_base23.hex.encode(spent.txid) !== input.txid || spent.index !== input.vout) {
10144
+ throw new Error(`fill plan checkpoint ${i} does not spend ${input.txid}:${input.vout}`);
10145
+ }
10146
+ });
10147
+ const payments = layout.outputs.length;
10148
+ if (arkTx.outputsLength !== payments + 2) {
10149
+ throw new Error(
10150
+ `fill plan built ${arkTx.outputsLength} outputs, expected ${payments} payments plus extension and anchor`
10151
+ );
10152
+ }
10153
+ layout.outputs.forEach((expected, i) => {
10154
+ const out = arkTx.getOutput(i);
10155
+ if (!out?.script || import_base23.hex.encode(out.script) !== import_base23.hex.encode(expected.script)) {
10156
+ throw new Error(`fill plan output ${i} is not the ${expected.role} script`);
10157
+ }
10158
+ if (out.amount !== expected.sats) {
10159
+ throw new Error(
10160
+ `fill plan output ${i} carries ${out.amount}, expected ${expected.sats}`
10161
+ );
10162
+ }
10163
+ });
10164
+ const ext = arkTx.getOutput(payments);
10165
+ if (!ext?.script || !import_sdk38.Extension.isExtension(ext.script)) {
10166
+ throw new Error(`fill plan output ${payments} is not the extension packet`);
10167
+ }
10168
+ const anchor = arkTx.getOutput(payments + 1);
10169
+ if (!anchor?.script || import_base23.hex.encode(anchor.script) !== import_base23.hex.encode(import_sdk38.P2A.script) || anchor.amount !== import_sdk38.P2A.amount) {
10170
+ throw new Error(`fill plan output ${payments + 1} is not the anchor`);
10171
+ }
10172
+ const packet = import_sdk38.Extension.fromTx(arkTx).getAssetPacket();
10173
+ for (const group of packet?.groups ?? []) {
10174
+ if (group.assetId === null) throw new Error("fill plan carries an issuance group");
10175
+ const assetId = group.assetId.toString();
10176
+ const unitsIn = group.inputs.reduce((s, input) => s + input.amount, BigInt(0));
10177
+ const unitsOut = group.outputs.reduce((s, output) => s + output.amount, BigInt(0));
10178
+ if (unitsIn !== unitsOut) {
10179
+ throw new Error(`fill plan asset ${assetId} mints ${unitsOut - unitsIn} units`);
10180
+ }
10181
+ for (const output of group.outputs) {
10182
+ const hosted = arkTx.getOutput(output.vout);
10183
+ if (output.vout >= payments || !hosted?.script || import_sdk38.Extension.isExtension(hosted.script)) {
10184
+ throw new Error(
10185
+ `fill plan asset ${assetId} pays nonexistent output ${output.vout}`
10186
+ );
10187
+ }
10188
+ }
10189
+ }
10190
+ if (wantedAssetId !== void 0) {
10191
+ if ((packet?.groups.length ?? 0) === 0) {
10192
+ throw new Error(`fill plan carries no asset group, expected ${wantedAssetId}`);
10193
+ }
10194
+ const first = packet?.groups[0].assetId?.toString();
10195
+ if (first !== wantedAssetId) {
10196
+ throw new Error(
10197
+ `fill plan asset group 0 is ${first}, expected the wanted ${wantedAssetId}`
10198
+ );
10199
+ }
10200
+ }
10201
+ const arkTxPsbt = import_base23.base64.encode(arkTx.toPSBT());
10202
+ const checkpointPsbts = checkpoints.map((c) => import_base23.base64.encode(c.toPSBT()));
10203
+ const inputOwners = layout.inputs.map((input) => input.owner);
10204
+ const graph = {
10205
+ arkTx: arkTxPsbt,
10206
+ checkpoints: checkpointPsbts,
10207
+ graphId: digestJointGraph(
10208
+ { arkTx: arkTxPsbt, checkpoints: checkpointPsbts, inputOwners },
10209
+ OFFER_FILL_TEMPLATE
10210
+ ),
10211
+ inputOwners
10212
+ };
10213
+ return deepFreeze(graph);
10214
+ }
10215
+ function verifyOfferFillPlan(plan) {
10216
+ if (!plan || typeof plan !== "object" || !Array.isArray(plan.inputOwners)) return false;
10217
+ const allowed = OFFER_FILL_OWNERS;
10218
+ if (!plan.inputOwners.every((owner) => allowed.includes(owner))) return false;
10219
+ return verifyJointGraph(plan, OFFER_FILL_TEMPLATE);
10220
+ }
10221
+
8885
10222
  // src/evmRfq.ts
8886
- var import_base21 = require("@scure/base");
10223
+ var import_base24 = require("@scure/base");
8887
10224
  init_rfq();
8888
10225
  var EVM_CHAIN = "ethereum";
8889
10226
  var EVM_ADDRESS = /^0x[0-9a-fA-F]{40}$/;
@@ -8948,7 +10285,7 @@ var evmSendRequest = (input) => {
8948
10285
  payment_hash: input.paymentHash,
8949
10286
  evm_claim_address: assertEvmAddress(input.evmClaimAddress, "evmClaimAddress"),
8950
10287
  refund_address: input.refundAddress,
8951
- client_refund_pubkey: import_base21.hex.encode(input.senderPubkey)
10288
+ client_refund_pubkey: import_base24.hex.encode(input.senderPubkey)
8952
10289
  }
8953
10290
  };
8954
10291
  };
@@ -8972,7 +10309,7 @@ var evmReceiveRequest = (input) => {
8972
10309
  evm_timeout_block: input.evmTimeoutBlock,
8973
10310
  evm_refund_address: assertEvmAddress(input.evmRefundAddress, "evmRefundAddress"),
8974
10311
  payout_address: input.payoutAddress,
8975
- payout_pubkey: import_base21.hex.encode(input.payoutPubkey)
10312
+ payout_pubkey: import_base24.hex.encode(input.payoutPubkey)
8976
10313
  }
8977
10314
  };
8978
10315
  };
@@ -9143,6 +10480,8 @@ var readCommonProfile = (profile, paymentHash, chainId) => {
9143
10480
  MaxFeeExceeded,
9144
10481
  MissingCorridorDep,
9145
10482
  NotCancellable,
10483
+ OFFER_FILL_OWNERS,
10484
+ OFFER_FILL_TEMPLATE,
9146
10485
  OFFER_SWAP_ID_PREFIX,
9147
10486
  ONCHAIN_CLAIM_FEE_RATE_SATVB,
9148
10487
  ONCHAIN_DRIVE,
@@ -9169,6 +10508,7 @@ var readCommonProfile = (profile, paymentHash, chainId) => {
9169
10508
  bitcoinNetworkOf,
9170
10509
  btcAssetPart,
9171
10510
  btcOn,
10511
+ buildOfferFillPlan,
9172
10512
  cancelSwap,
9173
10513
  canonicalAssetId,
9174
10514
  cardMarketOf,
@@ -9184,6 +10524,8 @@ var readCommonProfile = (profile, paymentHash, chainId) => {
9184
10524
  createSwapDrive,
9185
10525
  decodeBolt11,
9186
10526
  decodeRfqAmount,
10527
+ deepFreeze,
10528
+ digestJointGraph,
9187
10529
  discoveryIndex,
9188
10530
  eligibleMarkets,
9189
10531
  encodeRfqAmount,
@@ -9209,6 +10551,7 @@ var readCommonProfile = (profile, paymentHash, chainId) => {
9209
10551
  formatAssetId,
9210
10552
  fromAtomicDecimal,
9211
10553
  fromRfqAmountSide,
10554
+ fundingWasNotSubmitted,
9212
10555
  fundsFromWallet,
9213
10556
  instrumentOf,
9214
10557
  isAddressable,
@@ -9274,9 +10617,12 @@ var readCommonProfile = (profile, paymentHash, chainId) => {
9274
10617
  toDiscoveryLeg,
9275
10618
  toRfqAmountSide,
9276
10619
  toSafeNumber,
10620
+ unsignedPsbtBytes,
9277
10621
  usableMarkets,
9278
10622
  verifiedCarrierSats,
9279
10623
  verifyCrossAssetAmount,
10624
+ verifyJointGraph,
10625
+ verifyOfferFillPlan,
9280
10626
  verifyPair,
9281
10627
  verifyPlanLegs,
9282
10628
  verifyQuoteTtl,