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