@arkade-os/swap 0.1.0-rc.2 → 0.1.0-rc.21
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 +52 -2
- package/dist/advanced.cjs +8376 -0
- package/dist/advanced.d.cts +550 -0
- package/dist/advanced.d.ts +550 -0
- package/dist/advanced.js +451 -0
- package/dist/chunk-A3SHHRX4.js +104 -0
- package/dist/chunk-HUQQVBC4.js +4262 -0
- package/dist/{chunk-EOYGUCDM.js → chunk-ITFCQWPG.js} +755 -1382
- package/dist/chunk-PVB7EBAM.js +2517 -0
- package/dist/errors-C3h8ANmE.d.ts +1560 -0
- package/dist/errors-hm7aqnRM.d.cts +1560 -0
- package/dist/index.cjs +4861 -3988
- package/dist/index.d.cts +69 -2812
- package/dist/index.d.ts +69 -2812
- package/dist/index.js +179 -3719
- package/dist/lockupContract-5r5RlgOJ.d.cts +137 -0
- package/dist/lockupContract-5r5RlgOJ.d.ts +137 -0
- package/dist/node/index.cjs +61 -10
- package/dist/node/index.d.cts +249 -591
- package/dist/node/index.d.ts +249 -591
- package/dist/node/index.js +65 -10
- package/dist/nostr.cjs +191 -11
- package/dist/nostr.d.cts +23 -68
- package/dist/nostr.d.ts +23 -68
- package/dist/nostr.js +3 -4
- package/dist/offer-Bd9Yvd8Z.d.ts +261 -0
- package/dist/offer-F88rtL_I.d.cts +261 -0
- package/dist/protocol.cjs +4086 -3706
- package/dist/protocol.d.cts +163 -768
- package/dist/protocol.d.ts +163 -768
- package/dist/protocol.js +190 -173
- 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-BuYWGAKz.d.cts +2261 -0
- package/dist/repository-DYnRLPt-.d.ts +2261 -0
- package/dist/rfq-60PGpQ_x.d.cts +950 -0
- package/dist/rfq-60PGpQ_x.d.ts +950 -0
- package/dist/watch-BTyiBLSd.d.ts +74 -0
- package/dist/watch-M_KY-5ho.d.cts +74 -0
- package/package.json +20 -10
- package/dist/chunk-LYCMM3VB.js +0 -1357
- package/dist/chunk-U7VWWTL6.js +0 -66
- package/dist/repository-_zU9_pM3.d.cts +0 -3426
- package/dist/repository-kO95noyv.d.ts +0 -3426
- package/dist/rfq-DdBV4JO5.d.cts +0 -1097
- package/dist/rfq-DdBV4JO5.d.ts +0 -1097
- package/dist/watch-CQqvwgwY.d.cts +0 -96
- package/dist/watch-wMbmfN4p.d.ts +0 -96
|
@@ -0,0 +1,4262 @@
|
|
|
1
|
+
import {
|
|
2
|
+
LOCKUP_OWNER,
|
|
3
|
+
LockupNeedsRecoveryError,
|
|
4
|
+
MARKETS_CACHE_TTL_MS,
|
|
5
|
+
PAYMENT_HASH,
|
|
6
|
+
QUOTE_OPTIONS,
|
|
7
|
+
RefundNotLocallyPossibleError,
|
|
8
|
+
RfqSwapManager,
|
|
9
|
+
arkadeRefunder,
|
|
10
|
+
classifyDepositSpend,
|
|
11
|
+
corridorOutcome,
|
|
12
|
+
findLockupVtxos,
|
|
13
|
+
isRfqConfigurationRefusal,
|
|
14
|
+
isRfqSwapTerminal,
|
|
15
|
+
lightningCorridor,
|
|
16
|
+
makeCachedFeedFetch,
|
|
17
|
+
marketAssetId,
|
|
18
|
+
marketCorridor,
|
|
19
|
+
marketPairLabel,
|
|
20
|
+
normalizeRfqSwapRecord,
|
|
21
|
+
offerOutcome,
|
|
22
|
+
onchainCorridor,
|
|
23
|
+
onchainSendProfile,
|
|
24
|
+
pushClaim,
|
|
25
|
+
readsChain,
|
|
26
|
+
rebuildRfqSwap,
|
|
27
|
+
recordOutcome,
|
|
28
|
+
restoreAssetSwaps,
|
|
29
|
+
rfqClaimDestinationOf,
|
|
30
|
+
rfqClaimSecretOf,
|
|
31
|
+
rfqSecretsProfile,
|
|
32
|
+
rfqSignerOf,
|
|
33
|
+
rfqSwapOriginOf,
|
|
34
|
+
senderIdentityForSwapRecord,
|
|
35
|
+
spendTxidsOf,
|
|
36
|
+
toRestoreTx,
|
|
37
|
+
walletOperator,
|
|
38
|
+
watchOfferSwaps
|
|
39
|
+
} from "./chunk-ITFCQWPG.js";
|
|
40
|
+
import {
|
|
41
|
+
ARKADE_BTC,
|
|
42
|
+
ASSET_CARRIER_SATS,
|
|
43
|
+
AddressMismatch,
|
|
44
|
+
BTC_ASSET_ID,
|
|
45
|
+
L1_NETWORKS,
|
|
46
|
+
LIGHTNING_BTC,
|
|
47
|
+
LockupContractMissing,
|
|
48
|
+
NoSpendableDepositError,
|
|
49
|
+
OFFER_PACKET_TYPE,
|
|
50
|
+
ONCHAIN_BTC,
|
|
51
|
+
ONCHAIN_CLAIM_VSIZE,
|
|
52
|
+
ONCHAIN_DUST_SATS,
|
|
53
|
+
OfferCovenantMismatchError,
|
|
54
|
+
RETIRABLE,
|
|
55
|
+
SwapRefusal,
|
|
56
|
+
arkadeSwapRequest,
|
|
57
|
+
assertFundable,
|
|
58
|
+
assertPairLength,
|
|
59
|
+
assertReceivable,
|
|
60
|
+
claimOnchainFill,
|
|
61
|
+
createOffer,
|
|
62
|
+
decodeOffer,
|
|
63
|
+
deriveLightningReceive,
|
|
64
|
+
deriveLightningSend,
|
|
65
|
+
deriveOffer,
|
|
66
|
+
deriveOnchainSend,
|
|
67
|
+
l1NetworkFromArk,
|
|
68
|
+
l1ScriptForAddress,
|
|
69
|
+
lightningReceiveRequest,
|
|
70
|
+
lightningSendRequest,
|
|
71
|
+
lockupContractParams,
|
|
72
|
+
newRfqId,
|
|
73
|
+
offerTermsFromQuote,
|
|
74
|
+
onchainSendRequest,
|
|
75
|
+
preimageForSwapRecord,
|
|
76
|
+
prepareOfferCancel,
|
|
77
|
+
quoteCarrierSats,
|
|
78
|
+
registerDerivedOffer,
|
|
79
|
+
registerLockupContract,
|
|
80
|
+
restoreOfferCoverage,
|
|
81
|
+
retireOfferContract,
|
|
82
|
+
retireSettledOfferContracts,
|
|
83
|
+
rfqPair,
|
|
84
|
+
sealClaimPacket,
|
|
85
|
+
unilateralClaimDelay,
|
|
86
|
+
verifyOfferAddress
|
|
87
|
+
} from "./chunk-PVB7EBAM.js";
|
|
88
|
+
import {
|
|
89
|
+
assertRfqSwapPageFilter,
|
|
90
|
+
collectAssetSwaps,
|
|
91
|
+
collectRfqSwaps,
|
|
92
|
+
collectSwapRecords
|
|
93
|
+
} from "./chunk-A3SHHRX4.js";
|
|
94
|
+
|
|
95
|
+
// src/client/assetId.ts
|
|
96
|
+
import { asset, networks } from "@arkade-os/sdk";
|
|
97
|
+
var RAILS = ["arkade", "bitcoin", "bolt11", "eip155"];
|
|
98
|
+
var BITCOIN_RAILS = ["arkade", "bitcoin", "bolt11"];
|
|
99
|
+
var BTC_ASSET_PART = "slip44:0";
|
|
100
|
+
var ARKADE_ASSET_NAMESPACE = "asset";
|
|
101
|
+
var AssetIdError = class extends Error {
|
|
102
|
+
reason;
|
|
103
|
+
value;
|
|
104
|
+
constructor(reason, value, detail, options) {
|
|
105
|
+
super(`invalid asset id ${JSON.stringify(value)}: ${detail}`, options);
|
|
106
|
+
this.name = "AssetIdError";
|
|
107
|
+
this.reason = reason;
|
|
108
|
+
this.value = value;
|
|
109
|
+
}
|
|
110
|
+
};
|
|
111
|
+
var REFERENCE_RULE = {
|
|
112
|
+
slip44: /^(0|[1-9][0-9]{0,9})$/,
|
|
113
|
+
/** The 68-lowercase-hex identity form; `asset.AssetId` then re-validates it. */
|
|
114
|
+
asset: /^[0-9a-f]{68}$/,
|
|
115
|
+
/**
|
|
116
|
+
* Reserved for §9. Lowercase, never EIP-55: mixed case would be two spellings of one asset
|
|
117
|
+
* comparing unequal in a pair string, a record and a cache key.
|
|
118
|
+
*/
|
|
119
|
+
erc20: /^0x[0-9a-f]{40}$/
|
|
120
|
+
};
|
|
121
|
+
var CHAIN_REFERENCE = /^[-_a-z0-9]{1,32}$/;
|
|
122
|
+
var CHAIN_ID = /^(0|[1-9][0-9]*)$/;
|
|
123
|
+
var ASSET_REFERENCE = /^[-.%a-z0-9]{1,128}$/;
|
|
124
|
+
var isRail = (value) => RAILS.includes(value);
|
|
125
|
+
var isNetworkRef = (value) => Object.hasOwn(networks, value);
|
|
126
|
+
var parseAssetId = (value) => {
|
|
127
|
+
if (/[A-Z]/.test(value)) {
|
|
128
|
+
throw new AssetIdError(
|
|
129
|
+
"uppercase",
|
|
130
|
+
value,
|
|
131
|
+
"ids are lowercase throughout \u2014 lowercase an EIP-55 reference before it becomes one"
|
|
132
|
+
);
|
|
133
|
+
}
|
|
134
|
+
const slash = value.indexOf("/");
|
|
135
|
+
if (slash < 0) {
|
|
136
|
+
throw new AssetIdError("malformed", value, "expected <rail>:<network>/<asset-ns>:<ref>");
|
|
137
|
+
}
|
|
138
|
+
if (value.indexOf("/", slash + 1) >= 0) {
|
|
139
|
+
throw new AssetIdError(
|
|
140
|
+
"token_id_unsupported",
|
|
141
|
+
value,
|
|
142
|
+
"a CAIP-19 token id has no meaning here"
|
|
143
|
+
);
|
|
144
|
+
}
|
|
145
|
+
const chain = value.slice(0, slash);
|
|
146
|
+
const assetPart = value.slice(slash + 1);
|
|
147
|
+
const chainColon = chain.indexOf(":");
|
|
148
|
+
const assetColon = assetPart.indexOf(":");
|
|
149
|
+
if (chainColon < 0 || assetColon < 0) {
|
|
150
|
+
throw new AssetIdError("malformed", value, "expected <rail>:<network>/<asset-ns>:<ref>");
|
|
151
|
+
}
|
|
152
|
+
const rail = chain.slice(0, chainColon);
|
|
153
|
+
const reference = chain.slice(chainColon + 1);
|
|
154
|
+
const assetNamespace = assetPart.slice(0, assetColon);
|
|
155
|
+
const assetReference = assetPart.slice(assetColon + 1);
|
|
156
|
+
if (!isRail(rail)) {
|
|
157
|
+
throw new AssetIdError("unknown_rail", value, `no rail named ${JSON.stringify(rail)}`);
|
|
158
|
+
}
|
|
159
|
+
if (!CHAIN_REFERENCE.test(reference)) {
|
|
160
|
+
throw new AssetIdError("malformed", value, "the chain reference is not CAIP-2 shaped");
|
|
161
|
+
}
|
|
162
|
+
if (rail === "eip155") {
|
|
163
|
+
if (!CHAIN_ID.test(reference)) {
|
|
164
|
+
throw new AssetIdError("invalid_chain_id", value, "eip155 takes a decimal chain id");
|
|
165
|
+
}
|
|
166
|
+
} else if (!isNetworkRef(reference)) {
|
|
167
|
+
throw new AssetIdError(
|
|
168
|
+
"unknown_network",
|
|
169
|
+
value,
|
|
170
|
+
`no bitcoin network named ${JSON.stringify(reference)}`
|
|
171
|
+
);
|
|
172
|
+
}
|
|
173
|
+
if (!Object.hasOwn(REFERENCE_RULE, assetNamespace)) {
|
|
174
|
+
throw new AssetIdError(
|
|
175
|
+
"unknown_asset_namespace",
|
|
176
|
+
value,
|
|
177
|
+
`no asset namespace named ${JSON.stringify(assetNamespace)}`
|
|
178
|
+
);
|
|
179
|
+
}
|
|
180
|
+
const namespace = assetNamespace;
|
|
181
|
+
if (!ASSET_REFERENCE.test(assetReference) || !REFERENCE_RULE[namespace].test(assetReference)) {
|
|
182
|
+
throw new AssetIdError(
|
|
183
|
+
"invalid_asset_reference",
|
|
184
|
+
value,
|
|
185
|
+
`${namespace} takes no reference ${JSON.stringify(assetReference)}`
|
|
186
|
+
);
|
|
187
|
+
}
|
|
188
|
+
if (namespace === ARKADE_ASSET_NAMESPACE) {
|
|
189
|
+
try {
|
|
190
|
+
asset.AssetId.fromString(assetReference);
|
|
191
|
+
} catch (cause) {
|
|
192
|
+
throw new AssetIdError(
|
|
193
|
+
"invalid_asset_reference",
|
|
194
|
+
value,
|
|
195
|
+
"core refuses that issuance identity",
|
|
196
|
+
{ cause }
|
|
197
|
+
);
|
|
198
|
+
}
|
|
199
|
+
}
|
|
200
|
+
return { rail, reference, assetNamespace: namespace, assetReference };
|
|
201
|
+
};
|
|
202
|
+
var isAssetId = (value) => {
|
|
203
|
+
try {
|
|
204
|
+
parseAssetId(value);
|
|
205
|
+
return true;
|
|
206
|
+
} catch {
|
|
207
|
+
return false;
|
|
208
|
+
}
|
|
209
|
+
};
|
|
210
|
+
var formatAssetId = (parts) => {
|
|
211
|
+
const id = `${parts.rail}:${parts.reference}/${parts.assetNamespace}:${parts.assetReference}`;
|
|
212
|
+
parseAssetId(id);
|
|
213
|
+
return id;
|
|
214
|
+
};
|
|
215
|
+
var railOf = (id) => parseAssetId(id).rail;
|
|
216
|
+
var bitcoinNetworkOf = (id) => {
|
|
217
|
+
const { rail, reference } = parseAssetId(id);
|
|
218
|
+
return rail === "eip155" ? void 0 : reference;
|
|
219
|
+
};
|
|
220
|
+
var assetPartOf = (id) => {
|
|
221
|
+
const { assetNamespace, assetReference } = parseAssetId(id);
|
|
222
|
+
return `${assetNamespace}:${assetReference}`;
|
|
223
|
+
};
|
|
224
|
+
var sameAsset = (a, b) => {
|
|
225
|
+
const left = parseAssetId(a);
|
|
226
|
+
const right = parseAssetId(b);
|
|
227
|
+
return left.reference === right.reference && left.assetNamespace === right.assetNamespace && left.assetReference === right.assetReference;
|
|
228
|
+
};
|
|
229
|
+
var btcAssetPart = (network) => network === "bitcoin" ? "slip44:0" : "slip44:1";
|
|
230
|
+
var btcOn = (rail, network) => (
|
|
231
|
+
// TS won't resolve the conditional against an unbound `R`; the cast stays in this expression.
|
|
232
|
+
`${rail}:${network}/${btcAssetPart(network)}`
|
|
233
|
+
);
|
|
234
|
+
var isBtcAsset = (id) => {
|
|
235
|
+
const { rail, reference, assetNamespace, assetReference } = parseAssetId(id);
|
|
236
|
+
return rail !== "eip155" && `${assetNamespace}:${assetReference}` === btcAssetPart(reference);
|
|
237
|
+
};
|
|
238
|
+
var isBtcAssetLenient = (id) => {
|
|
239
|
+
if (isBtcAsset(id)) return true;
|
|
240
|
+
const { rail, assetNamespace, assetReference } = parseAssetId(id);
|
|
241
|
+
return rail !== "eip155" && assetNamespace === "slip44" && assetReference === "0";
|
|
242
|
+
};
|
|
243
|
+
var arkadeAsset = (network, id) => `arkade:${network}/${ARKADE_ASSET_NAMESPACE}:${id.toString()}`;
|
|
244
|
+
var issuanceOf = (id) => {
|
|
245
|
+
const { assetNamespace, assetReference } = parseAssetId(id);
|
|
246
|
+
return assetNamespace === ARKADE_ASSET_NAMESPACE ? asset.AssetId.fromString(assetReference) : void 0;
|
|
247
|
+
};
|
|
248
|
+
|
|
249
|
+
// src/client/errors.ts
|
|
250
|
+
var AmbiguousDestination = class extends Error {
|
|
251
|
+
constructor(destination, detail) {
|
|
252
|
+
super(`cannot route ${JSON.stringify(destination)}: ${detail}`);
|
|
253
|
+
this.destination = destination;
|
|
254
|
+
}
|
|
255
|
+
destination;
|
|
256
|
+
name = "AmbiguousDestination";
|
|
257
|
+
};
|
|
258
|
+
var UnsupportedRoute = class extends Error {
|
|
259
|
+
name = "UnsupportedRoute";
|
|
260
|
+
give;
|
|
261
|
+
take;
|
|
262
|
+
constructor(detail, corridors = {}) {
|
|
263
|
+
super(`unsupported route: ${detail}`);
|
|
264
|
+
this.give = corridors.give;
|
|
265
|
+
this.take = corridors.take;
|
|
266
|
+
}
|
|
267
|
+
};
|
|
268
|
+
var DiscoverySnapshotUnavailable = class extends Error {
|
|
269
|
+
constructor(network, detail) {
|
|
270
|
+
super(`cannot resolve on ${network} offline: ${detail}`);
|
|
271
|
+
this.network = network;
|
|
272
|
+
}
|
|
273
|
+
network;
|
|
274
|
+
name = "DiscoverySnapshotUnavailable";
|
|
275
|
+
};
|
|
276
|
+
var AmountMismatch = class extends Error {
|
|
277
|
+
constructor(sources) {
|
|
278
|
+
super(`exactly one amount may be pinned; got ${sources[0]} and ${sources[1]}`);
|
|
279
|
+
this.sources = sources;
|
|
280
|
+
}
|
|
281
|
+
sources;
|
|
282
|
+
name = "AmountMismatch";
|
|
283
|
+
};
|
|
284
|
+
var AmountEncodingUnsupported = class extends Error {
|
|
285
|
+
constructor(field, value, detail, options) {
|
|
286
|
+
super(`${field}: ${detail}`, options);
|
|
287
|
+
this.field = field;
|
|
288
|
+
this.value = value;
|
|
289
|
+
}
|
|
290
|
+
field;
|
|
291
|
+
value;
|
|
292
|
+
name = "AmountEncodingUnsupported";
|
|
293
|
+
};
|
|
294
|
+
var QuoteVerificationFailed = class extends Error {
|
|
295
|
+
constructor(check, expected, actual, options) {
|
|
296
|
+
super(`quote failed the ${check} check \u2014 refusing to fund`, options);
|
|
297
|
+
this.check = check;
|
|
298
|
+
this.expected = expected;
|
|
299
|
+
this.actual = actual;
|
|
300
|
+
}
|
|
301
|
+
check;
|
|
302
|
+
name = "QuoteVerificationFailed";
|
|
303
|
+
expected;
|
|
304
|
+
actual;
|
|
305
|
+
};
|
|
306
|
+
var QuoteExpired = class extends Error {
|
|
307
|
+
constructor(quoteId, expiresAt, now) {
|
|
308
|
+
super(`quote ${quoteId} expired at ${expiresAt}, ${now - expiresAt} ago`);
|
|
309
|
+
this.quoteId = quoteId;
|
|
310
|
+
this.expiresAt = expiresAt;
|
|
311
|
+
this.now = now;
|
|
312
|
+
}
|
|
313
|
+
quoteId;
|
|
314
|
+
expiresAt;
|
|
315
|
+
now;
|
|
316
|
+
name = "QuoteExpired";
|
|
317
|
+
};
|
|
318
|
+
var MaxFeeExceeded = class extends Error {
|
|
319
|
+
constructor(quoteId, asset5, fee, maxFee) {
|
|
320
|
+
super(`fee ${fee} of ${asset5} exceeds the ${maxFee} ceiling`);
|
|
321
|
+
this.quoteId = quoteId;
|
|
322
|
+
this.asset = asset5;
|
|
323
|
+
this.fee = fee;
|
|
324
|
+
this.maxFee = maxFee;
|
|
325
|
+
}
|
|
326
|
+
quoteId;
|
|
327
|
+
asset;
|
|
328
|
+
fee;
|
|
329
|
+
maxFee;
|
|
330
|
+
name = "MaxFeeExceeded";
|
|
331
|
+
};
|
|
332
|
+
var InsufficientFunds = class extends Error {
|
|
333
|
+
constructor(asset5, required, available) {
|
|
334
|
+
super(
|
|
335
|
+
`funding needs ${required} of ${asset5}` + (available === void 0 ? "" : `, wallet holds ${available}`)
|
|
336
|
+
);
|
|
337
|
+
this.asset = asset5;
|
|
338
|
+
this.required = required;
|
|
339
|
+
this.available = available;
|
|
340
|
+
}
|
|
341
|
+
asset;
|
|
342
|
+
required;
|
|
343
|
+
name = "InsufficientFunds";
|
|
344
|
+
available;
|
|
345
|
+
};
|
|
346
|
+
var AcceptConflict = class extends Error {
|
|
347
|
+
constructor(quoteId, swapId, fields) {
|
|
348
|
+
super(`accept ${quoteId} conflicts with swap ${swapId} on ${fields.join(", ")}`);
|
|
349
|
+
this.quoteId = quoteId;
|
|
350
|
+
this.swapId = swapId;
|
|
351
|
+
this.fields = fields;
|
|
352
|
+
}
|
|
353
|
+
quoteId;
|
|
354
|
+
swapId;
|
|
355
|
+
fields;
|
|
356
|
+
name = "AcceptConflict";
|
|
357
|
+
};
|
|
358
|
+
var ClientDisposed = class extends Error {
|
|
359
|
+
constructor(method) {
|
|
360
|
+
super(`${method}() called after the client was disposed`);
|
|
361
|
+
this.method = method;
|
|
362
|
+
}
|
|
363
|
+
method;
|
|
364
|
+
name = "ClientDisposed";
|
|
365
|
+
};
|
|
366
|
+
var NotCancellable = class extends Error {
|
|
367
|
+
constructor(swapId) {
|
|
368
|
+
super(`swap ${swapId} is not a cancellable asset swap`);
|
|
369
|
+
this.swapId = swapId;
|
|
370
|
+
}
|
|
371
|
+
swapId;
|
|
372
|
+
name = "NotCancellable";
|
|
373
|
+
};
|
|
374
|
+
var InconsistentRoute = class extends Error {
|
|
375
|
+
constructor(asset5, destination) {
|
|
376
|
+
super(`destination ${JSON.stringify(destination)} is not on ${asset5}'s chain`);
|
|
377
|
+
this.asset = asset5;
|
|
378
|
+
this.destination = destination;
|
|
379
|
+
}
|
|
380
|
+
asset;
|
|
381
|
+
destination;
|
|
382
|
+
name = "InconsistentRoute";
|
|
383
|
+
};
|
|
384
|
+
var OperatorUnreachable = class extends Error {
|
|
385
|
+
name = "OperatorUnreachable";
|
|
386
|
+
constructor(detail, options) {
|
|
387
|
+
super(`cannot derive a covenant: ${detail}`, options);
|
|
388
|
+
}
|
|
389
|
+
};
|
|
390
|
+
var MissingCorridorDep = class extends Error {
|
|
391
|
+
constructor(corridor, dep) {
|
|
392
|
+
super(`the ${corridor} corridor has no ${dep}`);
|
|
393
|
+
this.corridor = corridor;
|
|
394
|
+
this.dep = dep;
|
|
395
|
+
}
|
|
396
|
+
corridor;
|
|
397
|
+
dep;
|
|
398
|
+
name = "MissingCorridorDep";
|
|
399
|
+
};
|
|
400
|
+
var SWAP_ERRORS = {
|
|
401
|
+
AmbiguousDestination,
|
|
402
|
+
UnsupportedRoute,
|
|
403
|
+
DiscoverySnapshotUnavailable,
|
|
404
|
+
AmountMismatch,
|
|
405
|
+
AmountEncodingUnsupported,
|
|
406
|
+
QuoteVerificationFailed,
|
|
407
|
+
SwapRefusal,
|
|
408
|
+
QuoteExpired,
|
|
409
|
+
MaxFeeExceeded,
|
|
410
|
+
InsufficientFunds,
|
|
411
|
+
AcceptConflict,
|
|
412
|
+
ClientDisposed,
|
|
413
|
+
NotCancellable,
|
|
414
|
+
InconsistentRoute,
|
|
415
|
+
OperatorUnreachable,
|
|
416
|
+
MissingCorridorDep
|
|
417
|
+
};
|
|
418
|
+
var SWAP_ERROR_NAMES = Object.keys(SWAP_ERRORS);
|
|
419
|
+
function isSwapError(e, name) {
|
|
420
|
+
if (!(e instanceof Error)) return false;
|
|
421
|
+
const table = SWAP_ERRORS;
|
|
422
|
+
const ctor = table[e.name];
|
|
423
|
+
if (ctor === void 0 || !(e instanceof ctor)) return false;
|
|
424
|
+
return name === void 0 || e.name === name;
|
|
425
|
+
}
|
|
426
|
+
|
|
427
|
+
// src/client/aliases.ts
|
|
428
|
+
import { NETWORKS, isNetwork } from "@arkade-os/solver-discovery";
|
|
429
|
+
var toDiscoveryLeg = (id) => {
|
|
430
|
+
const { rail, reference, assetNamespace, assetReference } = parseAssetId(id);
|
|
431
|
+
const asset5 = `${assetNamespace}:${assetReference}`;
|
|
432
|
+
const isBtc = isBtcAsset(id);
|
|
433
|
+
if (!isBtc && rail !== "eip155" && (asset5 === "slip44:0" || asset5 === "slip44:1")) {
|
|
434
|
+
const expected = btcOn(rail, reference);
|
|
435
|
+
throw new UnsupportedRoute(`${id} is not BTC on ${reference}: BTC there is ${expected}`);
|
|
436
|
+
}
|
|
437
|
+
if (rail === "arkade") {
|
|
438
|
+
if (isBtc) return { corridor: "arkade", assetId: BTC_ASSET_ID, marketId: id };
|
|
439
|
+
if (assetNamespace === ARKADE_ASSET_NAMESPACE) {
|
|
440
|
+
return { corridor: "arkade", assetId: assetReference, marketId: id };
|
|
441
|
+
}
|
|
442
|
+
throw new UnsupportedRoute(`the arkade corridor has no ${asset5}`);
|
|
443
|
+
}
|
|
444
|
+
if (rail === "bolt11") {
|
|
445
|
+
if (isBtc) return { corridor: "lightning", assetId: BTC_ASSET_ID, marketId: id };
|
|
446
|
+
throw new UnsupportedRoute(`the lightning corridor carries BTC only, not ${asset5}`);
|
|
447
|
+
}
|
|
448
|
+
if (rail === "bitcoin") {
|
|
449
|
+
if (isBtc) return { corridor: "onchain", assetId: BTC_ASSET_ID, marketId: id };
|
|
450
|
+
throw new UnsupportedRoute(`the onchain corridor carries BTC only, not ${asset5}`);
|
|
451
|
+
}
|
|
452
|
+
throw new UnsupportedRoute(`no corridor serves ${id}`);
|
|
453
|
+
};
|
|
454
|
+
var INDEXED_NETWORKS = NETWORKS;
|
|
455
|
+
var isIndexedNetwork = (network) => isNetwork(network);
|
|
456
|
+
var networkOfRow = (row) => parseAssetId(row.id).reference;
|
|
457
|
+
var canonicalAssetId = (input, table) => {
|
|
458
|
+
if (isAssetId(input)) return input;
|
|
459
|
+
const wanted = input.trim().toLowerCase();
|
|
460
|
+
const matches = table.assets.filter(
|
|
461
|
+
(row) => row.ticker.toLowerCase() === wanted && networkOfRow(row) === table.network
|
|
462
|
+
);
|
|
463
|
+
if (matches.length === 0) {
|
|
464
|
+
throw new AssetIdError(
|
|
465
|
+
"unknown_alias",
|
|
466
|
+
input,
|
|
467
|
+
`no asset with that ticker on ${table.network}`
|
|
468
|
+
);
|
|
469
|
+
}
|
|
470
|
+
const distinct = new Set(matches.map((row) => row.id));
|
|
471
|
+
if (distinct.size > 1) {
|
|
472
|
+
throw new AssetIdError(
|
|
473
|
+
"ambiguous_alias",
|
|
474
|
+
input,
|
|
475
|
+
`${distinct.size} assets on ${table.network} answer to that ticker: ${[...distinct].join(", ")}`
|
|
476
|
+
);
|
|
477
|
+
}
|
|
478
|
+
return matches[0].id;
|
|
479
|
+
};
|
|
480
|
+
|
|
481
|
+
// src/client/amount.ts
|
|
482
|
+
import {
|
|
483
|
+
AMOUNT_PATTERN,
|
|
484
|
+
MAX_ASSET_DECIMALS,
|
|
485
|
+
fromAtomic,
|
|
486
|
+
isAmount,
|
|
487
|
+
toAtomic
|
|
488
|
+
} from "@arkade-os/solver-discovery";
|
|
489
|
+
var AmountFormatError = class extends Error {
|
|
490
|
+
constructor(reason, message) {
|
|
491
|
+
super(message);
|
|
492
|
+
this.reason = reason;
|
|
493
|
+
}
|
|
494
|
+
reason;
|
|
495
|
+
name = "AmountFormatError";
|
|
496
|
+
};
|
|
497
|
+
var SCALED_DECIMAL = /^([0-9]+)(?:\.([0-9]+))?$/;
|
|
498
|
+
var ATOMIC_CEILING = 10n ** 30n;
|
|
499
|
+
var MAX_SIGNIFICANT_DIGITS = 64;
|
|
500
|
+
var assertDecimals = (decimals) => {
|
|
501
|
+
if (!Number.isInteger(decimals) || decimals < 0 || decimals > MAX_ASSET_DECIMALS) {
|
|
502
|
+
throw new AmountFormatError(
|
|
503
|
+
"invalid_decimals",
|
|
504
|
+
`decimals must be an integer in [0, ${MAX_ASSET_DECIMALS}], got ${decimals}`
|
|
505
|
+
);
|
|
506
|
+
}
|
|
507
|
+
};
|
|
508
|
+
var assertRepresentable = (value, what) => {
|
|
509
|
+
if (value >= ATOMIC_CEILING) {
|
|
510
|
+
throw new AmountFormatError(
|
|
511
|
+
"too_large",
|
|
512
|
+
`${what} does not fit the canonical 30-digit encoding`
|
|
513
|
+
);
|
|
514
|
+
}
|
|
515
|
+
};
|
|
516
|
+
var Amount = {
|
|
517
|
+
/**
|
|
518
|
+
* A human decimal into atomic units.
|
|
519
|
+
*
|
|
520
|
+
* `string` only, no exponent: a `number` makes `100000` ambiguous between sats and BTC, and the
|
|
521
|
+
* ambiguity resolves only after funding. Refuses rather than rounds input finer than the asset
|
|
522
|
+
* (a truncated amount is a swap for the wrong size), and refuses results that would not survive
|
|
523
|
+
* the record boundary.
|
|
524
|
+
*/
|
|
525
|
+
parse(display, asset5) {
|
|
526
|
+
assertDecimals(asset5.decimals);
|
|
527
|
+
const parts = SCALED_DECIMAL.exec(display);
|
|
528
|
+
if (!parts) {
|
|
529
|
+
throw new AmountFormatError(
|
|
530
|
+
"not_decimal",
|
|
531
|
+
`not an unsigned decimal amount: ${JSON.stringify(display)} (write 0.5, not .5; no sign, exponent, separator or space)`
|
|
532
|
+
);
|
|
533
|
+
}
|
|
534
|
+
const [, whole, fraction = ""] = parts;
|
|
535
|
+
if (fraction.length > asset5.decimals) {
|
|
536
|
+
throw new AmountFormatError(
|
|
537
|
+
"too_precise",
|
|
538
|
+
`${display} has more precision than ${asset5.decimals} decimals allow`
|
|
539
|
+
);
|
|
540
|
+
}
|
|
541
|
+
if (whole.length + fraction.length > MAX_SIGNIFICANT_DIGITS) {
|
|
542
|
+
throw new AmountFormatError("too_large", `${display} has too many digits`);
|
|
543
|
+
}
|
|
544
|
+
const value = toAtomic(display, asset5.decimals);
|
|
545
|
+
assertRepresentable(value, `${display} at ${asset5.decimals} decimals`);
|
|
546
|
+
return value;
|
|
547
|
+
},
|
|
548
|
+
/** Atomic units into a human decimal, trailing zeros trimmed. Refuses a negative: every amount
|
|
549
|
+
* here is an obligation, so a negative one is an upstream defect. */
|
|
550
|
+
format(value, asset5) {
|
|
551
|
+
assertDecimals(asset5.decimals);
|
|
552
|
+
if (value < 0n) {
|
|
553
|
+
throw new AmountFormatError("negative", `amount must be non-negative, got ${value}`);
|
|
554
|
+
}
|
|
555
|
+
assertRepresentable(value, `${value}`);
|
|
556
|
+
return fromAtomic(value, asset5.decimals);
|
|
557
|
+
}
|
|
558
|
+
};
|
|
559
|
+
var toAtomicDecimal = (value) => {
|
|
560
|
+
if (value < 0n) {
|
|
561
|
+
throw new AmountFormatError("negative", `amount must be non-negative, got ${value}`);
|
|
562
|
+
}
|
|
563
|
+
assertRepresentable(value, `${value}`);
|
|
564
|
+
return value.toString();
|
|
565
|
+
};
|
|
566
|
+
var fromAtomicDecimal = (text) => {
|
|
567
|
+
if (!isAmount(text)) {
|
|
568
|
+
throw new AmountFormatError(
|
|
569
|
+
"not_canonical",
|
|
570
|
+
`not a canonical atomic amount: ${JSON.stringify(text)}`
|
|
571
|
+
);
|
|
572
|
+
}
|
|
573
|
+
return BigInt(text);
|
|
574
|
+
};
|
|
575
|
+
var isAtomicDecimal = (value) => typeof value === "string" && AMOUNT_PATTERN.test(value);
|
|
576
|
+
|
|
577
|
+
// src/client/rfqAmount.ts
|
|
578
|
+
import { isAmount as isAmount2 } from "@arkade-os/solver-discovery";
|
|
579
|
+
var toRfqAmountSide = (on) => on === "give" ? "from" : "to";
|
|
580
|
+
var fromRfqAmountSide = (side) => side === "from" ? "give" : "take";
|
|
581
|
+
var encodeRfqAmount = (value, field) => {
|
|
582
|
+
try {
|
|
583
|
+
return toAtomicDecimal(value);
|
|
584
|
+
} catch (cause) {
|
|
585
|
+
throw new AmountEncodingUnsupported(
|
|
586
|
+
field,
|
|
587
|
+
`${value}`,
|
|
588
|
+
"the wire's canonical encoding cannot carry it",
|
|
589
|
+
{ cause }
|
|
590
|
+
);
|
|
591
|
+
}
|
|
592
|
+
};
|
|
593
|
+
var decodeRfqAmount = (raw, field) => {
|
|
594
|
+
if (typeof raw === "string") {
|
|
595
|
+
if (!isAmount2(raw)) {
|
|
596
|
+
throw new AmountEncodingUnsupported(
|
|
597
|
+
field,
|
|
598
|
+
raw,
|
|
599
|
+
"not a canonical decimal amount (unsigned, no leading zeros, 30 digits)"
|
|
600
|
+
);
|
|
601
|
+
}
|
|
602
|
+
return BigInt(raw);
|
|
603
|
+
}
|
|
604
|
+
if (typeof raw === "number") {
|
|
605
|
+
if (!Number.isSafeInteger(raw) || raw < 0) {
|
|
606
|
+
throw new AmountEncodingUnsupported(
|
|
607
|
+
field,
|
|
608
|
+
`${raw}`,
|
|
609
|
+
"a JSON number amount is only readable as a non-negative safe integer"
|
|
610
|
+
);
|
|
611
|
+
}
|
|
612
|
+
return BigInt(raw);
|
|
613
|
+
}
|
|
614
|
+
throw new AmountEncodingUnsupported(
|
|
615
|
+
field,
|
|
616
|
+
typeof raw === "bigint" || typeof raw === "boolean" ? `${raw}` : String(raw),
|
|
617
|
+
`expected a decimal string, got ${typeof raw}`
|
|
618
|
+
);
|
|
619
|
+
};
|
|
620
|
+
var toSafeNumber = (value, field) => {
|
|
621
|
+
if (value < 0n || value > BigInt(Number.MAX_SAFE_INTEGER)) {
|
|
622
|
+
throw new AmountEncodingUnsupported(
|
|
623
|
+
field,
|
|
624
|
+
`${value}`,
|
|
625
|
+
"does not fit a non-negative safe integer"
|
|
626
|
+
);
|
|
627
|
+
}
|
|
628
|
+
return Number(value);
|
|
629
|
+
};
|
|
630
|
+
|
|
631
|
+
// src/client/record.ts
|
|
632
|
+
var assetSwapIdOf = (family, quoteId) => `${family}:${quoteId}`;
|
|
633
|
+
var OFFER_SWAP_ID_PREFIX = "offer:";
|
|
634
|
+
var RFQ_SWAP_ID_PREFIX = "rfq:";
|
|
635
|
+
var familyOfSwapId = (swapId) => swapId.startsWith(OFFER_SWAP_ID_PREFIX) ? "offer" : swapId.startsWith(RFQ_SWAP_ID_PREFIX) ? "rfq" : void 0;
|
|
636
|
+
var quoteIdOfSwapId = (swapId) => {
|
|
637
|
+
const family = familyOfSwapId(swapId);
|
|
638
|
+
return family === void 0 ? swapId : swapId.slice(`${family}:`.length);
|
|
639
|
+
};
|
|
640
|
+
var recordEndpoint = (endpoint2) => ({
|
|
641
|
+
corridor: endpoint2.corridor,
|
|
642
|
+
asset: endpoint2.asset,
|
|
643
|
+
instrument: recordInstrument(endpoint2.instrument)
|
|
644
|
+
});
|
|
645
|
+
var recordInstrument = (instrument) => {
|
|
646
|
+
switch (instrument.kind) {
|
|
647
|
+
case "wallet":
|
|
648
|
+
return { kind: "wallet" };
|
|
649
|
+
case "address":
|
|
650
|
+
return { kind: "address", address: instrument.address };
|
|
651
|
+
case "invoice":
|
|
652
|
+
return {
|
|
653
|
+
kind: "invoice",
|
|
654
|
+
bolt11: instrument.bolt11,
|
|
655
|
+
paymentHash: instrument.paymentHash,
|
|
656
|
+
...instrument.amount === void 0 ? {} : { amount: toAtomicDecimal(instrument.amount) },
|
|
657
|
+
expiresAt: instrument.expiresAt
|
|
658
|
+
};
|
|
659
|
+
}
|
|
660
|
+
};
|
|
661
|
+
var instrumentOf = (instrument) => {
|
|
662
|
+
switch (instrument.kind) {
|
|
663
|
+
case "wallet":
|
|
664
|
+
return { kind: "wallet" };
|
|
665
|
+
case "address":
|
|
666
|
+
return { kind: "address", address: instrument.address };
|
|
667
|
+
case "invoice":
|
|
668
|
+
return {
|
|
669
|
+
kind: "invoice",
|
|
670
|
+
bolt11: instrument.bolt11,
|
|
671
|
+
paymentHash: instrument.paymentHash,
|
|
672
|
+
...instrument.amount === void 0 ? {} : { amount: fromAtomicDecimal(instrument.amount) },
|
|
673
|
+
expiresAt: instrument.expiresAt
|
|
674
|
+
};
|
|
675
|
+
}
|
|
676
|
+
};
|
|
677
|
+
var recordArtifact = (artifact) => artifact.kind === "invoice" ? { kind: "invoice", bolt11: artifact.bolt11 } : {
|
|
678
|
+
kind: "deposit",
|
|
679
|
+
corridor: artifact.corridor,
|
|
680
|
+
address: artifact.address,
|
|
681
|
+
asset: artifact.asset,
|
|
682
|
+
amount: toAtomicDecimal(artifact.amount),
|
|
683
|
+
...artifact.expiresAt === void 0 ? {} : { expiresAt: artifact.expiresAt }
|
|
684
|
+
};
|
|
685
|
+
var artifactOf = (artifact) => artifact.kind === "invoice" ? { kind: "invoice", bolt11: artifact.bolt11 } : {
|
|
686
|
+
kind: "deposit",
|
|
687
|
+
corridor: artifact.corridor,
|
|
688
|
+
address: artifact.address,
|
|
689
|
+
asset: artifact.asset,
|
|
690
|
+
amount: fromAtomicDecimal(artifact.amount),
|
|
691
|
+
...artifact.expiresAt === void 0 ? {} : { expiresAt: artifact.expiresAt }
|
|
692
|
+
};
|
|
693
|
+
var recordLeg = (leg) => ({
|
|
694
|
+
asset: leg.asset,
|
|
695
|
+
amount: toAtomicDecimal(leg.amount)
|
|
696
|
+
});
|
|
697
|
+
var legOf = (leg) => ({
|
|
698
|
+
asset: leg.asset,
|
|
699
|
+
amount: fromAtomicDecimal(leg.amount)
|
|
700
|
+
});
|
|
701
|
+
var swapOf = (record, outcome) => ({
|
|
702
|
+
id: assetSwapIdOf(record.family, record.id),
|
|
703
|
+
family: record.family,
|
|
704
|
+
outcome,
|
|
705
|
+
route: {
|
|
706
|
+
give: {
|
|
707
|
+
corridor: record.route.give.corridor,
|
|
708
|
+
asset: record.route.give.asset,
|
|
709
|
+
instrument: instrumentOf(record.route.give.instrument)
|
|
710
|
+
},
|
|
711
|
+
take: {
|
|
712
|
+
corridor: record.route.take.corridor,
|
|
713
|
+
asset: record.route.take.asset,
|
|
714
|
+
instrument: instrumentOf(record.route.take.instrument)
|
|
715
|
+
}
|
|
716
|
+
},
|
|
717
|
+
give: legOf(record.give),
|
|
718
|
+
take: legOf(record.take),
|
|
719
|
+
fee: legOf(record.fee),
|
|
720
|
+
market: record.market,
|
|
721
|
+
...record.solver === void 0 ? {} : { solver: record.solver },
|
|
722
|
+
...record.family === "rfq" ? { lock: record.lock, refundLocktime: record.refundLocktime } : {},
|
|
723
|
+
...record.artifact === void 0 ? {} : { artifact: artifactOf(record.artifact) },
|
|
724
|
+
expiresAt: record.expiresAt,
|
|
725
|
+
...record.fundingTxid === void 0 ? {} : { fundingTxid: record.fundingTxid },
|
|
726
|
+
...record.failure === void 0 ? {} : { failure: record.failure },
|
|
727
|
+
...record.blockedReason === void 0 ? {} : { blockedReason: record.blockedReason },
|
|
728
|
+
createdAt: record.createdAt,
|
|
729
|
+
updatedAt: record.updatedAt
|
|
730
|
+
});
|
|
731
|
+
var fundsFromWallet = (route) => route.give.instrument.kind === "wallet";
|
|
732
|
+
|
|
733
|
+
// src/client/accept.ts
|
|
734
|
+
import { hex } from "@scure/base";
|
|
735
|
+
import { asset as asset2, getAllNormalizedVtxos } from "@arkade-os/sdk";
|
|
736
|
+
var acceptLocks = /* @__PURE__ */ new Map();
|
|
737
|
+
var runSerialized = (id, body) => {
|
|
738
|
+
const tail = acceptLocks.get(id) ?? Promise.resolve();
|
|
739
|
+
const run = tail.then(body);
|
|
740
|
+
const marker = run.then(
|
|
741
|
+
() => void 0,
|
|
742
|
+
() => void 0
|
|
743
|
+
);
|
|
744
|
+
acceptLocks.set(id, marker);
|
|
745
|
+
void marker.then(() => {
|
|
746
|
+
if (acceptLocks.get(id) === marker) acceptLocks.delete(id);
|
|
747
|
+
});
|
|
748
|
+
return run;
|
|
749
|
+
};
|
|
750
|
+
var storageOf = (repository) => {
|
|
751
|
+
if (repository === void 0) {
|
|
752
|
+
throw new MissingCorridorDep("arkade", "repository");
|
|
753
|
+
}
|
|
754
|
+
return repository;
|
|
755
|
+
};
|
|
756
|
+
var sameRecordedInstrument = (a, b) => {
|
|
757
|
+
switch (a.kind) {
|
|
758
|
+
case "wallet":
|
|
759
|
+
return b.kind === "wallet";
|
|
760
|
+
case "address":
|
|
761
|
+
return b.kind === "address" && a.address === b.address;
|
|
762
|
+
case "invoice":
|
|
763
|
+
return b.kind === "invoice" && a.bolt11 === b.bolt11 && a.paymentHash === b.paymentHash && a.amount === b.amount && a.expiresAt === b.expiresAt;
|
|
764
|
+
}
|
|
765
|
+
};
|
|
766
|
+
var conflictingFields = (record, quote) => {
|
|
767
|
+
const incoming = recordedFacts(quote);
|
|
768
|
+
const stored = {
|
|
769
|
+
"route.pair": `${record.route.give.corridor}->${record.route.take.corridor}`,
|
|
770
|
+
"give.asset": record.route.give.asset,
|
|
771
|
+
"take.asset": record.route.take.asset,
|
|
772
|
+
"give.amount": record.give.amount,
|
|
773
|
+
"take.amount": record.take.amount,
|
|
774
|
+
"give.instrument": record.route.give.instrument,
|
|
775
|
+
"take.instrument": record.route.take.instrument,
|
|
776
|
+
"lock.hash": record.family === "rfq" ? record.lock.hash : void 0,
|
|
777
|
+
refundLocktime: record.family === "rfq" ? String(record.refundLocktime) : void 0,
|
|
778
|
+
solver: record.solver,
|
|
779
|
+
"market.source": marketSourceOf(record.market)
|
|
780
|
+
};
|
|
781
|
+
return Object.keys(incoming).filter((field) => {
|
|
782
|
+
if (field === "give.instrument" || field === "take.instrument") {
|
|
783
|
+
return !sameRecordedInstrument(stored[field], incoming[field]);
|
|
784
|
+
}
|
|
785
|
+
const a = stored[field];
|
|
786
|
+
const b = incoming[field];
|
|
787
|
+
if (a === void 0 && b === void 0) return false;
|
|
788
|
+
return a !== b;
|
|
789
|
+
});
|
|
790
|
+
};
|
|
791
|
+
var recordedFacts = (quote) => ({
|
|
792
|
+
"route.pair": `${quote.route.give.corridor}->${quote.route.take.corridor}`,
|
|
793
|
+
"give.asset": quote.route.give.asset,
|
|
794
|
+
"take.asset": quote.route.take.asset,
|
|
795
|
+
"give.amount": recordLeg(quote.give).amount,
|
|
796
|
+
"take.amount": recordLeg(quote.take).amount,
|
|
797
|
+
"give.instrument": recordEndpoint(quote.route.give).instrument,
|
|
798
|
+
"take.instrument": recordEndpoint(quote.route.take).instrument,
|
|
799
|
+
"lock.hash": quote.lock?.hash,
|
|
800
|
+
refundLocktime: quote.refundLocktime === void 0 ? void 0 : String(quote.refundLocktime),
|
|
801
|
+
solver: quote.solver,
|
|
802
|
+
"market.source": marketSourceOf(quote.market)
|
|
803
|
+
});
|
|
804
|
+
var marketSourceOf = (market) => market.kind === "card" ? market.source : void 0;
|
|
805
|
+
var assertFundable2 = async (wallet, quote) => {
|
|
806
|
+
const give = quote.give;
|
|
807
|
+
const balance = await wallet.getBalance();
|
|
808
|
+
const available = isBtcAsset(give.asset) ? BigInt(balance.available) : balance.availableAssets.find((a) => give.asset.endsWith(a.assetId))?.amount ?? 0n;
|
|
809
|
+
if (available < give.amount) {
|
|
810
|
+
throw new InsufficientFunds(give.asset, give.amount, available);
|
|
811
|
+
}
|
|
812
|
+
};
|
|
813
|
+
var commonOf = (quote, now) => ({
|
|
814
|
+
id: quote.id,
|
|
815
|
+
route: {
|
|
816
|
+
give: recordEndpoint(quote.route.give),
|
|
817
|
+
take: recordEndpoint(quote.route.take)
|
|
818
|
+
},
|
|
819
|
+
give: recordLeg(quote.give),
|
|
820
|
+
take: recordLeg(quote.take),
|
|
821
|
+
fee: recordLeg(quote.fee),
|
|
822
|
+
market: quote.market,
|
|
823
|
+
...quote.solver === void 0 ? {} : { solver: quote.solver },
|
|
824
|
+
expiresAt: quote.expiresAt,
|
|
825
|
+
...quote.artifact === void 0 ? {} : { artifact: recordArtifact(quote.artifact) },
|
|
826
|
+
createdAt: now,
|
|
827
|
+
updatedAt: now
|
|
828
|
+
});
|
|
829
|
+
var corridorRecord = (quote, preparation, now) => {
|
|
830
|
+
if (quote.lock === void 0 || quote.refundLocktime === void 0) {
|
|
831
|
+
throw new Error(`corridor quote ${quote.id} carries no lock hash or refund locktime`);
|
|
832
|
+
}
|
|
833
|
+
return {
|
|
834
|
+
...commonOf(quote, now),
|
|
835
|
+
family: "rfq",
|
|
836
|
+
state: "pending",
|
|
837
|
+
kind: KIND_OF[preparation.route],
|
|
838
|
+
rfqId: preparation.rfqId,
|
|
839
|
+
lockupAddress: preparation.lockup.address,
|
|
840
|
+
lockupPkScript: hex.encode(preparation.lockup.pkScript),
|
|
841
|
+
lock: { hash: quote.lock.hash },
|
|
842
|
+
refundLocktime: quote.refundLocktime,
|
|
843
|
+
profile: profileOf(preparation, quote.lock.hash)
|
|
844
|
+
};
|
|
845
|
+
};
|
|
846
|
+
var KIND_OF = {
|
|
847
|
+
"arkade->lightning": "lightning_send",
|
|
848
|
+
"lightning->arkade": "lightning_receive",
|
|
849
|
+
"arkade->onchain": "onchain_send"
|
|
850
|
+
};
|
|
851
|
+
var profileOf = (preparation, paymentHash) => {
|
|
852
|
+
const secrets = rfqSecretsProfile(preparation.secrets, paymentHash);
|
|
853
|
+
switch (preparation.route) {
|
|
854
|
+
case "arkade->lightning":
|
|
855
|
+
return { ...secrets };
|
|
856
|
+
case "lightning->arkade":
|
|
857
|
+
return {
|
|
858
|
+
...secrets,
|
|
859
|
+
expectedAmount: toSafeNumber(preparation.expectedAmount, "expectedAmount"),
|
|
860
|
+
payoutAddress: preparation.payoutAddress
|
|
861
|
+
};
|
|
862
|
+
case "arkade->onchain":
|
|
863
|
+
return {
|
|
864
|
+
...secrets,
|
|
865
|
+
...onchainSendProfile({
|
|
866
|
+
htlc: preparation.htlc,
|
|
867
|
+
htlcParams: preparation.htlcParams,
|
|
868
|
+
l1Network: preparation.l1Network,
|
|
869
|
+
minConfirmations: preparation.minConfirmations,
|
|
870
|
+
expectedAmount: toSafeNumber(preparation.expectedAmount, "expectedAmount"),
|
|
871
|
+
payoutPkScript: preparation.payoutPkScript
|
|
872
|
+
})
|
|
873
|
+
};
|
|
874
|
+
}
|
|
875
|
+
};
|
|
876
|
+
var acceptQuote = async (input) => runSerialized(input.quote.id, () => acceptQuoteBody(input));
|
|
877
|
+
var acceptQuoteBody = async (input) => {
|
|
878
|
+
const { quote, wallet, now } = input;
|
|
879
|
+
const repository = storageOf(input.repository);
|
|
880
|
+
const answer = (record2) => input.drive ? input.drive.adopt(record2) : swapOf(record2, recordOutcome(record2));
|
|
881
|
+
const expired = now > quote.expiresAt;
|
|
882
|
+
const stored = await repository.getSwapRecord(quote.id);
|
|
883
|
+
if (stored !== void 0) {
|
|
884
|
+
const fields = conflictingFields(stored, quote);
|
|
885
|
+
if (fields.length > 0) {
|
|
886
|
+
throw new AcceptConflict(quote.id, stored.id, fields);
|
|
887
|
+
}
|
|
888
|
+
if (stored.fundingTxid !== void 0) return answer(stored);
|
|
889
|
+
if (!fundsFromWallet(stored.route)) return answer(stored);
|
|
890
|
+
const found = await reconcileFunding({ wallet }, stored);
|
|
891
|
+
if (found !== void 0) {
|
|
892
|
+
return answer(await stampFunding(repository, stored, found, now));
|
|
893
|
+
}
|
|
894
|
+
if (expired) throw new QuoteExpired(quote.id, quote.expiresAt, now);
|
|
895
|
+
return answer(await fundAndStamp({ wallet, now }, stored, repository));
|
|
896
|
+
}
|
|
897
|
+
if (expired) throw new QuoteExpired(quote.id, quote.expiresAt, now);
|
|
898
|
+
const preparation = input.preparation;
|
|
899
|
+
if (preparation === void 0) {
|
|
900
|
+
throw new Error(
|
|
901
|
+
`quote ${quote.id} was not derived by this client instance; re-quote before accepting`
|
|
902
|
+
);
|
|
903
|
+
}
|
|
904
|
+
const funds = fundsFromWallet(quote.route);
|
|
905
|
+
if (funds) await assertFundable2(wallet, quote);
|
|
906
|
+
const record = preparation.backend === "feed" ? await registeredOfferRecord(input, preparation) : preparation.route === "arkade->arkade" ? await registeredAssetRecord(input, preparation) : await registeredCorridorRecord(input, preparation);
|
|
907
|
+
await repository.saveSwapRecord(record);
|
|
908
|
+
if (!funds) return answer(record);
|
|
909
|
+
return answer(await fundAndStamp({ wallet, now }, record, repository));
|
|
910
|
+
};
|
|
911
|
+
var registeredOfferRecord = async (input, preparation) => {
|
|
912
|
+
const { quote, wallet, corridors, now } = input;
|
|
913
|
+
const { plan } = preparation;
|
|
914
|
+
const arkade = corridors.get("arkade").deps;
|
|
915
|
+
const receiveIsBtc = plan.receive.asset.id === BTC_ASSET_ID;
|
|
916
|
+
const offer = await createOffer(wallet, {
|
|
917
|
+
// Keyed on the receive side: the covenant binds what the fill delivers.
|
|
918
|
+
wantAmount: plan.receive.atomic,
|
|
919
|
+
...receiveIsBtc ? { offerAsset: asset2.AssetId.fromString(plan.deposit.asset.id) } : { wantAsset: asset2.AssetId.fromString(plan.receive.asset.id) },
|
|
920
|
+
emulatorPubkey: arkade.emulatorPubkey
|
|
921
|
+
});
|
|
922
|
+
return {
|
|
923
|
+
...commonOf(quote, now),
|
|
924
|
+
family: "offer",
|
|
925
|
+
status: "pending",
|
|
926
|
+
offerHex: offer.offerHex,
|
|
927
|
+
swapAddress: offer.address,
|
|
928
|
+
swapPkScript: hex.encode(offer.swapPkScript)
|
|
929
|
+
};
|
|
930
|
+
};
|
|
931
|
+
var registeredAssetRecord = async (input, preparation) => {
|
|
932
|
+
await registerDerivedOffer(input.wallet, preparation.offer);
|
|
933
|
+
return {
|
|
934
|
+
...commonOf(input.quote, input.now),
|
|
935
|
+
family: "offer",
|
|
936
|
+
status: "pending",
|
|
937
|
+
offerHex: preparation.offer.offerHex,
|
|
938
|
+
swapAddress: preparation.offer.address,
|
|
939
|
+
swapPkScript: hex.encode(preparation.offer.swapPkScript),
|
|
940
|
+
...preparation.carrierSats === void 0 ? {} : { carrierSats: preparation.carrierSats.toString() }
|
|
941
|
+
};
|
|
942
|
+
};
|
|
943
|
+
var registeredCorridorRecord = async (input, preparation) => {
|
|
944
|
+
const contracts = await input.wallet.getContractManager();
|
|
945
|
+
await registerLockupContract(contracts, preparation.lockup.script, preparation.lockup.address);
|
|
946
|
+
return corridorRecord(input.quote, preparation, input.now);
|
|
947
|
+
};
|
|
948
|
+
var fundAndStamp = async (input, record, repository) => {
|
|
949
|
+
const txid = await fund(input, record);
|
|
950
|
+
return stampFunding(repository, record, txid, input.now);
|
|
951
|
+
};
|
|
952
|
+
var stampFunding = async (repository, record, fundingTxid, now) => {
|
|
953
|
+
const stamped = { ...record, fundingTxid, updatedAt: now };
|
|
954
|
+
try {
|
|
955
|
+
await repository.saveSwapRecord(stamped);
|
|
956
|
+
} catch (error) {
|
|
957
|
+
console.warn(`[swap] funded ${record.id} but could not store its txid`, error);
|
|
958
|
+
}
|
|
959
|
+
return stamped;
|
|
960
|
+
};
|
|
961
|
+
var fund = async (input, record) => {
|
|
962
|
+
const { wallet } = input;
|
|
963
|
+
if (record.family === "offer") {
|
|
964
|
+
const amount = fromAtomicDecimal(record.give.amount);
|
|
965
|
+
const depositIsBtc = isBtcAssetLenient(record.route.give.asset);
|
|
966
|
+
return wallet.send({
|
|
967
|
+
address: record.swapAddress,
|
|
968
|
+
// An asset deposit rides a dust-sat carrier: the solver's published one when the record
|
|
969
|
+
// names it (the fill is priced against it), else the SDK default.
|
|
970
|
+
...depositIsBtc ? { amount: toSafeNumber(amount, "give.amount") } : {
|
|
971
|
+
...record.carrierSats === void 0 ? {} : { amount: toSafeNumber(BigInt(record.carrierSats), "carrierSats") },
|
|
972
|
+
assets: [
|
|
973
|
+
{ assetId: toDiscoveryLeg(record.route.give.asset).assetId, amount }
|
|
974
|
+
]
|
|
975
|
+
},
|
|
976
|
+
extensions: [offerExtensionOf(record)]
|
|
977
|
+
});
|
|
978
|
+
}
|
|
979
|
+
if (record.kind === "lightning_receive") {
|
|
980
|
+
throw new Error(`receive swap ${record.id} funds nothing from this wallet`);
|
|
981
|
+
}
|
|
982
|
+
return wallet.send({
|
|
983
|
+
address: record.lockupAddress,
|
|
984
|
+
amount: toSafeNumber(fromAtomicDecimal(record.give.amount), "give.amount")
|
|
985
|
+
});
|
|
986
|
+
};
|
|
987
|
+
var offerExtensionOf = (record) => ({
|
|
988
|
+
type: OFFER_PACKET_TYPE,
|
|
989
|
+
payload: hex.decode(record.offerHex)
|
|
990
|
+
});
|
|
991
|
+
var reconcileFunding = async (input, record) => {
|
|
992
|
+
const script = record.family === "offer" ? record.swapPkScript : record.lockupPkScript;
|
|
993
|
+
const expected = BigInt(record.give.amount);
|
|
994
|
+
const reader = await input.wallet.getArkadeReader();
|
|
995
|
+
const vtxos = await getAllNormalizedVtxos(reader, [script]);
|
|
996
|
+
const deposit = vtxos.find((vtxo) => depositMatches(vtxo, record, expected));
|
|
997
|
+
return deposit?.txid;
|
|
998
|
+
};
|
|
999
|
+
var depositMatches = (vtxo, record, expected) => {
|
|
1000
|
+
const giveAsset = record.route.give.asset;
|
|
1001
|
+
if (isBtcAssetLenient(giveAsset)) {
|
|
1002
|
+
return BigInt(vtxo.value) === expected;
|
|
1003
|
+
}
|
|
1004
|
+
return (vtxo.assets ?? []).some(
|
|
1005
|
+
(entry) => giveAsset.endsWith(entry.assetId) && entry.amount === expected
|
|
1006
|
+
);
|
|
1007
|
+
};
|
|
1008
|
+
var swapRecordOf = async (repository, id) => storageOf(repository).getSwapRecord(id);
|
|
1009
|
+
|
|
1010
|
+
// src/client/corridor.ts
|
|
1011
|
+
var CORRIDORS = ["arkade", "lightning", "onchain"];
|
|
1012
|
+
var RAIL_BY_CORRIDOR = {
|
|
1013
|
+
arkade: "arkade",
|
|
1014
|
+
lightning: "bolt11",
|
|
1015
|
+
onchain: "bitcoin"
|
|
1016
|
+
};
|
|
1017
|
+
var CORRIDOR_BY_RAIL = {
|
|
1018
|
+
arkade: "arkade",
|
|
1019
|
+
bolt11: "lightning",
|
|
1020
|
+
bitcoin: "onchain"
|
|
1021
|
+
};
|
|
1022
|
+
var railOfCorridor = (corridor) => corridor in RAIL_BY_CORRIDOR ? RAIL_BY_CORRIDOR[corridor] : "eip155";
|
|
1023
|
+
var corridorOfRail = (rail) => rail === "eip155" ? void 0 : CORRIDOR_BY_RAIL[rail];
|
|
1024
|
+
|
|
1025
|
+
// src/client/aliasTable.ts
|
|
1026
|
+
var ARKADE_ASSET_IDENTITY = /^[0-9a-f]{68}$/;
|
|
1027
|
+
var publicAssetId = (corridor, assetId, network) => {
|
|
1028
|
+
const rail = railOfCorridor(corridor);
|
|
1029
|
+
if (assetId === BTC_ASSET_ID) return btcOn(rail, network);
|
|
1030
|
+
if (rail !== "arkade") return void 0;
|
|
1031
|
+
if (!ARKADE_ASSET_IDENTITY.test(assetId)) return void 0;
|
|
1032
|
+
return `arkade:${network}/${ARKADE_ASSET_NAMESPACE}:${assetId}`;
|
|
1033
|
+
};
|
|
1034
|
+
var aliasTableFrom = (markets, network) => {
|
|
1035
|
+
const rows = /* @__PURE__ */ new Map();
|
|
1036
|
+
const add = (card, side) => {
|
|
1037
|
+
const info = side === "base" ? card.base_asset : card.quote_asset;
|
|
1038
|
+
const corridor = corridorOfRail(marketCorridor(card, side));
|
|
1039
|
+
if (corridor === void 0) return;
|
|
1040
|
+
const canonical = marketAssetId(card, side);
|
|
1041
|
+
const id = canonical !== void 0 && isAssetId(canonical) ? canonical : publicAssetId(corridor, info.id, network);
|
|
1042
|
+
if (id === void 0 || typeof info.ticker !== "string" || info.ticker === "") return;
|
|
1043
|
+
rows.set(`${id} ${info.ticker.toLowerCase()}`, { id, ticker: info.ticker });
|
|
1044
|
+
};
|
|
1045
|
+
for (const card of markets) {
|
|
1046
|
+
add(card, "base");
|
|
1047
|
+
add(card, "quote");
|
|
1048
|
+
}
|
|
1049
|
+
return { network, assets: [...rows.values()] };
|
|
1050
|
+
};
|
|
1051
|
+
var scopedToRail = (table, rail) => ({
|
|
1052
|
+
network: table.network,
|
|
1053
|
+
assets: table.assets.filter((row) => row.id.startsWith(`${rail}:`))
|
|
1054
|
+
});
|
|
1055
|
+
|
|
1056
|
+
// src/client/corridors/arkade.ts
|
|
1057
|
+
import { ArkAddress, arkTarget, assertRecipientArkadeAddress } from "@arkade-os/sdk";
|
|
1058
|
+
var ARKADE_DRIVE = {};
|
|
1059
|
+
var messageOf = (error) => error instanceof Error ? error.message : String(error);
|
|
1060
|
+
var arkadeCorridor = Object.assign(
|
|
1061
|
+
(deps) => ({
|
|
1062
|
+
corridor: "arkade",
|
|
1063
|
+
deps,
|
|
1064
|
+
drive: ARKADE_DRIVE,
|
|
1065
|
+
matches(raw) {
|
|
1066
|
+
const target = arkTarget(raw);
|
|
1067
|
+
if (target === void 0) return void 0;
|
|
1068
|
+
try {
|
|
1069
|
+
const address = ArkAddress.decode(target);
|
|
1070
|
+
assertRecipientArkadeAddress(target, address, {
|
|
1071
|
+
hrp: deps.network.hrp,
|
|
1072
|
+
signerSet: deps.signerSet
|
|
1073
|
+
});
|
|
1074
|
+
} catch (error) {
|
|
1075
|
+
return { refused: messageOf(error) };
|
|
1076
|
+
}
|
|
1077
|
+
return { claimed: { kind: "address", address: target } };
|
|
1078
|
+
}
|
|
1079
|
+
}),
|
|
1080
|
+
{ target: arkTarget }
|
|
1081
|
+
);
|
|
1082
|
+
|
|
1083
|
+
// src/client/corridors/bolt11.ts
|
|
1084
|
+
import bolt11 from "light-bolt11-decoder";
|
|
1085
|
+
var DEFAULT_INVOICE_EXPIRY_SECONDS = 3600;
|
|
1086
|
+
var valueOf = (decoded, name) => decoded.sections.find(
|
|
1087
|
+
(section) => section.name === name
|
|
1088
|
+
)?.value;
|
|
1089
|
+
var decodeBolt11 = (invoice) => {
|
|
1090
|
+
const decoded = bolt11.decode(invoice);
|
|
1091
|
+
const timestamp = valueOf(decoded, "timestamp");
|
|
1092
|
+
if (typeof timestamp !== "number" || !Number.isFinite(timestamp)) {
|
|
1093
|
+
throw new Error("bolt11 invoice carries no timestamp");
|
|
1094
|
+
}
|
|
1095
|
+
const expiry = valueOf(decoded, "expiry");
|
|
1096
|
+
const expiresAt = timestamp + (typeof expiry === "number" ? expiry : DEFAULT_INVOICE_EXPIRY_SECONDS);
|
|
1097
|
+
const paymentHash = valueOf(decoded, "payment_hash");
|
|
1098
|
+
if (typeof paymentHash !== "string" || !PAYMENT_HASH.test(paymentHash)) {
|
|
1099
|
+
throw new Error("bolt11 invoice carries no payment hash");
|
|
1100
|
+
}
|
|
1101
|
+
const millisats = valueOf(decoded, "amount");
|
|
1102
|
+
const amountSats = typeof millisats === "string" ? Number(BigInt(millisats) / 1000n) : (
|
|
1103
|
+
/* amountless */
|
|
1104
|
+
0
|
|
1105
|
+
);
|
|
1106
|
+
return { raw: invoice, paymentHash, amountSats, expiresAt };
|
|
1107
|
+
};
|
|
1108
|
+
|
|
1109
|
+
// src/client/corridors/chainSource.ts
|
|
1110
|
+
import { hex as hex2 } from "@scure/base";
|
|
1111
|
+
import * as btc from "@scure/btc-signer";
|
|
1112
|
+
import { EsploraProvider } from "@arkade-os/sdk";
|
|
1113
|
+
var addressOfScript = (script, network) => btc.Address(network).encode(btc.OutScript.decode(script));
|
|
1114
|
+
var chainSourceOver = (backend, network) => {
|
|
1115
|
+
const spenderFromVins = async (txid, vout, pkScript) => {
|
|
1116
|
+
let address;
|
|
1117
|
+
try {
|
|
1118
|
+
address = addressOfScript(pkScript, network);
|
|
1119
|
+
} catch {
|
|
1120
|
+
return void 0;
|
|
1121
|
+
}
|
|
1122
|
+
for (const tx of await backend.provider.getTransactions(address)) {
|
|
1123
|
+
if ((tx.vin ?? []).some((input) => input.txid === txid && input.vout === vout)) {
|
|
1124
|
+
return tx.txid;
|
|
1125
|
+
}
|
|
1126
|
+
}
|
|
1127
|
+
return void 0;
|
|
1128
|
+
};
|
|
1129
|
+
return {
|
|
1130
|
+
async getScriptUtxos(pkScript) {
|
|
1131
|
+
const address = addressOfScript(pkScript, network);
|
|
1132
|
+
const [coins, tip] = await Promise.all([
|
|
1133
|
+
backend.provider.getCoins(address),
|
|
1134
|
+
backend.tip()
|
|
1135
|
+
]);
|
|
1136
|
+
return coins.map((coin) => ({
|
|
1137
|
+
txid: coin.txid,
|
|
1138
|
+
vout: coin.vout,
|
|
1139
|
+
amount: BigInt(coin.value),
|
|
1140
|
+
// A confirmed coin is one deep, not zero: its own block counts.
|
|
1141
|
+
confirmations: coin.status.confirmed && coin.status.block_height !== void 0 ? Math.max(0, tip.height - coin.status.block_height + 1) : 0
|
|
1142
|
+
}));
|
|
1143
|
+
},
|
|
1144
|
+
async getSpendingTx(txid, vout, pkScript) {
|
|
1145
|
+
const outspends = await backend.provider.getTxOutspends(txid);
|
|
1146
|
+
const outspend = outspends[vout];
|
|
1147
|
+
if (!outspend?.spent) return null;
|
|
1148
|
+
const spender = outspend.txid || await spenderFromVins(txid, vout, pkScript);
|
|
1149
|
+
if (!spender) return null;
|
|
1150
|
+
return { txHex: hex2.encode(await backend.provider.getRawTransaction(spender)) };
|
|
1151
|
+
},
|
|
1152
|
+
broadcast(txHex) {
|
|
1153
|
+
return backend.provider.broadcastTransaction(txHex);
|
|
1154
|
+
},
|
|
1155
|
+
async getMtp() {
|
|
1156
|
+
return (await backend.tip()).mtp;
|
|
1157
|
+
}
|
|
1158
|
+
};
|
|
1159
|
+
};
|
|
1160
|
+
var esploraTip = async (esploraUrl, fetchImpl) => {
|
|
1161
|
+
const response = await (fetchImpl ?? fetch)(`${esploraUrl}/blocks`);
|
|
1162
|
+
if (!response.ok) {
|
|
1163
|
+
throw new Error(`failed to read the chain tip: ${response.status} ${response.statusText}`);
|
|
1164
|
+
}
|
|
1165
|
+
const blocks = await response.json();
|
|
1166
|
+
const tip = Array.isArray(blocks) ? blocks[0] : void 0;
|
|
1167
|
+
if (!tip || typeof tip.height !== "number" || typeof tip.mediantime !== "number" || !(tip.mediantime > 0)) {
|
|
1168
|
+
throw new Error(`esplora returned no usable chain tip for ${esploraUrl}`);
|
|
1169
|
+
}
|
|
1170
|
+
return { height: tip.height, mtp: tip.mediantime };
|
|
1171
|
+
};
|
|
1172
|
+
var esploraChainSource = (input) => chainSourceOver(
|
|
1173
|
+
{
|
|
1174
|
+
provider: new EsploraProvider(input.esploraUrl),
|
|
1175
|
+
tip: () => esploraTip(input.esploraUrl, input.fetchImpl)
|
|
1176
|
+
},
|
|
1177
|
+
input.network
|
|
1178
|
+
);
|
|
1179
|
+
|
|
1180
|
+
// src/client/corridors/deps.ts
|
|
1181
|
+
import {
|
|
1182
|
+
ESPLORA_URL,
|
|
1183
|
+
defaultEmulatorPubkey,
|
|
1184
|
+
getNetwork,
|
|
1185
|
+
resolveEmulatorPubkey,
|
|
1186
|
+
signerSetFromInfo
|
|
1187
|
+
} from "@arkade-os/sdk";
|
|
1188
|
+
var ONCHAIN_CLAIM_FEE_RATE_SATVB = {
|
|
1189
|
+
bitcoin: 1,
|
|
1190
|
+
testnet: 1,
|
|
1191
|
+
signet: 1,
|
|
1192
|
+
mutinynet: 1,
|
|
1193
|
+
regtest: 1
|
|
1194
|
+
};
|
|
1195
|
+
var refusedIfNull = (value, corridor, dep) => {
|
|
1196
|
+
if (value === null) throw new MissingCorridorDep(corridor, dep);
|
|
1197
|
+
return value;
|
|
1198
|
+
};
|
|
1199
|
+
var refusedIfMalformed = (value, dep) => {
|
|
1200
|
+
if (value !== void 0 && value !== null && !(Number.isFinite(value) && value > 0)) {
|
|
1201
|
+
throw new MissingCorridorDep("onchain", dep);
|
|
1202
|
+
}
|
|
1203
|
+
return value;
|
|
1204
|
+
};
|
|
1205
|
+
var emulatorPubkeyFor = (base) => {
|
|
1206
|
+
if (base.emulatorPubkey !== void 0) {
|
|
1207
|
+
return resolveEmulatorPubkey(base.network, base.emulatorPubkey);
|
|
1208
|
+
}
|
|
1209
|
+
try {
|
|
1210
|
+
return defaultEmulatorPubkey(base.network);
|
|
1211
|
+
} catch {
|
|
1212
|
+
throw new MissingCorridorDep(
|
|
1213
|
+
"arkade",
|
|
1214
|
+
`covenant co-signer key (none is pinned for ${base.networkName}; pass emulatorPubkey)`
|
|
1215
|
+
);
|
|
1216
|
+
}
|
|
1217
|
+
};
|
|
1218
|
+
function resolveCorridorDeps(corridor, overrides, base) {
|
|
1219
|
+
switch (corridor) {
|
|
1220
|
+
case "arkade": {
|
|
1221
|
+
const repository = refusedIfNull(overrides?.arkade?.repository, "arkade", "repository") ?? base.repository;
|
|
1222
|
+
return {
|
|
1223
|
+
wallet: base.wallet,
|
|
1224
|
+
operator: base.operator,
|
|
1225
|
+
networkName: base.networkName,
|
|
1226
|
+
network: base.network,
|
|
1227
|
+
signerSet: base.signerSet,
|
|
1228
|
+
emulatorPubkey: emulatorPubkeyFor(base),
|
|
1229
|
+
repository
|
|
1230
|
+
};
|
|
1231
|
+
}
|
|
1232
|
+
case "lightning": {
|
|
1233
|
+
return {
|
|
1234
|
+
networkName: base.networkName,
|
|
1235
|
+
decode: refusedIfNull(overrides?.lightning?.decode, "lightning", "bolt11 decoder") ?? decodeBolt11,
|
|
1236
|
+
covclaimd: refusedIfNull(
|
|
1237
|
+
overrides?.lightning?.covclaimd,
|
|
1238
|
+
"lightning",
|
|
1239
|
+
"covclaimd deployment key"
|
|
1240
|
+
)
|
|
1241
|
+
};
|
|
1242
|
+
}
|
|
1243
|
+
case "onchain": {
|
|
1244
|
+
const chain = refusedIfNull(overrides?.onchain?.chain, "onchain", "chain source");
|
|
1245
|
+
const claim = refusedIfNull(overrides?.onchain?.claim, "onchain", "L1 claim callback");
|
|
1246
|
+
const feeRateOverride = refusedIfMalformed(
|
|
1247
|
+
overrides?.onchain?.claimFeeRateSatVb,
|
|
1248
|
+
"L1 claim fee rate"
|
|
1249
|
+
);
|
|
1250
|
+
const claimFeeRateSatVb = feeRateOverride === null ? void 0 : feeRateOverride ?? ONCHAIN_CLAIM_FEE_RATE_SATVB[base.networkName];
|
|
1251
|
+
const claimVsize = refusedIfMalformed(overrides?.onchain?.claimVsize, "L1 claim vsize") ?? ONCHAIN_CLAIM_VSIZE;
|
|
1252
|
+
return {
|
|
1253
|
+
networkName: base.networkName,
|
|
1254
|
+
chain: esploraChainSource({
|
|
1255
|
+
esploraUrl: chain?.esploraUrl ?? ESPLORA_URL[base.networkName],
|
|
1256
|
+
network: L1_NETWORKS[l1NetworkFromArk(base.networkName)],
|
|
1257
|
+
fetchImpl: base.fetchImpl
|
|
1258
|
+
}),
|
|
1259
|
+
...claim === void 0 ? {} : { claim },
|
|
1260
|
+
...claimFeeRateSatVb === void 0 ? {} : { claimFeeRateSatVb },
|
|
1261
|
+
claimVsize
|
|
1262
|
+
};
|
|
1263
|
+
}
|
|
1264
|
+
}
|
|
1265
|
+
}
|
|
1266
|
+
var liveArkadeInfo = async (wallet, opts = {}) => {
|
|
1267
|
+
const requireLive = opts.requireLive ?? true;
|
|
1268
|
+
try {
|
|
1269
|
+
return await wallet.getArkadeInfo({ requireLive });
|
|
1270
|
+
} catch (cause) {
|
|
1271
|
+
throw new OperatorUnreachable(
|
|
1272
|
+
`the Arkade server info could not be read${requireLive ? " live" : ""}: ${cause instanceof Error ? cause.message : String(cause)}`,
|
|
1273
|
+
{ cause }
|
|
1274
|
+
);
|
|
1275
|
+
}
|
|
1276
|
+
};
|
|
1277
|
+
var resolveCorridorBase = async (input) => {
|
|
1278
|
+
const info = await liveArkadeInfo(input.wallet, { requireLive: input.requireLive });
|
|
1279
|
+
const networkName = info.network;
|
|
1280
|
+
return {
|
|
1281
|
+
wallet: input.wallet,
|
|
1282
|
+
operator: input.operator,
|
|
1283
|
+
networkName,
|
|
1284
|
+
network: getNetwork(networkName),
|
|
1285
|
+
signerSet: signerSetFromInfo(info),
|
|
1286
|
+
emulatorPubkey: input.emulatorPubkey,
|
|
1287
|
+
fetchImpl: input.fetchImpl,
|
|
1288
|
+
repository: input.repository
|
|
1289
|
+
};
|
|
1290
|
+
};
|
|
1291
|
+
|
|
1292
|
+
// src/client/corridors/registry.ts
|
|
1293
|
+
import { isLnurl } from "@arkade-os/sdk";
|
|
1294
|
+
var CORRIDOR_FACTORIES = {
|
|
1295
|
+
arkade: arkadeCorridor,
|
|
1296
|
+
lightning: lightningCorridor,
|
|
1297
|
+
onchain: onchainCorridor
|
|
1298
|
+
};
|
|
1299
|
+
var corridorSet = (base, overrides) => {
|
|
1300
|
+
const built = /* @__PURE__ */ new Map();
|
|
1301
|
+
const get = (corridor) => {
|
|
1302
|
+
const memoized = built.get(corridor);
|
|
1303
|
+
if (memoized) return memoized;
|
|
1304
|
+
const factory = CORRIDOR_FACTORIES[corridor];
|
|
1305
|
+
const module = factory(resolveCorridorDeps(corridor, overrides, base));
|
|
1306
|
+
built.set(corridor, module);
|
|
1307
|
+
return module;
|
|
1308
|
+
};
|
|
1309
|
+
return {
|
|
1310
|
+
get,
|
|
1311
|
+
claim(raw) {
|
|
1312
|
+
const owners = CORRIDORS.filter(
|
|
1313
|
+
(corridor) => CORRIDOR_FACTORIES[corridor].target(raw) !== void 0
|
|
1314
|
+
);
|
|
1315
|
+
if (owners.length === 0) {
|
|
1316
|
+
if (isLnurl(raw)) return void 0;
|
|
1317
|
+
throw new AmbiguousDestination(raw, "no corridor recognises this destination");
|
|
1318
|
+
}
|
|
1319
|
+
const claims = [];
|
|
1320
|
+
const refusals = [];
|
|
1321
|
+
for (const corridor of owners) {
|
|
1322
|
+
const answer = get(corridor).matches(raw);
|
|
1323
|
+
if (answer?.claimed) claims.push({ corridor, instrument: answer.claimed });
|
|
1324
|
+
else if (answer?.refused) refusals.push(`${corridor}: ${answer.refused}`);
|
|
1325
|
+
}
|
|
1326
|
+
if (claims.length > 1) {
|
|
1327
|
+
throw new AmbiguousDestination(
|
|
1328
|
+
raw,
|
|
1329
|
+
`it names ${claims.map((claim) => claim.corridor).join(" and ")}, with nothing to choose between them`
|
|
1330
|
+
);
|
|
1331
|
+
}
|
|
1332
|
+
if (claims.length === 1) return claims[0];
|
|
1333
|
+
if (refusals.length > 0) throw new AmbiguousDestination(raw, refusals.join("; "));
|
|
1334
|
+
return void 0;
|
|
1335
|
+
}
|
|
1336
|
+
};
|
|
1337
|
+
};
|
|
1338
|
+
|
|
1339
|
+
// src/client/discovery.ts
|
|
1340
|
+
import {
|
|
1341
|
+
MAX_RELAYS,
|
|
1342
|
+
discover,
|
|
1343
|
+
isRfqMarket
|
|
1344
|
+
} from "@arkade-os/solver-discovery";
|
|
1345
|
+
var REGISTRY_URL = {
|
|
1346
|
+
bitcoin: "https://arkade-os.github.io/solver-registry/bitcoin.json",
|
|
1347
|
+
signet: "https://arkade-os.github.io/solver-registry/signet.json",
|
|
1348
|
+
mutinynet: "https://arkade-os.github.io/solver-registry/mutinynet.json",
|
|
1349
|
+
regtest: "https://arkade-os.github.io/solver-registry/regtest.json"
|
|
1350
|
+
};
|
|
1351
|
+
var HEX_64 = /^[0-9a-f]{64}$/;
|
|
1352
|
+
var LEGACY_ASSET_ID = /^(?:btc|[0-9a-f]{68})$/;
|
|
1353
|
+
var isRelayList = (value) => Array.isArray(value) && value.length > 0 && value.length <= MAX_RELAYS && value.every((relay) => typeof relay === "string" && relay.startsWith("wss://"));
|
|
1354
|
+
var isCorridorField = (value) => value === void 0 || CORRIDORS.includes(value);
|
|
1355
|
+
var isUsableCard = (value) => {
|
|
1356
|
+
const card = value;
|
|
1357
|
+
if (!card) return false;
|
|
1358
|
+
if (card.pair !== void 0 && typeof card.pair !== "string" || typeof card.solver !== "string" || typeof card.source !== "string" || card.sourceType !== "registry" && card.sourceType !== "local" || typeof card.base_asset?.id !== "string" || typeof card.quote_asset?.id !== "string" || typeof card.base_asset.decimals !== "number" || typeof card.quote_asset.decimals !== "number" || !isCorridorField(card.base_corridor) || !isCorridorField(card.quote_corridor)) {
|
|
1359
|
+
return false;
|
|
1360
|
+
}
|
|
1361
|
+
for (const side of ["base", "quote"]) {
|
|
1362
|
+
const id = marketAssetId(card, side);
|
|
1363
|
+
if (id === void 0 || !isAssetId(id) && !LEGACY_ASSET_ID.test(id)) return false;
|
|
1364
|
+
}
|
|
1365
|
+
if (isRfqMarket(card)) {
|
|
1366
|
+
if (typeof card.discovery_pubkey !== "string" || !HEX_64.test(card.discovery_pubkey)) {
|
|
1367
|
+
return false;
|
|
1368
|
+
}
|
|
1369
|
+
if (!isRelayList(card.transports?.nostr?.relays)) return false;
|
|
1370
|
+
}
|
|
1371
|
+
return true;
|
|
1372
|
+
};
|
|
1373
|
+
var readCache = async (repository, network, registry) => {
|
|
1374
|
+
try {
|
|
1375
|
+
const entry = await repository.getCachedMarkets(network, registry);
|
|
1376
|
+
if (!Array.isArray(entry?.markets) || typeof entry?.fetchedAt !== "number") return;
|
|
1377
|
+
const markets = entry.markets.filter(isUsableCard);
|
|
1378
|
+
return { markets, fetchedAt: entry.fetchedAt };
|
|
1379
|
+
} catch {
|
|
1380
|
+
return void 0;
|
|
1381
|
+
}
|
|
1382
|
+
};
|
|
1383
|
+
var discoveryIndex = (input) => {
|
|
1384
|
+
const config = input.config ?? {};
|
|
1385
|
+
const network = config.network ?? input.network;
|
|
1386
|
+
const registry = config.registryUrl === void 0 ? isIndexedNetwork(network) ? REGISTRY_URL[network] : void 0 : config.registryUrl ?? void 0;
|
|
1387
|
+
const injected = config.snapshot && {
|
|
1388
|
+
markets: config.snapshot,
|
|
1389
|
+
ref: { fetchedAt: Date.now(), live: true, source: "injected" }
|
|
1390
|
+
};
|
|
1391
|
+
let held;
|
|
1392
|
+
const unavailable = (detail) => {
|
|
1393
|
+
throw new DiscoverySnapshotUnavailable(input.network, detail);
|
|
1394
|
+
};
|
|
1395
|
+
const sources = () => {
|
|
1396
|
+
if (!isIndexedNetwork(network)) return {};
|
|
1397
|
+
if (!registry) return {};
|
|
1398
|
+
return { network, registry };
|
|
1399
|
+
};
|
|
1400
|
+
const whyUnavailable = () => {
|
|
1401
|
+
if (!isIndexedNetwork(network)) return `no market index is published for ${network}`;
|
|
1402
|
+
if (!registry)
|
|
1403
|
+
return "the registry was disabled and no snapshot was injected (registryUrl: null)";
|
|
1404
|
+
return `the registry ${registry} could not be reached and nothing is cached`;
|
|
1405
|
+
};
|
|
1406
|
+
const fromCache = async () => {
|
|
1407
|
+
const { network: indexed, registry: url } = sources();
|
|
1408
|
+
if (!indexed || !url || !input.repository) return void 0;
|
|
1409
|
+
const cached = await readCache(input.repository, indexed, url);
|
|
1410
|
+
if (!cached) return void 0;
|
|
1411
|
+
return {
|
|
1412
|
+
markets: cached.markets,
|
|
1413
|
+
ref: {
|
|
1414
|
+
fetchedAt: cached.fetchedAt,
|
|
1415
|
+
// Whatever its age: nothing attests a registry ever served these cards.
|
|
1416
|
+
live: false,
|
|
1417
|
+
source: "cache",
|
|
1418
|
+
registry: url
|
|
1419
|
+
}
|
|
1420
|
+
};
|
|
1421
|
+
};
|
|
1422
|
+
const peek = async () => {
|
|
1423
|
+
if (injected) return injected;
|
|
1424
|
+
if (held) return held;
|
|
1425
|
+
const cached = await fromCache();
|
|
1426
|
+
if (cached) {
|
|
1427
|
+
held = cached;
|
|
1428
|
+
return cached;
|
|
1429
|
+
}
|
|
1430
|
+
return unavailable(whyUnavailable());
|
|
1431
|
+
};
|
|
1432
|
+
const load = async (opts = {}) => {
|
|
1433
|
+
if (injected) return injected;
|
|
1434
|
+
const fresh = held?.ref.live === true && Date.now() - held.ref.fetchedAt < MARKETS_CACHE_TTL_MS;
|
|
1435
|
+
if (fresh && !opts.refresh) return held;
|
|
1436
|
+
const { network: indexed, registry: url } = sources();
|
|
1437
|
+
if (!indexed || !url) {
|
|
1438
|
+
return unavailable(whyUnavailable());
|
|
1439
|
+
}
|
|
1440
|
+
const result = await discover({
|
|
1441
|
+
registries: [url],
|
|
1442
|
+
localCards: [...config.localCards ?? []],
|
|
1443
|
+
network: indexed,
|
|
1444
|
+
fetchImpl: config.fetchImpl
|
|
1445
|
+
});
|
|
1446
|
+
if (result.warnings.length) config.logger?.("solver discovery:", ...result.warnings);
|
|
1447
|
+
if (result.sources.some((source) => source.ok)) {
|
|
1448
|
+
const fetchedAt = Date.now();
|
|
1449
|
+
held = {
|
|
1450
|
+
markets: result.markets,
|
|
1451
|
+
ref: { fetchedAt, live: true, source: "live", registry: url }
|
|
1452
|
+
};
|
|
1453
|
+
if (input.repository) {
|
|
1454
|
+
try {
|
|
1455
|
+
await input.repository.saveCachedMarkets(indexed, url, {
|
|
1456
|
+
markets: result.markets,
|
|
1457
|
+
fetchedAt
|
|
1458
|
+
});
|
|
1459
|
+
} catch {
|
|
1460
|
+
}
|
|
1461
|
+
}
|
|
1462
|
+
return held;
|
|
1463
|
+
}
|
|
1464
|
+
const cached = await fromCache();
|
|
1465
|
+
if (cached) {
|
|
1466
|
+
held = cached;
|
|
1467
|
+
return cached;
|
|
1468
|
+
}
|
|
1469
|
+
return unavailable(whyUnavailable());
|
|
1470
|
+
};
|
|
1471
|
+
return { peek, load };
|
|
1472
|
+
};
|
|
1473
|
+
|
|
1474
|
+
// src/client/driveRecords.ts
|
|
1475
|
+
import {
|
|
1476
|
+
ArkAddress as ArkAddress2,
|
|
1477
|
+
asset as asset3,
|
|
1478
|
+
assertPageRequest,
|
|
1479
|
+
pageResult
|
|
1480
|
+
} from "@arkade-os/sdk";
|
|
1481
|
+
import { sha256 } from "@noble/hashes/sha2.js";
|
|
1482
|
+
import { hex as hex3 } from "@scure/base";
|
|
1483
|
+
var splitRecords = (records) => {
|
|
1484
|
+
const corridor = [];
|
|
1485
|
+
const offer = [];
|
|
1486
|
+
for (const record of records) {
|
|
1487
|
+
if (record.family === "rfq") corridor.push(record);
|
|
1488
|
+
else offer.push(record);
|
|
1489
|
+
}
|
|
1490
|
+
return { corridor, offer };
|
|
1491
|
+
};
|
|
1492
|
+
var rfqRecordOf = (record) => ({
|
|
1493
|
+
kind: record.kind,
|
|
1494
|
+
lockupAddress: record.lockupAddress,
|
|
1495
|
+
profile: record.profile,
|
|
1496
|
+
...record.fundingTxid === void 0 ? {} : { fundingTxid: record.fundingTxid },
|
|
1497
|
+
rfqId: record.rfqId,
|
|
1498
|
+
state: record.state,
|
|
1499
|
+
createdAt: record.createdAt,
|
|
1500
|
+
updatedAt: record.updatedAt,
|
|
1501
|
+
...mutableHalfOf(record)
|
|
1502
|
+
});
|
|
1503
|
+
var mutableHalfOf = (from) => ({
|
|
1504
|
+
...from.refundTxid === void 0 ? {} : { refundTxid: from.refundTxid },
|
|
1505
|
+
...from.lockupSpendTxids?.length ? { lockupSpendTxids: [...from.lockupSpendTxids] } : {},
|
|
1506
|
+
...from.settlementPreimageHex === void 0 ? {} : { settlementPreimageHex: from.settlementPreimageHex },
|
|
1507
|
+
...from.failure === void 0 ? {} : { failure: from.failure },
|
|
1508
|
+
...from.claimFailure === void 0 ? {} : { claimFailure: from.claimFailure },
|
|
1509
|
+
...from.blockedReason === void 0 ? {} : { blockedReason: from.blockedReason }
|
|
1510
|
+
});
|
|
1511
|
+
var withRfqState = (record, state) => {
|
|
1512
|
+
const {
|
|
1513
|
+
refundTxid: _refundTxid,
|
|
1514
|
+
lockupSpendTxids: _lockupSpendTxids,
|
|
1515
|
+
settlementPreimageHex: _settlementPreimageHex,
|
|
1516
|
+
failure: _failure,
|
|
1517
|
+
claimFailure: _claimFailure,
|
|
1518
|
+
blockedReason: _blockedReason,
|
|
1519
|
+
...origin
|
|
1520
|
+
} = record;
|
|
1521
|
+
return {
|
|
1522
|
+
...origin,
|
|
1523
|
+
state: state.state,
|
|
1524
|
+
profile: state.profile,
|
|
1525
|
+
updatedAt: state.updatedAt,
|
|
1526
|
+
...mutableHalfOf(state)
|
|
1527
|
+
};
|
|
1528
|
+
};
|
|
1529
|
+
var pageRfqRecords = (records, filter, page) => {
|
|
1530
|
+
const rows = records.filter(
|
|
1531
|
+
(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)
|
|
1532
|
+
).sort(
|
|
1533
|
+
(a, b) => a.updatedAt - b.updatedAt || (a.rfqId < b.rfqId ? -1 : a.rfqId > b.rfqId ? 1 : 0)
|
|
1534
|
+
).slice(0, page.limit + 1);
|
|
1535
|
+
return pageResult(rows, page.limit, (record) => ({
|
|
1536
|
+
updatedAt: record.updatedAt,
|
|
1537
|
+
rfqId: record.rfqId
|
|
1538
|
+
}));
|
|
1539
|
+
};
|
|
1540
|
+
var corridorRecordStore = (repository, onRecord = () => {
|
|
1541
|
+
}, admits = () => true) => {
|
|
1542
|
+
const byRfqId = /* @__PURE__ */ new Map();
|
|
1543
|
+
const index = (record) => {
|
|
1544
|
+
byRfqId.set(record.rfqId, record.id);
|
|
1545
|
+
};
|
|
1546
|
+
const recordFor = async (rfqId) => {
|
|
1547
|
+
const known = byRfqId.get(rfqId);
|
|
1548
|
+
if (known !== void 0) {
|
|
1549
|
+
const record = await repository.getSwapRecord(known);
|
|
1550
|
+
if (record?.family === "rfq") return record;
|
|
1551
|
+
}
|
|
1552
|
+
const { corridor } = splitRecords(await collectSwapRecords(repository));
|
|
1553
|
+
for (const record of corridor) index(record);
|
|
1554
|
+
const found = byRfqId.get(rfqId);
|
|
1555
|
+
return found === void 0 ? void 0 : corridor.find((r) => r.id === found);
|
|
1556
|
+
};
|
|
1557
|
+
return {
|
|
1558
|
+
index,
|
|
1559
|
+
quoteIdOf: (rfqId) => byRfqId.get(rfqId),
|
|
1560
|
+
async getRfqSwapsPage(filter, page) {
|
|
1561
|
+
assertPageRequest(page);
|
|
1562
|
+
assertRfqSwapPageFilter(filter);
|
|
1563
|
+
const { corridor } = splitRecords(await collectSwapRecords(repository));
|
|
1564
|
+
for (const record of corridor) index(record);
|
|
1565
|
+
return pageRfqRecords(corridor.filter(admits).map(rfqRecordOf), filter, page);
|
|
1566
|
+
},
|
|
1567
|
+
async getRfqSwap(rfqId) {
|
|
1568
|
+
const record = await recordFor(rfqId);
|
|
1569
|
+
return record === void 0 ? void 0 : rfqRecordOf(record);
|
|
1570
|
+
},
|
|
1571
|
+
async saveRfqSwap(state) {
|
|
1572
|
+
const record = await recordFor(state.rfqId);
|
|
1573
|
+
if (record === void 0) {
|
|
1574
|
+
throw new Error(
|
|
1575
|
+
`no v2 swap record for rfq ${state.rfqId}; the drive cannot write its state`
|
|
1576
|
+
);
|
|
1577
|
+
}
|
|
1578
|
+
const updated = withRfqState(record, state);
|
|
1579
|
+
await repository.saveSwapRecord(updated);
|
|
1580
|
+
onRecord(updated);
|
|
1581
|
+
},
|
|
1582
|
+
async removeRfqSwap() {
|
|
1583
|
+
}
|
|
1584
|
+
};
|
|
1585
|
+
};
|
|
1586
|
+
var offerFactsOf = (record) => ({
|
|
1587
|
+
id: record.id,
|
|
1588
|
+
status: record.status,
|
|
1589
|
+
offerHex: record.offerHex,
|
|
1590
|
+
swapPkScript: record.swapPkScript,
|
|
1591
|
+
...record.fundingTxid === void 0 ? {} : { fundingTxid: record.fundingTxid },
|
|
1592
|
+
...record.spentTxid === void 0 ? {} : { spentTxid: record.spentTxid },
|
|
1593
|
+
// milliseconds: `coverage.ts` compares against `Date.now()`, and seconds would leave every
|
|
1594
|
+
// issued script outstanding for the life of the process
|
|
1595
|
+
createdAt: record.createdAt * 1e3
|
|
1596
|
+
});
|
|
1597
|
+
var offerRecordSource = (repository, onRecord = () => {
|
|
1598
|
+
}, now = () => Math.floor(Date.now() / 1e3)) => {
|
|
1599
|
+
const list = async () => {
|
|
1600
|
+
const { offer } = splitRecords(await collectSwapRecords(repository));
|
|
1601
|
+
return offer.map(offerFactsOf);
|
|
1602
|
+
};
|
|
1603
|
+
return {
|
|
1604
|
+
list,
|
|
1605
|
+
async apply(swap, changes) {
|
|
1606
|
+
const stored = await repository.getSwapRecord(swap.id);
|
|
1607
|
+
if (stored === void 0 || stored.family !== "offer") {
|
|
1608
|
+
return { persisted: false, swaps: await list() };
|
|
1609
|
+
}
|
|
1610
|
+
const updated = applyOfferSpend(stored, changes, now());
|
|
1611
|
+
try {
|
|
1612
|
+
await repository.saveSwapRecord(updated);
|
|
1613
|
+
onRecord(updated);
|
|
1614
|
+
const swaps = (await list()).map(
|
|
1615
|
+
(s) => s.id === updated.id ? offerFactsOf(updated) : s
|
|
1616
|
+
);
|
|
1617
|
+
return { persisted: true, swaps };
|
|
1618
|
+
} catch (error) {
|
|
1619
|
+
console.warn(`[swap] failed to persist offer spend for ${swap.id}`, error);
|
|
1620
|
+
return { persisted: false, swaps: await list() };
|
|
1621
|
+
}
|
|
1622
|
+
}
|
|
1623
|
+
};
|
|
1624
|
+
};
|
|
1625
|
+
var applyOfferSpend = (record, changes, now) => ({
|
|
1626
|
+
...record,
|
|
1627
|
+
status: changes.status,
|
|
1628
|
+
spentTxid: changes.spentTxid,
|
|
1629
|
+
// event timestamps are milliseconds; this record's are unix seconds
|
|
1630
|
+
...changes.completedAt === void 0 ? {} : { completedAt: Math.floor(changes.completedAt / 1e3) },
|
|
1631
|
+
updatedAt: now
|
|
1632
|
+
});
|
|
1633
|
+
var withDepositFate = (record, fate, now) => ({
|
|
1634
|
+
...record,
|
|
1635
|
+
status: fate.status,
|
|
1636
|
+
...fate.spentTxid === void 0 ? {} : { spentTxid: fate.spentTxid },
|
|
1637
|
+
...fate.completedAt === void 0 ? {} : { completedAt: Math.floor(fate.completedAt / 1e3) },
|
|
1638
|
+
updatedAt: now
|
|
1639
|
+
});
|
|
1640
|
+
var fateMoved = (record, fate) => record.status !== fate.status || fate.spentTxid !== void 0 && record.spentTxid !== fate.spentTxid || fate.completedAt !== void 0 && record.completedAt !== Math.floor(fate.completedAt / 1e3);
|
|
1641
|
+
var restoredOfferRecord = (swap, network, now) => {
|
|
1642
|
+
const give = restoredAssetId(network, swap.fromAsset);
|
|
1643
|
+
const take = restoredAssetId(network, swap.toAsset);
|
|
1644
|
+
const createdAt = Math.floor(swap.createdAt / 1e3);
|
|
1645
|
+
return withDepositFate(
|
|
1646
|
+
{
|
|
1647
|
+
id: swap.fundingTxid,
|
|
1648
|
+
family: "offer",
|
|
1649
|
+
route: {
|
|
1650
|
+
give: { corridor: "arkade", asset: give, instrument: { kind: "wallet" } },
|
|
1651
|
+
take: { corridor: "arkade", asset: take, instrument: { kind: "wallet" } }
|
|
1652
|
+
},
|
|
1653
|
+
give: { asset: give, amount: toAtomicDecimal(BigInt(swap.fromAmount)) },
|
|
1654
|
+
take: { asset: take, amount: toAtomicDecimal(BigInt(swap.toAmount)) },
|
|
1655
|
+
fee: { asset: take, amount: toAtomicDecimal(0n) },
|
|
1656
|
+
market: { kind: "restored", backend: "feed" },
|
|
1657
|
+
expiresAt: createdAt,
|
|
1658
|
+
status: swap.status,
|
|
1659
|
+
offerHex: swap.offerHex,
|
|
1660
|
+
swapAddress: swap.swapAddress,
|
|
1661
|
+
swapPkScript: swap.swapPkScript,
|
|
1662
|
+
fundingTxid: swap.fundingTxid,
|
|
1663
|
+
createdAt,
|
|
1664
|
+
updatedAt: now
|
|
1665
|
+
},
|
|
1666
|
+
swap,
|
|
1667
|
+
now
|
|
1668
|
+
);
|
|
1669
|
+
};
|
|
1670
|
+
var restoredAssetId = (network, id) => id === BTC_ASSET_ID ? btcOn("arkade", network) : arkadeAsset(network, asset3.AssetId.fromString(id));
|
|
1671
|
+
var RESTORED_CORRIDORS = {
|
|
1672
|
+
lightning_send: ["arkade", "lightning"],
|
|
1673
|
+
lightning_receive: ["lightning", "arkade"],
|
|
1674
|
+
onchain_send: ["arkade", "onchain"]
|
|
1675
|
+
};
|
|
1676
|
+
var restoredCorridorRecord = (stored, network, refundLocktime) => {
|
|
1677
|
+
const v1 = normalizeRfqSwapRecord(stored);
|
|
1678
|
+
const hashlock = v1.profile.hashlock;
|
|
1679
|
+
const hash = typeof hashlock?.paymentHash === "string" ? hashlock.paymentHash : v1.settlementPreimageHex === void 0 ? void 0 : hex3.encode(sha256(hex3.decode(v1.settlementPreimageHex)));
|
|
1680
|
+
if (hash === void 0) throw new Error(`v1 rfq swap ${v1.rfqId} has no payment hash`);
|
|
1681
|
+
const [giveCorridor, takeCorridor] = RESTORED_CORRIDORS[v1.kind];
|
|
1682
|
+
const give = btcOn(railOfCorridor(giveCorridor), network);
|
|
1683
|
+
const take = btcOn(railOfCorridor(takeCorridor), network);
|
|
1684
|
+
const amount = toAtomicDecimal(BigInt(v1.amount ?? 0));
|
|
1685
|
+
return {
|
|
1686
|
+
id: v1.rfqId,
|
|
1687
|
+
family: "rfq",
|
|
1688
|
+
route: {
|
|
1689
|
+
give: { corridor: giveCorridor, asset: give, instrument: { kind: "wallet" } },
|
|
1690
|
+
take: { corridor: takeCorridor, asset: take, instrument: { kind: "wallet" } }
|
|
1691
|
+
},
|
|
1692
|
+
give: { asset: give, amount },
|
|
1693
|
+
take: { asset: take, amount },
|
|
1694
|
+
fee: { asset: give, amount: toAtomicDecimal(0n) },
|
|
1695
|
+
market: { kind: "restored", backend: "rfq" },
|
|
1696
|
+
expiresAt: v1.createdAt,
|
|
1697
|
+
state: v1.state,
|
|
1698
|
+
kind: v1.kind,
|
|
1699
|
+
rfqId: v1.rfqId,
|
|
1700
|
+
lockupAddress: v1.lockupAddress,
|
|
1701
|
+
lockupPkScript: hex3.encode(ArkAddress2.decode(v1.lockupAddress).pkScript),
|
|
1702
|
+
lock: { hash },
|
|
1703
|
+
refundLocktime,
|
|
1704
|
+
profile: v1.profile,
|
|
1705
|
+
...v1.fundingTxid === void 0 ? {} : { fundingTxid: v1.fundingTxid },
|
|
1706
|
+
...mutableHalfOf(v1),
|
|
1707
|
+
createdAt: v1.createdAt,
|
|
1708
|
+
updatedAt: v1.updatedAt
|
|
1709
|
+
};
|
|
1710
|
+
};
|
|
1711
|
+
var walletLockupIndexer = (wallet) => {
|
|
1712
|
+
let reader;
|
|
1713
|
+
const reading = () => reader ??= wallet.getArkadeReader();
|
|
1714
|
+
return {
|
|
1715
|
+
getVtxos: async (opts) => {
|
|
1716
|
+
if (!opts) {
|
|
1717
|
+
throw new Error("getVtxos on the swap indexer requires scripts or outpoints");
|
|
1718
|
+
}
|
|
1719
|
+
return (await reading()).getVtxos(opts);
|
|
1720
|
+
},
|
|
1721
|
+
getVirtualTxs: async (...args) => (await reading()).getVirtualTxs(...args)
|
|
1722
|
+
};
|
|
1723
|
+
};
|
|
1724
|
+
|
|
1725
|
+
// src/client/cancel.ts
|
|
1726
|
+
import { base64, hex as hex4 } from "@scure/base";
|
|
1727
|
+
import { ArkAddress as ArkAddress3, Transaction } from "@arkade-os/sdk";
|
|
1728
|
+
var cancelSwap = async (input) => {
|
|
1729
|
+
const { wallet, repository, record, drive, indexer } = input;
|
|
1730
|
+
const now = input.now ?? (() => Math.floor(Date.now() / 1e3));
|
|
1731
|
+
const outcome = offerOutcome(record.status);
|
|
1732
|
+
if (outcome === "cancelled" || outcome === "filled" || outcome === "needs_recovery") {
|
|
1733
|
+
return { outcome };
|
|
1734
|
+
}
|
|
1735
|
+
const gated2 = withStatus(record, "cancelling", now());
|
|
1736
|
+
await repository.saveSwapRecord(gated2);
|
|
1737
|
+
drive.ingest(gated2);
|
|
1738
|
+
let prepared;
|
|
1739
|
+
try {
|
|
1740
|
+
prepared = await prepareOfferCancel(wallet, record.offerHex, {
|
|
1741
|
+
swapAddress: record.swapAddress,
|
|
1742
|
+
...record.fundingTxid === void 0 ? {} : { fundingTxid: record.fundingTxid }
|
|
1743
|
+
});
|
|
1744
|
+
} catch (error) {
|
|
1745
|
+
if (error instanceof OfferCovenantMismatchError) {
|
|
1746
|
+
const rolledBack = withStatus(record, record.status, now());
|
|
1747
|
+
try {
|
|
1748
|
+
await repository.saveSwapRecord(rolledBack);
|
|
1749
|
+
} catch (rollbackError) {
|
|
1750
|
+
console.warn(
|
|
1751
|
+
`[swap] could not roll back cancel gate for ${record.id}`,
|
|
1752
|
+
rollbackError
|
|
1753
|
+
);
|
|
1754
|
+
}
|
|
1755
|
+
drive.ingest(rolledBack);
|
|
1756
|
+
throw error;
|
|
1757
|
+
}
|
|
1758
|
+
if (error instanceof NoSpendableDepositError) {
|
|
1759
|
+
const reconciled = await reconcileDepositSpend(record, indexer);
|
|
1760
|
+
if (reconciled === void 0) {
|
|
1761
|
+
return { outcome: "needs_recovery" };
|
|
1762
|
+
}
|
|
1763
|
+
const { kind, spentTxid } = reconciled;
|
|
1764
|
+
const settled2 = withStatus(gated2, kind, now(), {
|
|
1765
|
+
spentTxid,
|
|
1766
|
+
// Mirrors the watcher: a completion time is a fill's, not a
|
|
1767
|
+
// cancel's.
|
|
1768
|
+
...kind === "fulfilled" ? { completedAt: now() } : {}
|
|
1769
|
+
});
|
|
1770
|
+
const { persisted: persisted2 } = await persistBestEffort(repository, settled2);
|
|
1771
|
+
drive.ingest(settled2);
|
|
1772
|
+
if (persisted2) await retireOfferScripts(wallet, repository, settled2);
|
|
1773
|
+
return { outcome: kind === "cancelled" ? "cancelled" : "filled" };
|
|
1774
|
+
}
|
|
1775
|
+
throw error;
|
|
1776
|
+
}
|
|
1777
|
+
const txid = await prepared.send();
|
|
1778
|
+
const settled = withStatus(gated2, "cancelled", now(), { spentTxid: txid });
|
|
1779
|
+
const { persisted } = await persistBestEffort(repository, settled);
|
|
1780
|
+
drive.ingest(settled);
|
|
1781
|
+
if (persisted) {
|
|
1782
|
+
await retireOfferScripts(wallet, repository, settled);
|
|
1783
|
+
}
|
|
1784
|
+
return { outcome: "cancelled" };
|
|
1785
|
+
};
|
|
1786
|
+
var reconcileDepositSpend = async (record, indexer) => {
|
|
1787
|
+
const offer = decodeOffer(hex4.decode(record.offerHex));
|
|
1788
|
+
const { vtxos } = await indexer.getVtxos({ scripts: [record.swapPkScript] });
|
|
1789
|
+
const all = vtxos ?? [];
|
|
1790
|
+
const deposit = record.fundingTxid === void 0 ? all.length === 1 ? all[0] : void 0 : all.find((vtxo) => vtxo.txid === record.fundingTxid);
|
|
1791
|
+
if (deposit === void 0) return void 0;
|
|
1792
|
+
const candidates = spendTxidsOf(deposit);
|
|
1793
|
+
if (candidates.length === 0) return void 0;
|
|
1794
|
+
const spentTxid = deposit.arkTxId || deposit.spentBy;
|
|
1795
|
+
if (!spentTxid) return void 0;
|
|
1796
|
+
const { txs } = await indexer.getVirtualTxs(candidates);
|
|
1797
|
+
const parsed = txs.map((psbt) => {
|
|
1798
|
+
try {
|
|
1799
|
+
return Transaction.fromPSBT(base64.decode(psbt));
|
|
1800
|
+
} catch {
|
|
1801
|
+
return void 0;
|
|
1802
|
+
}
|
|
1803
|
+
}).filter((tx) => tx !== void 0);
|
|
1804
|
+
const operatorPubkey = ArkAddress3.decode(record.swapAddress).serverPubKey;
|
|
1805
|
+
const kind = classifyDepositSpend(offer, operatorPubkey, parsed, {
|
|
1806
|
+
txid: deposit.txid,
|
|
1807
|
+
vout: deposit.vout
|
|
1808
|
+
});
|
|
1809
|
+
if (kind === "indeterminate") return void 0;
|
|
1810
|
+
return { kind, spentTxid };
|
|
1811
|
+
};
|
|
1812
|
+
var withStatus = (record, status, now, extra = {}) => ({
|
|
1813
|
+
...record,
|
|
1814
|
+
status,
|
|
1815
|
+
...extra.spentTxid === void 0 ? {} : { spentTxid: extra.spentTxid },
|
|
1816
|
+
...extra.completedAt === void 0 ? {} : { completedAt: extra.completedAt },
|
|
1817
|
+
updatedAt: now
|
|
1818
|
+
});
|
|
1819
|
+
var persistBestEffort = async (repository, record) => {
|
|
1820
|
+
try {
|
|
1821
|
+
await repository.saveSwapRecord(record);
|
|
1822
|
+
return { persisted: true };
|
|
1823
|
+
} catch (error) {
|
|
1824
|
+
console.warn(`[swap] could not persist cancel for ${record.id}`, error);
|
|
1825
|
+
return { persisted: false };
|
|
1826
|
+
}
|
|
1827
|
+
};
|
|
1828
|
+
var retireOfferScripts = async (wallet, repository, record) => {
|
|
1829
|
+
try {
|
|
1830
|
+
const { offer } = splitRecords(await collectSwapRecords(repository));
|
|
1831
|
+
await retireOfferContract(
|
|
1832
|
+
await wallet.getContractManager(),
|
|
1833
|
+
offer.map(offerFactsOf),
|
|
1834
|
+
record.swapPkScript
|
|
1835
|
+
);
|
|
1836
|
+
} catch (error) {
|
|
1837
|
+
console.warn(`[swap] could not retire offer script for ${record.id}`, error);
|
|
1838
|
+
}
|
|
1839
|
+
};
|
|
1840
|
+
|
|
1841
|
+
// src/client/drive.ts
|
|
1842
|
+
import {
|
|
1843
|
+
ArkAddress as ArkAddress4,
|
|
1844
|
+
contractSigner,
|
|
1845
|
+
getNetwork as getNetwork2,
|
|
1846
|
+
identityDescriptor
|
|
1847
|
+
} from "@arkade-os/sdk";
|
|
1848
|
+
import { hex as hex5 } from "@scure/base";
|
|
1849
|
+
|
|
1850
|
+
// src/client/legacyRecords.ts
|
|
1851
|
+
import { assertPageRequest as assertPageRequest2 } from "@arkade-os/sdk";
|
|
1852
|
+
var readLegacyRfqSwaps = async (repository, filter = {}) => {
|
|
1853
|
+
try {
|
|
1854
|
+
return await collectRfqSwaps(repository, filter);
|
|
1855
|
+
} catch (error) {
|
|
1856
|
+
console.warn("[swap] the v1 rfq swaps could not be read", error);
|
|
1857
|
+
return [];
|
|
1858
|
+
}
|
|
1859
|
+
};
|
|
1860
|
+
var legacyLiveRfqSwaps = async (repository) => (await readLegacyRfqSwaps(repository)).filter((record) => !isRfqSwapTerminal(record.state));
|
|
1861
|
+
var withLegacyRfqSwaps = (bridge, repository, admits) => {
|
|
1862
|
+
const legacy = /* @__PURE__ */ new Set();
|
|
1863
|
+
return {
|
|
1864
|
+
index: bridge.index,
|
|
1865
|
+
quoteIdOf: bridge.quoteIdOf,
|
|
1866
|
+
async getRfqSwapsPage(filter, page) {
|
|
1867
|
+
assertPageRequest2(page);
|
|
1868
|
+
assertRfqSwapPageFilter(filter);
|
|
1869
|
+
const v2 = await collectRfqSwaps(bridge, filter);
|
|
1870
|
+
const held = new Set(
|
|
1871
|
+
splitRecords(await collectSwapRecords(repository)).corridor.map((r) => r.rfqId)
|
|
1872
|
+
);
|
|
1873
|
+
const v1 = (await readLegacyRfqSwaps(repository, filter)).filter(
|
|
1874
|
+
(record) => !held.has(record.rfqId) && admits(record)
|
|
1875
|
+
);
|
|
1876
|
+
for (const record of v1) legacy.add(record.rfqId);
|
|
1877
|
+
return pageRfqRecords([...v2, ...v1], filter, page);
|
|
1878
|
+
},
|
|
1879
|
+
async getRfqSwap(rfqId) {
|
|
1880
|
+
if (!legacy.has(rfqId)) {
|
|
1881
|
+
const record2 = await bridge.getRfqSwap(rfqId);
|
|
1882
|
+
if (record2 !== void 0) return record2;
|
|
1883
|
+
}
|
|
1884
|
+
const record = await repository.getRfqSwap(rfqId);
|
|
1885
|
+
if (record !== void 0) legacy.add(rfqId);
|
|
1886
|
+
return record;
|
|
1887
|
+
},
|
|
1888
|
+
async saveRfqSwap(record) {
|
|
1889
|
+
if (legacy.has(record.rfqId)) await repository.saveRfqSwap(record);
|
|
1890
|
+
else await bridge.saveRfqSwap(record);
|
|
1891
|
+
},
|
|
1892
|
+
removeRfqSwap: (rfqId) => bridge.removeRfqSwap(rfqId)
|
|
1893
|
+
};
|
|
1894
|
+
};
|
|
1895
|
+
var legacyRfqSwapsToAdopt = async (repository) => {
|
|
1896
|
+
const v1 = await readLegacyRfqSwaps(repository);
|
|
1897
|
+
if (v1.length === 0) return [];
|
|
1898
|
+
const records = await collectSwapRecords(repository);
|
|
1899
|
+
const held = new Set(splitRecords(records).corridor.map((record) => record.rfqId));
|
|
1900
|
+
const ids = new Set(records.map((record) => record.id));
|
|
1901
|
+
return v1.filter((record) => {
|
|
1902
|
+
if (held.has(record.rfqId)) return false;
|
|
1903
|
+
if (ids.has(record.rfqId)) {
|
|
1904
|
+
console.warn(`[swap] v1 rfq swap ${record.rfqId} collides with a v2 record id`);
|
|
1905
|
+
return false;
|
|
1906
|
+
}
|
|
1907
|
+
return true;
|
|
1908
|
+
});
|
|
1909
|
+
};
|
|
1910
|
+
var readLegacyAssetSwaps = async (repository) => {
|
|
1911
|
+
try {
|
|
1912
|
+
return await collectAssetSwaps(repository);
|
|
1913
|
+
} catch (error) {
|
|
1914
|
+
console.warn("[swap] the v1 swaps could not be read", error);
|
|
1915
|
+
return [];
|
|
1916
|
+
}
|
|
1917
|
+
};
|
|
1918
|
+
var legacyOfferDepositsToAdopt = async (repository) => {
|
|
1919
|
+
const unadopted = (await readLegacyAssetSwaps(repository)).filter(
|
|
1920
|
+
(swap) => !!swap.offerHex && !!swap.fundingTxid
|
|
1921
|
+
);
|
|
1922
|
+
if (unadopted.length === 0) return /* @__PURE__ */ new Set();
|
|
1923
|
+
const { offer } = splitRecords(await collectSwapRecords(repository));
|
|
1924
|
+
const adopted = new Set(offer.map((record) => record.fundingTxid));
|
|
1925
|
+
return new Set(unadopted.map((swap) => swap.fundingTxid).filter((txid) => !adopted.has(txid)));
|
|
1926
|
+
};
|
|
1927
|
+
|
|
1928
|
+
// src/client/drive.ts
|
|
1929
|
+
var SwapDriveRefusedError = class extends Error {
|
|
1930
|
+
constructor(reason, detail, swapId) {
|
|
1931
|
+
super(detail);
|
|
1932
|
+
this.reason = reason;
|
|
1933
|
+
this.swapId = swapId;
|
|
1934
|
+
}
|
|
1935
|
+
reason;
|
|
1936
|
+
swapId;
|
|
1937
|
+
name = "SwapDriveRefusedError";
|
|
1938
|
+
};
|
|
1939
|
+
var OFFER_LIVE = (status) => status === "pending" || status === "cancelling";
|
|
1940
|
+
var traderClaimTxid = (swap) => swap.kind === "lightning_send" ? void 0 : swap.claimTxid;
|
|
1941
|
+
var readableRecord = (record) => {
|
|
1942
|
+
if (typeof record?.id !== "string" || record.route?.give === void 0) return false;
|
|
1943
|
+
if (record.family === "rfq") {
|
|
1944
|
+
return typeof record.rfqId === "string" && typeof record.lockupAddress === "string";
|
|
1945
|
+
}
|
|
1946
|
+
return record.family === "offer" && typeof record.offerHex === "string";
|
|
1947
|
+
};
|
|
1948
|
+
var createSwapDrive = (config) => {
|
|
1949
|
+
const { wallet, operator, repository, corridors, indexer } = config;
|
|
1950
|
+
const mode = config.mode ?? "auto";
|
|
1951
|
+
const now = config.now ?? (() => Math.floor(Date.now() / 1e3));
|
|
1952
|
+
const records = /* @__PURE__ */ new Map();
|
|
1953
|
+
const live = /* @__PURE__ */ new Map();
|
|
1954
|
+
const refunding = /* @__PURE__ */ new Set();
|
|
1955
|
+
const swept = /* @__PURE__ */ new Map();
|
|
1956
|
+
const recoveredIn = /* @__PURE__ */ new Set();
|
|
1957
|
+
const passed = /* @__PURE__ */ new Set();
|
|
1958
|
+
const delivered = /* @__PURE__ */ new Map();
|
|
1959
|
+
const listeners = /* @__PURE__ */ new Set();
|
|
1960
|
+
let disposed = false;
|
|
1961
|
+
let startRequested = mode === "auto";
|
|
1962
|
+
let watcher;
|
|
1963
|
+
let readyPromise;
|
|
1964
|
+
const inFlight = /* @__PURE__ */ new Set();
|
|
1965
|
+
let queue = Promise.resolve();
|
|
1966
|
+
const track = (work) => {
|
|
1967
|
+
inFlight.add(work);
|
|
1968
|
+
void work.then(
|
|
1969
|
+
() => inFlight.delete(work),
|
|
1970
|
+
() => inFlight.delete(work)
|
|
1971
|
+
);
|
|
1972
|
+
return work;
|
|
1973
|
+
};
|
|
1974
|
+
const enqueue = (task) => {
|
|
1975
|
+
queue = queue.then(task).catch((error) => {
|
|
1976
|
+
console.warn("[swap] the drive could not register a swap", error);
|
|
1977
|
+
});
|
|
1978
|
+
};
|
|
1979
|
+
const idle = async () => {
|
|
1980
|
+
do {
|
|
1981
|
+
await queue;
|
|
1982
|
+
await Promise.allSettled([...inFlight]);
|
|
1983
|
+
await watcher?.idle();
|
|
1984
|
+
} while (inFlight.size > 0);
|
|
1985
|
+
};
|
|
1986
|
+
const remember = (record) => {
|
|
1987
|
+
records.set(record.id, record);
|
|
1988
|
+
emit(record.id);
|
|
1989
|
+
};
|
|
1990
|
+
const storage = () => {
|
|
1991
|
+
if (!repository) throw new Error("the drive has no repository");
|
|
1992
|
+
return repository;
|
|
1993
|
+
};
|
|
1994
|
+
const undrivable = /* @__PURE__ */ new Set();
|
|
1995
|
+
const undrivableLegacy = /* @__PURE__ */ new Set();
|
|
1996
|
+
let bridge;
|
|
1997
|
+
let readThrough;
|
|
1998
|
+
const corridorStore = () => (
|
|
1999
|
+
// LEGACY(v1): unwrap to `bridge` alone once the read-through goes.
|
|
2000
|
+
readThrough ??= withLegacyRfqSwaps(
|
|
2001
|
+
bridge ??= corridorRecordStore(
|
|
2002
|
+
storage(),
|
|
2003
|
+
remember,
|
|
2004
|
+
// Terminal records stay readable but are excluded from the manager's read, sparing
|
|
2005
|
+
// a rebuild per record just to file it `finished`. The index still learns their
|
|
2006
|
+
// `rfqId` (see `getRfqSwapsPage`).
|
|
2007
|
+
(r) => !undrivable.has(r.id) && !isRfqSwapTerminal(r.state)
|
|
2008
|
+
),
|
|
2009
|
+
storage(),
|
|
2010
|
+
(r) => !undrivableLegacy.has(r.rfqId) && !isRfqSwapTerminal(r.state)
|
|
2011
|
+
)
|
|
2012
|
+
);
|
|
2013
|
+
const effectiveState = (swap) => {
|
|
2014
|
+
if (mode === "auto") return swap.state;
|
|
2015
|
+
if (swap.state !== "needs_counterparty") return swap.state;
|
|
2016
|
+
if (!isRfqConfigurationRefusal(swap.blockedReason)) return swap.state;
|
|
2017
|
+
return traderClaimTxid(swap) ? "claimed" : "pending";
|
|
2018
|
+
};
|
|
2019
|
+
const outcomeOfEntry = (record, current) => {
|
|
2020
|
+
if (record.family === "offer") return recordOutcome(record);
|
|
2021
|
+
if (current === void 0) {
|
|
2022
|
+
if (isRfqSwapTerminal(record.state)) return corridorOutcome(record.kind, record.state);
|
|
2023
|
+
return recordOutcome(record);
|
|
2024
|
+
}
|
|
2025
|
+
const state = effectiveState(current);
|
|
2026
|
+
if (state === "pending" && !passed.has(record.id)) return recordOutcome(record);
|
|
2027
|
+
if (isRfqSwapTerminal(state)) return corridorOutcome(current.kind, state);
|
|
2028
|
+
if (LOCKUP_OWNER[current.kind] === "trader" && refunding.has(record.id) && now() >= current.refundLocktime) {
|
|
2029
|
+
return "refunding";
|
|
2030
|
+
}
|
|
2031
|
+
if (swept.has(record.id)) return "needs_recovery";
|
|
2032
|
+
return corridorOutcome(current.kind, state);
|
|
2033
|
+
};
|
|
2034
|
+
const detailOf = (record, current) => record.family === "offer" ? { family: "offer", status: record.status } : { family: "rfq", state: current?.state ?? record.state };
|
|
2035
|
+
const publicSwap = (record, outcome, current) => {
|
|
2036
|
+
const base = swapOf(record, outcome);
|
|
2037
|
+
if (current === void 0) return base;
|
|
2038
|
+
const { failure: _failure, blockedReason: _blockedReason, ...rest } = base;
|
|
2039
|
+
return {
|
|
2040
|
+
...rest,
|
|
2041
|
+
...current.failure === void 0 ? {} : { failure: current.failure },
|
|
2042
|
+
...current.blockedReason === void 0 ? {} : { blockedReason: current.blockedReason }
|
|
2043
|
+
};
|
|
2044
|
+
};
|
|
2045
|
+
const updateFor = (id) => {
|
|
2046
|
+
const record = records.get(id);
|
|
2047
|
+
if (record === void 0) return void 0;
|
|
2048
|
+
const current = live.get(id);
|
|
2049
|
+
const outcome = outcomeOfEntry(record, current);
|
|
2050
|
+
return {
|
|
2051
|
+
swap: publicSwap(record, outcome, current),
|
|
2052
|
+
outcome,
|
|
2053
|
+
detail: detailOf(record, current)
|
|
2054
|
+
};
|
|
2055
|
+
};
|
|
2056
|
+
const deliver = (update, to) => {
|
|
2057
|
+
for (const listener of to) {
|
|
2058
|
+
try {
|
|
2059
|
+
listener(update);
|
|
2060
|
+
} catch {
|
|
2061
|
+
}
|
|
2062
|
+
}
|
|
2063
|
+
};
|
|
2064
|
+
function emit(id) {
|
|
2065
|
+
const update = updateFor(id);
|
|
2066
|
+
if (update === void 0) return;
|
|
2067
|
+
if (delivered.get(id) === update.outcome) return;
|
|
2068
|
+
delivered.set(id, update.outcome);
|
|
2069
|
+
deliver(update, listeners);
|
|
2070
|
+
}
|
|
2071
|
+
const emitAll = () => {
|
|
2072
|
+
for (const id of records.keys()) emit(id);
|
|
2073
|
+
};
|
|
2074
|
+
const touch = (rfqId, swap) => {
|
|
2075
|
+
const id = bridge?.quoteIdOf(rfqId);
|
|
2076
|
+
if (id === void 0) return;
|
|
2077
|
+
live.set(id, swap);
|
|
2078
|
+
passed.add(id);
|
|
2079
|
+
emit(id);
|
|
2080
|
+
};
|
|
2081
|
+
const managerDeps = { indexer };
|
|
2082
|
+
if (config.contracts) managerDeps.contracts = config.contracts;
|
|
2083
|
+
const manager = new RfqSwapManager(managerDeps, {
|
|
2084
|
+
...config.pollIntervalMs === void 0 ? {} : { pollIntervalMs: config.pollIntervalMs },
|
|
2085
|
+
now
|
|
2086
|
+
});
|
|
2087
|
+
manager.onSwapUpdate((swap) => touch(swap.rfqId, swap));
|
|
2088
|
+
manager.onSwapCompleted((swap) => touch(swap.rfqId, swap));
|
|
2089
|
+
manager.onSwapFailed((swap, error) => {
|
|
2090
|
+
const id = bridge?.quoteIdOf(swap.rfqId);
|
|
2091
|
+
if (id !== void 0 && error instanceof LockupNeedsRecoveryError) {
|
|
2092
|
+
swept.set(id, error.outpoints);
|
|
2093
|
+
}
|
|
2094
|
+
touch(swap.rfqId, swap);
|
|
2095
|
+
});
|
|
2096
|
+
let onchainSeams;
|
|
2097
|
+
const defaultOnchainClaim = (chain, feeRateSatVb) => {
|
|
2098
|
+
return async (swap, utxo) => {
|
|
2099
|
+
const record = await corridorStore().getRfqSwap(swap.rfqId);
|
|
2100
|
+
if (!record) {
|
|
2101
|
+
throw new Error(`rfq swap ${swap.rfqId} has no stored record to claim from`);
|
|
2102
|
+
}
|
|
2103
|
+
const secret = rfqClaimSecretOf(record);
|
|
2104
|
+
if (!secret) throw new Error(`rfq swap ${swap.rfqId} carries no claim secret`);
|
|
2105
|
+
const preimage = await preimageForSwapRecord(wallet, secret);
|
|
2106
|
+
const signer = await contractSigner(wallet, await identityDescriptor(wallet.identity));
|
|
2107
|
+
const claimKey = record.profile.claimKey;
|
|
2108
|
+
if (typeof claimKey === "string") {
|
|
2109
|
+
const held = hex5.encode(await signer.xOnlyPublicKey());
|
|
2110
|
+
if (held !== claimKey) {
|
|
2111
|
+
throw new Error(
|
|
2112
|
+
`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`
|
|
2113
|
+
);
|
|
2114
|
+
}
|
|
2115
|
+
}
|
|
2116
|
+
if (!swap.payoutPkScript) {
|
|
2117
|
+
throw new Error(`rfq swap ${swap.rfqId} carries no claim payout script`);
|
|
2118
|
+
}
|
|
2119
|
+
const { txid } = await track(
|
|
2120
|
+
claimOnchainFill(chain, {
|
|
2121
|
+
htlc: swap.htlc,
|
|
2122
|
+
utxo,
|
|
2123
|
+
preimage,
|
|
2124
|
+
payoutPkScript: swap.payoutPkScript,
|
|
2125
|
+
feeRateSatVb,
|
|
2126
|
+
sign: (sighash) => signer.signMessage(sighash, "schnorr")
|
|
2127
|
+
})
|
|
2128
|
+
);
|
|
2129
|
+
return { txid };
|
|
2130
|
+
};
|
|
2131
|
+
};
|
|
2132
|
+
const resolveOnchain = async () => {
|
|
2133
|
+
if (onchainSeams !== void 0) return onchainSeams !== null;
|
|
2134
|
+
try {
|
|
2135
|
+
const deps = (await corridors()).get("onchain").deps;
|
|
2136
|
+
const claim = deps.claim ?? (deps.claimFeeRateSatVb === void 0 ? void 0 : defaultOnchainClaim(deps.chain, deps.claimFeeRateSatVb));
|
|
2137
|
+
onchainSeams = { chain: deps.chain, ...claim ? { claim } : {} };
|
|
2138
|
+
managerDeps.chain = deps.chain;
|
|
2139
|
+
return true;
|
|
2140
|
+
} catch (error) {
|
|
2141
|
+
console.warn(
|
|
2142
|
+
"[swap] the onchain corridor has no chain source, so its swaps cannot be driven",
|
|
2143
|
+
error
|
|
2144
|
+
);
|
|
2145
|
+
onchainSeams = null;
|
|
2146
|
+
return false;
|
|
2147
|
+
}
|
|
2148
|
+
};
|
|
2149
|
+
const drivable = async (record) => !readsChain(record.kind) || await resolveOnchain();
|
|
2150
|
+
const pinnedNetwork = async () => getNetwork2(await config.network());
|
|
2151
|
+
const claimLockup = async (swap, vtxos, { partiallyClaimed }) => {
|
|
2152
|
+
const record = await corridorStore().getRfqSwap(swap.rfqId);
|
|
2153
|
+
if (!record) throw new Error(`rfq swap ${swap.rfqId} has no stored record to claim from`);
|
|
2154
|
+
const secret = rfqClaimSecretOf(record);
|
|
2155
|
+
if (!secret) throw new Error(`rfq swap ${swap.rfqId} carries no claim secret`);
|
|
2156
|
+
const script = swap.lockup?.script;
|
|
2157
|
+
if (!script) throw new Error(`rfq swap ${swap.rfqId} carries no lockup covenant`);
|
|
2158
|
+
const payoutAddress = rfqClaimDestinationOf(record);
|
|
2159
|
+
if (!payoutAddress) {
|
|
2160
|
+
throw new Error(`rfq swap ${swap.rfqId} carries no claim destination`);
|
|
2161
|
+
}
|
|
2162
|
+
return track(
|
|
2163
|
+
pushClaim(operator, {
|
|
2164
|
+
contract: script,
|
|
2165
|
+
receiver: await contractSigner(wallet, secret.signingDescriptor),
|
|
2166
|
+
preimage: await preimageForSwapRecord(wallet, secret),
|
|
2167
|
+
vtxos,
|
|
2168
|
+
destinationPkScript: ArkAddress4.decode(payoutAddress).pkScript,
|
|
2169
|
+
// Passed through: `pushClaim`'s own value check decides whether `P` is published.
|
|
2170
|
+
expectedAmount: swap.expectedAmount,
|
|
2171
|
+
partiallyClaimed,
|
|
2172
|
+
network: await pinnedNetwork()
|
|
2173
|
+
})
|
|
2174
|
+
);
|
|
2175
|
+
};
|
|
2176
|
+
const canRefundArkade = async (swap) => {
|
|
2177
|
+
const record = await corridorStore().getRfqSwap(swap.rfqId);
|
|
2178
|
+
if (!record) {
|
|
2179
|
+
return {
|
|
2180
|
+
ok: false,
|
|
2181
|
+
reason: `no stored record for ${swap.rfqId}; the descriptor that signs its refund lives there`
|
|
2182
|
+
};
|
|
2183
|
+
}
|
|
2184
|
+
const signer = rfqSignerOf(record);
|
|
2185
|
+
try {
|
|
2186
|
+
await senderIdentityForSwapRecord(wallet, signer ?? {});
|
|
2187
|
+
return { ok: true };
|
|
2188
|
+
} catch (error) {
|
|
2189
|
+
if (error instanceof RefundNotLocallyPossibleError) {
|
|
2190
|
+
return { ok: false, reason: error.message };
|
|
2191
|
+
}
|
|
2192
|
+
throw error;
|
|
2193
|
+
}
|
|
2194
|
+
};
|
|
2195
|
+
const wireCallbacks = () => {
|
|
2196
|
+
if (mode === "readonly") return;
|
|
2197
|
+
const push = arkadeRefunder({
|
|
2198
|
+
operator,
|
|
2199
|
+
contracts: lockupSource,
|
|
2200
|
+
wallet,
|
|
2201
|
+
repository: corridorStore(),
|
|
2202
|
+
network: pinnedNetwork
|
|
2203
|
+
});
|
|
2204
|
+
manager.setCallbacks({
|
|
2205
|
+
refundArkade: async (swap) => {
|
|
2206
|
+
const id = bridge?.quoteIdOf(swap.rfqId);
|
|
2207
|
+
if (id !== void 0) {
|
|
2208
|
+
swept.delete(id);
|
|
2209
|
+
refunding.add(id);
|
|
2210
|
+
passed.add(id);
|
|
2211
|
+
emit(id);
|
|
2212
|
+
}
|
|
2213
|
+
try {
|
|
2214
|
+
return await track(push(swap));
|
|
2215
|
+
} finally {
|
|
2216
|
+
if (id !== void 0) refunding.delete(id);
|
|
2217
|
+
}
|
|
2218
|
+
},
|
|
2219
|
+
canRefundArkade,
|
|
2220
|
+
claimLockup,
|
|
2221
|
+
...onchainSeams?.claim ? { claimOnchain: onchainSeams.claim } : {}
|
|
2222
|
+
});
|
|
2223
|
+
};
|
|
2224
|
+
let offerSource;
|
|
2225
|
+
const offers = () => offerSource ??= offerRecordSource(storage(), remember, now);
|
|
2226
|
+
const restoreOfferDeposits = async (reopen = []) => {
|
|
2227
|
+
const store = storage();
|
|
2228
|
+
const [history, scanned, address, network] = await Promise.all([
|
|
2229
|
+
wallet.getTransactionHistory(),
|
|
2230
|
+
store.getScannedTxids(),
|
|
2231
|
+
wallet.getAddress(),
|
|
2232
|
+
config.network()
|
|
2233
|
+
]);
|
|
2234
|
+
const txs = history.map(toRestoreTx);
|
|
2235
|
+
const { hrp, serverPubKey: operatorPubkey } = ArkAddress4.decode(address);
|
|
2236
|
+
const reopened = await legacyOfferDepositsToAdopt(store);
|
|
2237
|
+
for (const txid of reopen) reopened.add(txid);
|
|
2238
|
+
const cursor = reopened.size === 0 ? scanned : new Set([...scanned].filter((txid) => !reopened.has(txid)));
|
|
2239
|
+
const { restored, scannedTxids } = await restoreAssetSwaps(indexer, txs, /* @__PURE__ */ new Set(), {
|
|
2240
|
+
operatorPubkey,
|
|
2241
|
+
scanned: cursor,
|
|
2242
|
+
hrp,
|
|
2243
|
+
recoveredIn
|
|
2244
|
+
});
|
|
2245
|
+
const { offer } = splitRecords(await collectSwapRecords(store));
|
|
2246
|
+
const current = new Map(offer.map((record) => [record.id, record]));
|
|
2247
|
+
const byDeposit = new Map(
|
|
2248
|
+
offer.filter((record) => record.fundingTxid !== void 0).map((record) => [`${record.swapPkScript}:${record.fundingTxid}`, record])
|
|
2249
|
+
);
|
|
2250
|
+
const unstamped = /* @__PURE__ */ new Map();
|
|
2251
|
+
for (const record of offer) {
|
|
2252
|
+
if (record.fundingTxid !== void 0 || !OFFER_LIVE(record.status)) continue;
|
|
2253
|
+
unstamped.set(record.swapPkScript, [
|
|
2254
|
+
...unstamped.get(record.swapPkScript) ?? [],
|
|
2255
|
+
record
|
|
2256
|
+
]);
|
|
2257
|
+
}
|
|
2258
|
+
const write = async (record) => {
|
|
2259
|
+
await store.saveSwapRecord(record);
|
|
2260
|
+
current.set(record.id, record);
|
|
2261
|
+
remember(record);
|
|
2262
|
+
};
|
|
2263
|
+
for (const found of restored) {
|
|
2264
|
+
const known = byDeposit.get(`${found.swapPkScript}:${found.fundingTxid}`);
|
|
2265
|
+
if (known !== void 0) {
|
|
2266
|
+
if (fateMoved(known, found)) await write(withDepositFate(known, found, now()));
|
|
2267
|
+
continue;
|
|
2268
|
+
}
|
|
2269
|
+
const orphan = unstamped.get(found.swapPkScript)?.shift();
|
|
2270
|
+
if (orphan !== void 0) {
|
|
2271
|
+
await write(
|
|
2272
|
+
withDepositFate({ ...orphan, fundingTxid: found.fundingTxid }, found, now())
|
|
2273
|
+
);
|
|
2274
|
+
continue;
|
|
2275
|
+
}
|
|
2276
|
+
await write(restoredOfferRecord(found, network, now()));
|
|
2277
|
+
}
|
|
2278
|
+
const stillLive = /* @__PURE__ */ new Set();
|
|
2279
|
+
for (const record of current.values()) {
|
|
2280
|
+
if (OFFER_LIVE(record.status) && record.fundingTxid) stillLive.add(record.fundingTxid);
|
|
2281
|
+
}
|
|
2282
|
+
await store.markTxidsScanned(scannedTxids.filter((txid) => !stillLive.has(txid)));
|
|
2283
|
+
const registry = managerDeps.contracts;
|
|
2284
|
+
if (registry) {
|
|
2285
|
+
await retireSettledOfferContracts(registry, [...current.values()].map(offerFactsOf));
|
|
2286
|
+
}
|
|
2287
|
+
return [...current.values()];
|
|
2288
|
+
};
|
|
2289
|
+
const contractsOf = async () => managerDeps.contracts ??= await wallet.getContractManager();
|
|
2290
|
+
const lockupSource = {
|
|
2291
|
+
getContractsWithVtxos: async (filter) => (await contractsOf()).getContractsWithVtxos(filter)
|
|
2292
|
+
};
|
|
2293
|
+
const registerCorridorSwap = async (record) => {
|
|
2294
|
+
if (mode === "readonly") return;
|
|
2295
|
+
if (!await drivable(record)) {
|
|
2296
|
+
undrivable.add(record.id);
|
|
2297
|
+
return;
|
|
2298
|
+
}
|
|
2299
|
+
const contracts = await contractsOf();
|
|
2300
|
+
const stored = rfqRecordOf(record);
|
|
2301
|
+
const params = await lockupContractParams(contracts, record.lockupAddress);
|
|
2302
|
+
const swap = rebuildRfqSwap(stored, params);
|
|
2303
|
+
live.set(record.id, swap);
|
|
2304
|
+
await manager.addSwap(swap, rfqSwapOriginOf(stored));
|
|
2305
|
+
await markPassed();
|
|
2306
|
+
emit(record.id);
|
|
2307
|
+
await arm();
|
|
2308
|
+
emit(record.id);
|
|
2309
|
+
};
|
|
2310
|
+
const hasLiveWork = async (offer) => (await manager.getPendingSwaps()).length > 0 || offer.some((r) => OFFER_LIVE(r.status));
|
|
2311
|
+
const markPassed = async () => {
|
|
2312
|
+
if (!(await manager.getStats()).isRunning) return;
|
|
2313
|
+
for (const swap of await manager.getAllSwaps()) {
|
|
2314
|
+
const id = bridge?.quoteIdOf(swap.rfqId);
|
|
2315
|
+
if (id !== void 0) passed.add(id);
|
|
2316
|
+
}
|
|
2317
|
+
};
|
|
2318
|
+
const arm = async () => {
|
|
2319
|
+
if (mode === "readonly" || !startRequested) return;
|
|
2320
|
+
if (!repository) return;
|
|
2321
|
+
await contractsOf();
|
|
2322
|
+
wireCallbacks();
|
|
2323
|
+
await manager.start();
|
|
2324
|
+
await markPassed();
|
|
2325
|
+
if (!watcher) {
|
|
2326
|
+
watcher = await watchOfferSwaps({
|
|
2327
|
+
wallet,
|
|
2328
|
+
source: offers(),
|
|
2329
|
+
onUpdate: (swap) => emit(swap.id)
|
|
2330
|
+
});
|
|
2331
|
+
}
|
|
2332
|
+
};
|
|
2333
|
+
const registerRestoredOffers = async (offers2) => {
|
|
2334
|
+
if (mode === "readonly") return;
|
|
2335
|
+
const live2 = offers2.filter(
|
|
2336
|
+
(record) => record.fundingTxid !== void 0 && !RETIRABLE.includes(record.status)
|
|
2337
|
+
);
|
|
2338
|
+
if (live2.length === 0) return;
|
|
2339
|
+
try {
|
|
2340
|
+
await restoreOfferCoverage(wallet, live2.map(offerFactsOf));
|
|
2341
|
+
} catch (error) {
|
|
2342
|
+
console.warn("[swap] could not register restored offer covenants", error);
|
|
2343
|
+
}
|
|
2344
|
+
};
|
|
2345
|
+
const adoptLegacyRfqSwaps = async (store) => {
|
|
2346
|
+
try {
|
|
2347
|
+
const toAdopt = await legacyRfqSwapsToAdopt(store);
|
|
2348
|
+
if (toAdopt.length === 0) return;
|
|
2349
|
+
const network = await config.network();
|
|
2350
|
+
const contracts = await contractsOf();
|
|
2351
|
+
for (const v1 of toAdopt) {
|
|
2352
|
+
try {
|
|
2353
|
+
const params = await lockupContractParams(contracts, v1.lockupAddress).catch(
|
|
2354
|
+
(error) => {
|
|
2355
|
+
if (error instanceof LockupContractMissing) return void 0;
|
|
2356
|
+
throw error;
|
|
2357
|
+
}
|
|
2358
|
+
);
|
|
2359
|
+
if (params === void 0 && !isRfqSwapTerminal(v1.state)) continue;
|
|
2360
|
+
const refundLocktime = params ? Number(params.refundLocktime) : 0;
|
|
2361
|
+
await store.saveSwapRecord(restoredCorridorRecord(v1, network, refundLocktime));
|
|
2362
|
+
} catch (error) {
|
|
2363
|
+
console.warn(`[swap] could not adopt v1 rfq swap ${v1.rfqId}`, error);
|
|
2364
|
+
}
|
|
2365
|
+
}
|
|
2366
|
+
} catch (error) {
|
|
2367
|
+
console.warn("[swap] v1 rfq swap adoption did not complete", error);
|
|
2368
|
+
}
|
|
2369
|
+
};
|
|
2370
|
+
const restore = async () => {
|
|
2371
|
+
if (!repository) return;
|
|
2372
|
+
await adoptLegacyRfqSwaps(repository);
|
|
2373
|
+
const all = await collectSwapRecords(repository);
|
|
2374
|
+
const { corridor, offer } = splitRecords(all.filter(readableRecord));
|
|
2375
|
+
for (const record of [...corridor, ...offer]) records.set(record.id, record);
|
|
2376
|
+
const liveCorridor = corridor.filter((record) => !isRfqSwapTerminal(record.state));
|
|
2377
|
+
const store = corridorStore();
|
|
2378
|
+
for (const record of liveCorridor) store.index(record);
|
|
2379
|
+
const liveLegacy = await legacyLiveRfqSwaps(repository);
|
|
2380
|
+
if (liveCorridor.length > 0 || liveLegacy.length > 0) {
|
|
2381
|
+
try {
|
|
2382
|
+
await contractsOf();
|
|
2383
|
+
for (const record of liveCorridor) {
|
|
2384
|
+
if (!await drivable(record)) undrivable.add(record.id);
|
|
2385
|
+
}
|
|
2386
|
+
for (const record of liveLegacy) {
|
|
2387
|
+
if (!await drivable(record)) undrivableLegacy.add(record.rfqId);
|
|
2388
|
+
}
|
|
2389
|
+
managerDeps.repository = store;
|
|
2390
|
+
const result = await manager.restoreFromRepository();
|
|
2391
|
+
for (const swap of result.restored) {
|
|
2392
|
+
const id = store.quoteIdOf(swap.rfqId);
|
|
2393
|
+
if (id !== void 0) live.set(id, swap);
|
|
2394
|
+
}
|
|
2395
|
+
for (const failure of result.failed) {
|
|
2396
|
+
console.warn(
|
|
2397
|
+
`[swap] could not restore rfq swap ${failure.rfqId}`,
|
|
2398
|
+
failure.error
|
|
2399
|
+
);
|
|
2400
|
+
}
|
|
2401
|
+
} catch (error) {
|
|
2402
|
+
console.warn("[swap] the corridor restore could not drive", error);
|
|
2403
|
+
}
|
|
2404
|
+
}
|
|
2405
|
+
let offers2 = offer;
|
|
2406
|
+
try {
|
|
2407
|
+
offers2 = await restoreOfferDeposits(
|
|
2408
|
+
offer.flatMap(
|
|
2409
|
+
(record) => record.status === "recoverable" && record.fundingTxid !== void 0 ? [record.fundingTxid] : []
|
|
2410
|
+
)
|
|
2411
|
+
);
|
|
2412
|
+
} catch (error) {
|
|
2413
|
+
console.warn("[swap] the offer deposit restore did not complete", error);
|
|
2414
|
+
}
|
|
2415
|
+
await registerRestoredOffers(offers2);
|
|
2416
|
+
emitAll();
|
|
2417
|
+
if (mode === "auto" && await hasLiveWork(offers2)) {
|
|
2418
|
+
try {
|
|
2419
|
+
await arm();
|
|
2420
|
+
} catch (error) {
|
|
2421
|
+
console.warn("[swap] the drive could not arm after its restore", error);
|
|
2422
|
+
}
|
|
2423
|
+
}
|
|
2424
|
+
emitAll();
|
|
2425
|
+
};
|
|
2426
|
+
const ready = () => readyPromise ??= restore();
|
|
2427
|
+
const stop = async () => {
|
|
2428
|
+
await queue;
|
|
2429
|
+
await manager.stop();
|
|
2430
|
+
watcher?.stop();
|
|
2431
|
+
await watcher?.idle();
|
|
2432
|
+
watcher = void 0;
|
|
2433
|
+
if (mode === "manual") startRequested = false;
|
|
2434
|
+
};
|
|
2435
|
+
const recoverer = async () => {
|
|
2436
|
+
const probe = wallet.getVtxoManager;
|
|
2437
|
+
if (typeof probe !== "function") {
|
|
2438
|
+
throw new SwapDriveRefusedError(
|
|
2439
|
+
"no-recovery-support",
|
|
2440
|
+
"this wallet exposes no VTXO manager, so no recovery round can be run"
|
|
2441
|
+
);
|
|
2442
|
+
}
|
|
2443
|
+
return probe.call(wallet);
|
|
2444
|
+
};
|
|
2445
|
+
const recoverableAt = async (script) => (await findLockupVtxos(lockupSource, script)).filter((vtxo) => vtxo.recoverable);
|
|
2446
|
+
const recover = async (id) => {
|
|
2447
|
+
if (disposed) throw new ClientDisposed("recover");
|
|
2448
|
+
if (mode === "readonly") {
|
|
2449
|
+
throw new SwapDriveRefusedError(
|
|
2450
|
+
"readonly",
|
|
2451
|
+
'this client is configured drive: "readonly" and actuates nothing',
|
|
2452
|
+
id
|
|
2453
|
+
);
|
|
2454
|
+
}
|
|
2455
|
+
await ready();
|
|
2456
|
+
const record = records.get(id) ?? await repository?.getSwapRecord(id);
|
|
2457
|
+
if (record === void 0) {
|
|
2458
|
+
throw new SwapDriveRefusedError("unknown-swap", `no swap record for ${id}`, id);
|
|
2459
|
+
}
|
|
2460
|
+
records.set(record.id, record);
|
|
2461
|
+
if (record.family === "rfq") {
|
|
2462
|
+
if (now() < record.refundLocktime) {
|
|
2463
|
+
throw new SwapDriveRefusedError(
|
|
2464
|
+
"refund-window-open",
|
|
2465
|
+
`swap ${id}'s lockup cannot be recovered before its refund locktime ${record.refundLocktime}`,
|
|
2466
|
+
id
|
|
2467
|
+
);
|
|
2468
|
+
}
|
|
2469
|
+
const script = hex5.decode(record.lockupPkScript);
|
|
2470
|
+
const before = await recoverableAt(script);
|
|
2471
|
+
if (before.length === 0) {
|
|
2472
|
+
throw new SwapDriveRefusedError(
|
|
2473
|
+
"nothing-swept",
|
|
2474
|
+
`swap ${id} has no swept outputs to recover`,
|
|
2475
|
+
id
|
|
2476
|
+
);
|
|
2477
|
+
}
|
|
2478
|
+
const txid2 = await track((await recoverer()).recoverVtxos());
|
|
2479
|
+
const after = await recoverableAt(script);
|
|
2480
|
+
const still = new Set(after.map((vtxo) => `${vtxo.txid}:${vtxo.vout}`));
|
|
2481
|
+
const recovered2 = before.every((vtxo) => !still.has(`${vtxo.txid}:${vtxo.vout}`));
|
|
2482
|
+
if (recovered2) swept.delete(id);
|
|
2483
|
+
await manager.poll();
|
|
2484
|
+
await markPassed();
|
|
2485
|
+
return { recovered: recovered2, txid: txid2, swap: swapView(id) };
|
|
2486
|
+
}
|
|
2487
|
+
if (record.status !== "recoverable") {
|
|
2488
|
+
throw new SwapDriveRefusedError(
|
|
2489
|
+
"nothing-swept",
|
|
2490
|
+
`offer swap ${id} is ${record.status}, so it has nothing swept to recover`,
|
|
2491
|
+
id
|
|
2492
|
+
);
|
|
2493
|
+
}
|
|
2494
|
+
const wentHome = async () => {
|
|
2495
|
+
await restoreOfferDeposits(
|
|
2496
|
+
record.fundingTxid === void 0 ? [] : [record.fundingTxid]
|
|
2497
|
+
);
|
|
2498
|
+
const after = records.get(id);
|
|
2499
|
+
return after?.family === "offer" && after.status !== "recoverable";
|
|
2500
|
+
};
|
|
2501
|
+
try {
|
|
2502
|
+
if (await wentHome()) return { recovered: true, swap: swapView(id) };
|
|
2503
|
+
} catch (error) {
|
|
2504
|
+
console.warn(`[swap] could not re-read offer ${id} before recovering it`, error);
|
|
2505
|
+
}
|
|
2506
|
+
const vtxoManager = await recoverer();
|
|
2507
|
+
await restoreOfferCoverage(wallet, [offerFactsOf(record)]);
|
|
2508
|
+
const txid = await track(vtxoManager.recoverVtxos());
|
|
2509
|
+
recoveredIn.add(txid);
|
|
2510
|
+
let recovered = false;
|
|
2511
|
+
try {
|
|
2512
|
+
recovered = await wentHome();
|
|
2513
|
+
} catch (error) {
|
|
2514
|
+
console.warn(
|
|
2515
|
+
`[swap] recovered offer ${id} in ${txid}, but could not re-read it`,
|
|
2516
|
+
error
|
|
2517
|
+
);
|
|
2518
|
+
}
|
|
2519
|
+
return { recovered, txid, swap: swapView(id) };
|
|
2520
|
+
};
|
|
2521
|
+
const swapView = (id) => {
|
|
2522
|
+
const update = updateFor(id);
|
|
2523
|
+
if (update === void 0) throw new Error(`the drive holds no swap ${id}`);
|
|
2524
|
+
return update.swap;
|
|
2525
|
+
};
|
|
2526
|
+
return {
|
|
2527
|
+
get ready() {
|
|
2528
|
+
return ready();
|
|
2529
|
+
},
|
|
2530
|
+
start: async () => {
|
|
2531
|
+
if (disposed) throw new ClientDisposed("start");
|
|
2532
|
+
if (mode === "readonly") {
|
|
2533
|
+
throw new SwapDriveRefusedError(
|
|
2534
|
+
"readonly",
|
|
2535
|
+
'this client is configured drive: "readonly" and will not start a drive loop'
|
|
2536
|
+
);
|
|
2537
|
+
}
|
|
2538
|
+
startRequested = true;
|
|
2539
|
+
await ready();
|
|
2540
|
+
await arm();
|
|
2541
|
+
},
|
|
2542
|
+
stop: async () => {
|
|
2543
|
+
await readyPromise?.catch(() => {
|
|
2544
|
+
});
|
|
2545
|
+
await stop();
|
|
2546
|
+
},
|
|
2547
|
+
dispose: async () => {
|
|
2548
|
+
if (disposed) return;
|
|
2549
|
+
disposed = true;
|
|
2550
|
+
await stop();
|
|
2551
|
+
await idle();
|
|
2552
|
+
listeners.clear();
|
|
2553
|
+
},
|
|
2554
|
+
onUpdate: (fn) => {
|
|
2555
|
+
if (disposed) throw new ClientDisposed("onUpdate");
|
|
2556
|
+
listeners.add(fn);
|
|
2557
|
+
for (const id of records.keys()) {
|
|
2558
|
+
const update = updateFor(id);
|
|
2559
|
+
if (update === void 0) continue;
|
|
2560
|
+
delivered.set(id, update.outcome);
|
|
2561
|
+
deliver(update, [fn]);
|
|
2562
|
+
}
|
|
2563
|
+
void ready().catch(() => {
|
|
2564
|
+
});
|
|
2565
|
+
return () => {
|
|
2566
|
+
listeners.delete(fn);
|
|
2567
|
+
};
|
|
2568
|
+
},
|
|
2569
|
+
adopt: (record) => {
|
|
2570
|
+
if (disposed) throw new ClientDisposed("accept");
|
|
2571
|
+
records.set(record.id, record);
|
|
2572
|
+
if (record.family === "rfq") {
|
|
2573
|
+
corridorStore().index(record);
|
|
2574
|
+
managerDeps.repository = corridorStore();
|
|
2575
|
+
enqueue(() => registerCorridorSwap(record));
|
|
2576
|
+
} else {
|
|
2577
|
+
enqueue(() => arm());
|
|
2578
|
+
}
|
|
2579
|
+
emit(record.id);
|
|
2580
|
+
return swapView(record.id);
|
|
2581
|
+
},
|
|
2582
|
+
swap: (id) => updateFor(id)?.swap,
|
|
2583
|
+
outcomeOf: (record) => outcomeOfEntry(record, live.get(record.id)),
|
|
2584
|
+
ingest: (record) => remember(record),
|
|
2585
|
+
recover,
|
|
2586
|
+
idle
|
|
2587
|
+
};
|
|
2588
|
+
};
|
|
2589
|
+
|
|
2590
|
+
// src/client/market.ts
|
|
2591
|
+
import {
|
|
2592
|
+
isRfqMarket as isRfqMarket2,
|
|
2593
|
+
marketCorridor as marketCorridor2,
|
|
2594
|
+
marketLegKey,
|
|
2595
|
+
selectMarkets
|
|
2596
|
+
} from "@arkade-os/solver-discovery";
|
|
2597
|
+
var marketKeyOf = (card) => {
|
|
2598
|
+
const base = marketLegKey(card, "base");
|
|
2599
|
+
const quote = marketLegKey(card, "quote");
|
|
2600
|
+
const baseIsArkade = marketCorridor2(card, "base") === "arkade";
|
|
2601
|
+
const quoteIsArkade = marketCorridor2(card, "quote") === "arkade";
|
|
2602
|
+
if (baseIsArkade !== quoteIsArkade) {
|
|
2603
|
+
return baseIsArkade ? `${base}/${quote}` : `${quote}/${base}`;
|
|
2604
|
+
}
|
|
2605
|
+
return base <= quote ? `${base}/${quote}` : `${quote}/${base}`;
|
|
2606
|
+
};
|
|
2607
|
+
var hasRendezvous = (card) => typeof card.discovery_pubkey === "string" && (card.transports?.nostr?.relays?.length ?? 0) > 0;
|
|
2608
|
+
var isAddressable = (card) => !isRfqMarket2(card) || hasRendezvous(card);
|
|
2609
|
+
var marketBackendOf = (card) => isRfqMarket2(card) || hasRendezvous(card) ? "rfq" : "feed";
|
|
2610
|
+
var usableMarkets = (snapshot, policy) => {
|
|
2611
|
+
const allowed = policy?.allowedRegistries;
|
|
2612
|
+
return (allowed ? snapshot.markets.filter((card) => allowed.includes(card.source)) : snapshot.markets).filter(isAddressable);
|
|
2613
|
+
};
|
|
2614
|
+
var eligibleMarkets = (snapshot, legs, policy, takeAmount) => {
|
|
2615
|
+
const markets = usableMarkets(snapshot, policy);
|
|
2616
|
+
const { give, take } = legs;
|
|
2617
|
+
if (give.corridor === take.corridor && give.assetId === take.assetId) return [];
|
|
2618
|
+
const oriented = (side) => {
|
|
2619
|
+
const base = side === "base" ? give : take;
|
|
2620
|
+
const quote = side === "base" ? take : give;
|
|
2621
|
+
const selection = {
|
|
2622
|
+
// The trader receives the take leg, so the solver must be able to pay that side out.
|
|
2623
|
+
wantSide: side === "base" ? "quote" : "base",
|
|
2624
|
+
...takeAmount === void 0 ? {} : { wantAmount: takeAmount }
|
|
2625
|
+
};
|
|
2626
|
+
const canonical = selectMarkets([...markets], {
|
|
2627
|
+
baseId: base.marketId,
|
|
2628
|
+
quoteId: quote.marketId,
|
|
2629
|
+
...selection
|
|
2630
|
+
});
|
|
2631
|
+
const legacy = selectMarkets([...markets], {
|
|
2632
|
+
baseId: `${base.corridor}:${base.assetId}`,
|
|
2633
|
+
quoteId: `${quote.corridor}:${quote.assetId}`,
|
|
2634
|
+
...selection
|
|
2635
|
+
});
|
|
2636
|
+
const selected = [.../* @__PURE__ */ new Set([...canonical, ...legacy])];
|
|
2637
|
+
return selected.map((card) => ({
|
|
2638
|
+
card,
|
|
2639
|
+
give: side,
|
|
2640
|
+
backend: marketBackendOf(card),
|
|
2641
|
+
key: marketKeyOf(card)
|
|
2642
|
+
}));
|
|
2643
|
+
};
|
|
2644
|
+
return [...oriented("base"), ...oriented("quote")];
|
|
2645
|
+
};
|
|
2646
|
+
var chooseMarket = (candidates, policy) => {
|
|
2647
|
+
if (candidates.length === 0) return void 0;
|
|
2648
|
+
if (!policy?.selectMarket) return candidates[0];
|
|
2649
|
+
const chosen = policy.selectMarket(candidates);
|
|
2650
|
+
if (chosen === void 0) return void 0;
|
|
2651
|
+
if (!candidates.includes(chosen)) {
|
|
2652
|
+
throw new Error("policy.selectMarket returned a market that was not among the candidates");
|
|
2653
|
+
}
|
|
2654
|
+
return chosen;
|
|
2655
|
+
};
|
|
2656
|
+
var marketRefOf = (candidate, snapshot) => cardMarketOf(candidate.card, snapshot, candidate.key, candidate.backend);
|
|
2657
|
+
var cardMarketOf = (card, snapshot, key, backend) => ({
|
|
2658
|
+
kind: "card",
|
|
2659
|
+
key,
|
|
2660
|
+
backend,
|
|
2661
|
+
source: card.source,
|
|
2662
|
+
sourceType: card.sourceType,
|
|
2663
|
+
solver: card.solver,
|
|
2664
|
+
...card.discovery_pubkey === void 0 ? {} : { discoveryPubkey: card.discovery_pubkey },
|
|
2665
|
+
pair: card.pair ?? marketPairLabel(card),
|
|
2666
|
+
snapshot
|
|
2667
|
+
});
|
|
2668
|
+
var isCardMarket = (market) => market.kind === "card";
|
|
2669
|
+
|
|
2670
|
+
// src/client/resolve.ts
|
|
2671
|
+
var SUPPORTED_PAIRS = [
|
|
2672
|
+
"arkade->arkade",
|
|
2673
|
+
"arkade->lightning",
|
|
2674
|
+
"lightning->arkade",
|
|
2675
|
+
"arkade->onchain"
|
|
2676
|
+
];
|
|
2677
|
+
var isSupportedPair = (pair) => SUPPORTED_PAIRS.includes(pair);
|
|
2678
|
+
var assembleRoute = (give, take) => {
|
|
2679
|
+
for (const leg of [give, take]) {
|
|
2680
|
+
const rail = railOfCorridor(leg.corridor);
|
|
2681
|
+
if (!leg.asset.startsWith(`${rail}:`)) {
|
|
2682
|
+
throw new Error(
|
|
2683
|
+
`route leg ${leg.corridor} carries ${leg.asset}, which is not on the ${rail} rail`
|
|
2684
|
+
);
|
|
2685
|
+
}
|
|
2686
|
+
}
|
|
2687
|
+
return { give, take };
|
|
2688
|
+
};
|
|
2689
|
+
var endpoint = (corridor, asset5, instrument) => ({
|
|
2690
|
+
corridor,
|
|
2691
|
+
asset: asset5,
|
|
2692
|
+
...instrument === void 0 ? {} : { instrument }
|
|
2693
|
+
});
|
|
2694
|
+
var legFor = (asset5, expected) => {
|
|
2695
|
+
const leg = toDiscoveryLeg(asset5);
|
|
2696
|
+
if (expected !== void 0 && leg.corridor !== expected) {
|
|
2697
|
+
throw new UnsupportedRoute(
|
|
2698
|
+
`${asset5} settles on ${leg.corridor}, and this leg is ${expected}`,
|
|
2699
|
+
{ give: leg.corridor, take: expected }
|
|
2700
|
+
);
|
|
2701
|
+
}
|
|
2702
|
+
return leg;
|
|
2703
|
+
};
|
|
2704
|
+
var resolveRoute = async (input, deps) => {
|
|
2705
|
+
const claimed = input.to === void 0 ? void 0 : deps.corridors.claim(input.to);
|
|
2706
|
+
if (input.to !== void 0 && claimed === void 0) {
|
|
2707
|
+
throw new UnsupportedRoute(`no corridor serves ${JSON.stringify(input.to)}`);
|
|
2708
|
+
}
|
|
2709
|
+
if (claimed?.corridor === "arkade") {
|
|
2710
|
+
throw new UnsupportedRoute(
|
|
2711
|
+
"an Arkade address is a plain Arkade payment, not a swap \u2014 send it with the wallet",
|
|
2712
|
+
{ take: "arkade" }
|
|
2713
|
+
);
|
|
2714
|
+
}
|
|
2715
|
+
const snapshot = deps.mode === "quote" ? await deps.discovery.load() : await deps.discovery.peek();
|
|
2716
|
+
const aliases = aliasTableFrom(snapshot.markets, deps.network);
|
|
2717
|
+
if (input.via !== void 0 && (input.via === "arkade" || !isCorridor(input.via))) {
|
|
2718
|
+
throw new UnsupportedRoute(
|
|
2719
|
+
`via names ${input.via}, which is not a corridor a receive can arrive over`
|
|
2720
|
+
);
|
|
2721
|
+
}
|
|
2722
|
+
const giveCorridor = input.via;
|
|
2723
|
+
const takeCorridor = claimed?.corridor ?? (giveCorridor === void 0 ? void 0 : "arkade");
|
|
2724
|
+
const takeAsset = assetFor(input.take, takeCorridor ?? "arkade", deps.network, aliases);
|
|
2725
|
+
const giveAsset = assetFor(input.give, giveCorridor ?? "arkade", deps.network, aliases);
|
|
2726
|
+
const takeLeg = legFor(takeAsset, takeCorridor);
|
|
2727
|
+
const giveLeg = legFor(giveAsset, giveCorridor);
|
|
2728
|
+
if (giveLeg.corridor === takeLeg.corridor && giveLeg.assetId === takeLeg.assetId) {
|
|
2729
|
+
throw new UnsupportedRoute(
|
|
2730
|
+
`both legs are ${giveAsset} on ${giveLeg.corridor} \u2014 name the other side with take, a destination, or via`,
|
|
2731
|
+
{ give: giveLeg.corridor, take: takeLeg.corridor }
|
|
2732
|
+
);
|
|
2733
|
+
}
|
|
2734
|
+
const pair = `${giveLeg.corridor}->${takeLeg.corridor}`;
|
|
2735
|
+
if (!isSupportedPair(pair)) {
|
|
2736
|
+
throw new UnsupportedRoute(
|
|
2737
|
+
pair === "onchain->arkade" ? "onchain -> arkade is not served until the client owns the trader's L1 refund path end to end" : `${pair} is not an implemented route`,
|
|
2738
|
+
{ give: giveLeg.corridor, take: takeLeg.corridor }
|
|
2739
|
+
);
|
|
2740
|
+
}
|
|
2741
|
+
const give = endpoint(
|
|
2742
|
+
giveLeg.corridor,
|
|
2743
|
+
giveAsset,
|
|
2744
|
+
giveLeg.corridor === "arkade" ? { kind: "wallet" } : void 0
|
|
2745
|
+
);
|
|
2746
|
+
const take = endpoint(
|
|
2747
|
+
takeLeg.corridor,
|
|
2748
|
+
takeAsset,
|
|
2749
|
+
claimed?.instrument ?? (takeLeg.corridor === "arkade" ? { kind: "wallet" } : void 0)
|
|
2750
|
+
);
|
|
2751
|
+
const amount = pinAmount(input, take.instrument);
|
|
2752
|
+
const candidates = eligibleMarkets(
|
|
2753
|
+
snapshot,
|
|
2754
|
+
{ give: giveLeg, take: takeLeg },
|
|
2755
|
+
deps.policy,
|
|
2756
|
+
amount?.on === "take" ? amount.value : void 0
|
|
2757
|
+
);
|
|
2758
|
+
const market = chooseMarket(candidates, deps.policy);
|
|
2759
|
+
const resolution = {
|
|
2760
|
+
give,
|
|
2761
|
+
take,
|
|
2762
|
+
...market === void 0 ? {} : { market: marketRefOf(market, snapshot.ref) },
|
|
2763
|
+
eligible: market === void 0 ? 0 : candidates.length,
|
|
2764
|
+
snapshot: snapshot.ref,
|
|
2765
|
+
...amount === void 0 ? {} : { amount }
|
|
2766
|
+
};
|
|
2767
|
+
return {
|
|
2768
|
+
resolution,
|
|
2769
|
+
legs: { give: giveLeg, take: takeLeg },
|
|
2770
|
+
give,
|
|
2771
|
+
take,
|
|
2772
|
+
pair,
|
|
2773
|
+
candidates,
|
|
2774
|
+
...market === void 0 ? {} : { market },
|
|
2775
|
+
snapshot,
|
|
2776
|
+
...amount === void 0 ? {} : { amount },
|
|
2777
|
+
aliases
|
|
2778
|
+
};
|
|
2779
|
+
};
|
|
2780
|
+
var isCorridor = (value) => CORRIDORS.includes(value);
|
|
2781
|
+
var assetFor = (ref, corridor, network, aliases) => ref === void 0 ? btcOn(railOfCorridor(corridor), network) : (
|
|
2782
|
+
// Rail-scoped: BTC has one id per rail, so a whole-table `"BTC"` is ambiguous.
|
|
2783
|
+
canonicalAssetId(ref, scopedToRail(aliases, railOfCorridor(corridor)))
|
|
2784
|
+
);
|
|
2785
|
+
var pinAmount = (input, takeInstrument) => {
|
|
2786
|
+
const pinned = takeInstrument?.kind === "invoice" && takeInstrument.amount !== void 0 ? { value: takeInstrument.amount, named: "the invoice's" } : takeInstrument?.kind === "address" && takeInstrument.amount !== void 0 ? { value: takeInstrument.amount, named: "the destination's" } : void 0;
|
|
2787
|
+
if (input.amount !== void 0 && pinned !== void 0) {
|
|
2788
|
+
throw new AmountMismatch([`${pinned.named} ${pinned.value}`, `amount ${input.amount}`]);
|
|
2789
|
+
}
|
|
2790
|
+
if (input.amount !== void 0) {
|
|
2791
|
+
if (input.amountOn === void 0) {
|
|
2792
|
+
throw new Error("amount needs amountOn ('give' or 'take') to say which leg it pins");
|
|
2793
|
+
}
|
|
2794
|
+
if (input.amount <= 0n) {
|
|
2795
|
+
throw new Error(`amount must be positive, got ${input.amount}`);
|
|
2796
|
+
}
|
|
2797
|
+
return { value: input.amount, on: input.amountOn, source: "caller" };
|
|
2798
|
+
}
|
|
2799
|
+
if (pinned !== void 0) return { value: pinned.value, on: "take", source: "destination" };
|
|
2800
|
+
return void 0;
|
|
2801
|
+
};
|
|
2802
|
+
|
|
2803
|
+
// src/client/verify.ts
|
|
2804
|
+
var reasonOf = (error) => error instanceof Error && typeof error.reason === "string" ? error.reason : void 0;
|
|
2805
|
+
var CHECK_BY_REASON = {
|
|
2806
|
+
invoice_expired: "invoice",
|
|
2807
|
+
invoice_undecodable: "invoice",
|
|
2808
|
+
invoice_hash_mismatch: "invoice",
|
|
2809
|
+
invoice_amount_mismatch: "invoice",
|
|
2810
|
+
insufficient_headroom: "refund_window",
|
|
2811
|
+
missing_refund_locktime: "refund_window",
|
|
2812
|
+
claim_window_too_short: "refund_window",
|
|
2813
|
+
confirmations_out_of_range: "refund_window",
|
|
2814
|
+
timelock_order: "refund_window",
|
|
2815
|
+
quote_malformed: "refund_window"
|
|
2816
|
+
};
|
|
2817
|
+
var gated = (run, quote) => {
|
|
2818
|
+
try {
|
|
2819
|
+
run();
|
|
2820
|
+
} catch (error) {
|
|
2821
|
+
const reason = reasonOf(error);
|
|
2822
|
+
if (reason === "quote_expired") {
|
|
2823
|
+
throw new QuoteExpired(quote.id, quote.expiresAt, quote.now);
|
|
2824
|
+
}
|
|
2825
|
+
const check = reason === void 0 ? void 0 : CHECK_BY_REASON[reason];
|
|
2826
|
+
if (check === void 0) throw error;
|
|
2827
|
+
throw new QuoteVerificationFailed(
|
|
2828
|
+
check,
|
|
2829
|
+
void 0,
|
|
2830
|
+
error instanceof Error ? error.message : String(error),
|
|
2831
|
+
{ cause: error }
|
|
2832
|
+
);
|
|
2833
|
+
}
|
|
2834
|
+
};
|
|
2835
|
+
var verifyResponder = (input) => {
|
|
2836
|
+
if (!input.pinnable || input.expected === void 0) {
|
|
2837
|
+
throw new QuoteVerificationFailed(
|
|
2838
|
+
"responder",
|
|
2839
|
+
"a registry-served card naming the solver's discovery key",
|
|
2840
|
+
input.expected === void 0 ? "the card names no discovery key" : "the card came out of the local cache, which does not authenticate it"
|
|
2841
|
+
);
|
|
2842
|
+
}
|
|
2843
|
+
if (input.attested === void 0) {
|
|
2844
|
+
throw new QuoteVerificationFailed(
|
|
2845
|
+
"responder",
|
|
2846
|
+
input.expected,
|
|
2847
|
+
"the transport attests nobody"
|
|
2848
|
+
);
|
|
2849
|
+
}
|
|
2850
|
+
if (input.attested !== input.expected) {
|
|
2851
|
+
throw new QuoteVerificationFailed("responder", input.expected, input.attested);
|
|
2852
|
+
}
|
|
2853
|
+
};
|
|
2854
|
+
var verifyPair = (quoted, requested) => {
|
|
2855
|
+
if (quoted !== requested) {
|
|
2856
|
+
throw new QuoteVerificationFailed("pair", requested, String(quoted));
|
|
2857
|
+
}
|
|
2858
|
+
};
|
|
2859
|
+
var verifyingDerivation = (derive) => {
|
|
2860
|
+
try {
|
|
2861
|
+
return derive();
|
|
2862
|
+
} catch (error) {
|
|
2863
|
+
if (error instanceof AddressMismatch) {
|
|
2864
|
+
const derived = Array.isArray(error.derived) ? error.derived.join(", ") : error.derived;
|
|
2865
|
+
throw new QuoteVerificationFailed("lockup_address", derived, error.quoted, {
|
|
2866
|
+
cause: error
|
|
2867
|
+
});
|
|
2868
|
+
}
|
|
2869
|
+
if (error instanceof Error) {
|
|
2870
|
+
throw new QuoteVerificationFailed("lockup_address", void 0, error.message, {
|
|
2871
|
+
cause: error
|
|
2872
|
+
});
|
|
2873
|
+
}
|
|
2874
|
+
throw error;
|
|
2875
|
+
}
|
|
2876
|
+
};
|
|
2877
|
+
var verifySendWindow = (input) => {
|
|
2878
|
+
gated(
|
|
2879
|
+
() => assertFundable({
|
|
2880
|
+
quote: input.quote,
|
|
2881
|
+
now: input.now,
|
|
2882
|
+
...input.invoiceExpiresAt === void 0 ? {} : { invoiceExpiresAt: input.invoiceExpiresAt },
|
|
2883
|
+
...input.onchain === void 0 ? {} : { onchain: input.onchain }
|
|
2884
|
+
}),
|
|
2885
|
+
{ id: input.quoteId, expiresAt: input.quote.valid_until, now: input.now }
|
|
2886
|
+
);
|
|
2887
|
+
};
|
|
2888
|
+
var verifyReceiveWindow = (input) => {
|
|
2889
|
+
gated(
|
|
2890
|
+
() => assertReceivable({
|
|
2891
|
+
quote: input.quote,
|
|
2892
|
+
payDeadline: input.payDeadline,
|
|
2893
|
+
now: input.now
|
|
2894
|
+
}),
|
|
2895
|
+
{ id: input.quoteId, expiresAt: input.payDeadline, now: input.now }
|
|
2896
|
+
);
|
|
2897
|
+
};
|
|
2898
|
+
var verifySendInvoice = (input) => {
|
|
2899
|
+
const invoiced = input.invoiced;
|
|
2900
|
+
if (input.take !== invoiced) {
|
|
2901
|
+
throw new QuoteVerificationFailed("invoice", `${invoiced}`, `${input.take}`);
|
|
2902
|
+
}
|
|
2903
|
+
if (input.give < input.take) {
|
|
2904
|
+
throw new QuoteVerificationFailed(
|
|
2905
|
+
"invoice",
|
|
2906
|
+
`at least the invoice's ${invoiced}`,
|
|
2907
|
+
`${input.give}, a negative spread`
|
|
2908
|
+
);
|
|
2909
|
+
}
|
|
2910
|
+
};
|
|
2911
|
+
var verifyReceiveInvoiceFacts = (input) => {
|
|
2912
|
+
let decoded;
|
|
2913
|
+
try {
|
|
2914
|
+
decoded = input.decode(input.invoice);
|
|
2915
|
+
} catch (cause) {
|
|
2916
|
+
throw new QuoteVerificationFailed(
|
|
2917
|
+
"invoice",
|
|
2918
|
+
"a decodable BOLT11",
|
|
2919
|
+
cause instanceof Error ? cause.message : String(cause),
|
|
2920
|
+
{ cause }
|
|
2921
|
+
);
|
|
2922
|
+
}
|
|
2923
|
+
if (!Number.isFinite(decoded.expiresAt)) {
|
|
2924
|
+
throw new QuoteVerificationFailed("invoice", "a finite expiry", `${decoded.expiresAt}`);
|
|
2925
|
+
}
|
|
2926
|
+
if (!Number.isFinite(input.validUntil)) {
|
|
2927
|
+
throw new QuoteVerificationFailed(
|
|
2928
|
+
"refund_window",
|
|
2929
|
+
"a finite valid_until",
|
|
2930
|
+
`${input.validUntil}`
|
|
2931
|
+
);
|
|
2932
|
+
}
|
|
2933
|
+
if (decoded.paymentHash !== input.paymentHash) {
|
|
2934
|
+
throw new QuoteVerificationFailed("invoice", input.paymentHash, decoded.paymentHash);
|
|
2935
|
+
}
|
|
2936
|
+
if (!Number.isSafeInteger(decoded.amountSats) || decoded.amountSats <= 0) {
|
|
2937
|
+
throw new QuoteVerificationFailed(
|
|
2938
|
+
"invoice",
|
|
2939
|
+
`${input.payAmount}`,
|
|
2940
|
+
"the invoice names no amount"
|
|
2941
|
+
);
|
|
2942
|
+
}
|
|
2943
|
+
if (BigInt(decoded.amountSats) !== input.payAmount) {
|
|
2944
|
+
throw new QuoteVerificationFailed("invoice", `${input.payAmount}`, `${decoded.amountSats}`);
|
|
2945
|
+
}
|
|
2946
|
+
return { payDeadline: Math.min(decoded.expiresAt, input.validUntil) };
|
|
2947
|
+
};
|
|
2948
|
+
var verifyQuoteTtl = (input) => {
|
|
2949
|
+
const floor = input.floorSeconds ?? 0;
|
|
2950
|
+
if (input.expiresAt - input.now <= floor) {
|
|
2951
|
+
throw new QuoteExpired(input.quoteId, input.expiresAt, input.now);
|
|
2952
|
+
}
|
|
2953
|
+
};
|
|
2954
|
+
var verifyQuotedAmount = (input) => {
|
|
2955
|
+
verifyPinnedAmount(input);
|
|
2956
|
+
if (input.take > input.give) {
|
|
2957
|
+
throw new QuoteVerificationFailed(
|
|
2958
|
+
"pair",
|
|
2959
|
+
`${input.pair} give >= take`,
|
|
2960
|
+
`give=${input.give} take=${input.take}`
|
|
2961
|
+
);
|
|
2962
|
+
}
|
|
2963
|
+
};
|
|
2964
|
+
var verifyCrossAssetAmount = (input) => {
|
|
2965
|
+
verifyPinnedAmount(input);
|
|
2966
|
+
if (input.give <= 0n || input.take <= 0n) {
|
|
2967
|
+
throw new QuoteVerificationFailed(
|
|
2968
|
+
"pair",
|
|
2969
|
+
`${input.pair} give > 0 take > 0`,
|
|
2970
|
+
`give=${input.give} take=${input.take}`
|
|
2971
|
+
);
|
|
2972
|
+
}
|
|
2973
|
+
};
|
|
2974
|
+
var verifiedCarrierSats = (quote) => {
|
|
2975
|
+
try {
|
|
2976
|
+
return quoteCarrierSats(quote);
|
|
2977
|
+
} catch (error) {
|
|
2978
|
+
if (reasonOf(error) !== "carrier_malformed") throw error;
|
|
2979
|
+
throw new QuoteVerificationFailed(
|
|
2980
|
+
"pair",
|
|
2981
|
+
"carrier_sats a non-negative integer",
|
|
2982
|
+
String(quote.carrier_sats),
|
|
2983
|
+
{ cause: error }
|
|
2984
|
+
);
|
|
2985
|
+
}
|
|
2986
|
+
};
|
|
2987
|
+
var verifyPinnedAmount = (input) => {
|
|
2988
|
+
const quoted = input.pinned.on === "give" ? input.give : input.take;
|
|
2989
|
+
if (quoted !== input.pinned.value) {
|
|
2990
|
+
throw new QuoteVerificationFailed(
|
|
2991
|
+
"pair",
|
|
2992
|
+
`${input.pair} ${input.pinned.on}=${input.pinned.value}`,
|
|
2993
|
+
`${input.pair} ${input.pinned.on}=${quoted}`
|
|
2994
|
+
);
|
|
2995
|
+
}
|
|
2996
|
+
};
|
|
2997
|
+
|
|
2998
|
+
// src/client/quoteOffer.ts
|
|
2999
|
+
import {
|
|
3000
|
+
computeWantAmount,
|
|
3001
|
+
marketLegKey as marketLegKey2,
|
|
3002
|
+
quoteOffer
|
|
3003
|
+
} from "@arkade-os/solver-discovery";
|
|
3004
|
+
var FEED_TTL_MS = 3e4;
|
|
3005
|
+
var feedFetch = (base = fetch) => {
|
|
3006
|
+
const at = /* @__PURE__ */ new Map();
|
|
3007
|
+
const probe = async (input, init) => {
|
|
3008
|
+
at.set(input instanceof Request ? input.url : String(input), Date.now());
|
|
3009
|
+
return base(input, init);
|
|
3010
|
+
};
|
|
3011
|
+
return { fetch: makeCachedFeedFetch(FEED_TTL_MS, probe), fetchedAt: (url) => at.get(url) };
|
|
3012
|
+
};
|
|
3013
|
+
var quoteFromFeed = async (input) => {
|
|
3014
|
+
const { candidate, amount } = input;
|
|
3015
|
+
if (amount === void 0) {
|
|
3016
|
+
throw new Error("an asset swap needs an amount and the side it pins");
|
|
3017
|
+
}
|
|
3018
|
+
const plan = await quoteOffer(candidate.card, {
|
|
3019
|
+
give: candidate.give,
|
|
3020
|
+
...amount.on === "give" ? { giveAmount: amount.value } : { wantAmount: amount.value },
|
|
3021
|
+
// What `fund` attaches to an asset deposit and the fill pays an asset want: the plan asks
|
|
3022
|
+
// for it back in a BTC payout, and charges it where the card declares a delivered carrier.
|
|
3023
|
+
carrierSats: ASSET_CARRIER_SATS,
|
|
3024
|
+
...QUOTE_OPTIONS,
|
|
3025
|
+
fetchImpl: input.feed.fetch
|
|
3026
|
+
});
|
|
3027
|
+
verifyPlanLegs(plan, input.legs, candidate.give);
|
|
3028
|
+
const expiresAt = feedExpiry(candidate.card, input.feed, input.now);
|
|
3029
|
+
verifyQuoteTtl({
|
|
3030
|
+
quoteId: input.quoteId,
|
|
3031
|
+
expiresAt,
|
|
3032
|
+
now: input.now,
|
|
3033
|
+
floorSeconds: input.policy?.quoteTtlFloorSeconds
|
|
3034
|
+
});
|
|
3035
|
+
const route = assembleRoute(
|
|
3036
|
+
{ ...input.endpoints.give, instrument: { kind: "wallet" } },
|
|
3037
|
+
{ ...input.endpoints.take, instrument: { kind: "wallet" } }
|
|
3038
|
+
);
|
|
3039
|
+
return {
|
|
3040
|
+
quote: {
|
|
3041
|
+
id: input.quoteId,
|
|
3042
|
+
route,
|
|
3043
|
+
give: { asset: input.endpoints.give.asset, amount: plan.deposit.atomic },
|
|
3044
|
+
take: { asset: input.endpoints.take.asset, amount: plan.receive.atomic },
|
|
3045
|
+
market: input.market,
|
|
3046
|
+
expiresAt,
|
|
3047
|
+
fee: {
|
|
3048
|
+
// The plan's payout returns the deposit's carrier; that part is not proceeds.
|
|
3049
|
+
amount: feedSpread(
|
|
3050
|
+
plan,
|
|
3051
|
+
plan.receive.atomic,
|
|
3052
|
+
sellsAssetForBtc(input.endpoints) ? ASSET_CARRIER_SATS : 0n
|
|
3053
|
+
),
|
|
3054
|
+
asset: input.endpoints.take.asset
|
|
3055
|
+
}
|
|
3056
|
+
},
|
|
3057
|
+
preparation: { backend: "feed", card: candidate.card, plan, give: candidate.give }
|
|
3058
|
+
};
|
|
3059
|
+
};
|
|
3060
|
+
var feedSpread = (plan, take, carrierSats = 0n) => {
|
|
3061
|
+
const payout = take > carrierSats ? take - carrierSats : 0n;
|
|
3062
|
+
const fair = computeWantAmount({
|
|
3063
|
+
deposit: plan.deposit.atomic,
|
|
3064
|
+
give: plan.give,
|
|
3065
|
+
price: plan.price,
|
|
3066
|
+
feeBps: 0,
|
|
3067
|
+
safetyBps: 0
|
|
3068
|
+
});
|
|
3069
|
+
const spread = fair - payout;
|
|
3070
|
+
return spread > 0n ? spread : 0n;
|
|
3071
|
+
};
|
|
3072
|
+
var sellsAssetForBtc = (endpoints) => !isBtcAsset(endpoints.give.asset) && isBtcAsset(endpoints.take.asset);
|
|
3073
|
+
var feedExpiry = (card, feed, now) => {
|
|
3074
|
+
const readAt = card.price_feed === void 0 ? void 0 : feed.fetchedAt(card.price_feed);
|
|
3075
|
+
const from = readAt === void 0 ? now : Math.floor(readAt / 1e3);
|
|
3076
|
+
return from + FEED_TTL_MS / 1e3;
|
|
3077
|
+
};
|
|
3078
|
+
var verifyPlanLegs = (plan, legs, give) => {
|
|
3079
|
+
const take = give === "base" ? "quote" : "base";
|
|
3080
|
+
const spelled = (side) => marketLegKey2(plan.market, side);
|
|
3081
|
+
const names = (side, leg) => spelled(side) === leg.marketId || spelled(side) === `${leg.corridor}:${leg.assetId}`;
|
|
3082
|
+
if (plan.give !== give || !names(give, legs.give) || !names(take, legs.take)) {
|
|
3083
|
+
throw new QuoteVerificationFailed(
|
|
3084
|
+
"pair",
|
|
3085
|
+
`${legs.give.marketId}->${legs.take.marketId}`,
|
|
3086
|
+
`${spelled(give)}->${spelled(take)}`
|
|
3087
|
+
);
|
|
3088
|
+
}
|
|
3089
|
+
};
|
|
3090
|
+
|
|
3091
|
+
// src/client/sats.ts
|
|
3092
|
+
var satsOf = (value, field) => {
|
|
3093
|
+
if (value < 0n || value > BigInt(Number.MAX_SAFE_INTEGER)) {
|
|
3094
|
+
throw new AmountEncodingUnsupported(
|
|
3095
|
+
field,
|
|
3096
|
+
`${value}`,
|
|
3097
|
+
"outside the non-negative safe-integer window core's payment amounts are numbers in"
|
|
3098
|
+
);
|
|
3099
|
+
}
|
|
3100
|
+
return Number(value);
|
|
3101
|
+
};
|
|
3102
|
+
|
|
3103
|
+
// src/payment/status.ts
|
|
3104
|
+
var PAYMENT_STATUS = {
|
|
3105
|
+
/** Persisted, funding not broadcast. */
|
|
3106
|
+
accepted: "pending",
|
|
3107
|
+
funding: "pending",
|
|
3108
|
+
/** The lockup is funded. */
|
|
3109
|
+
funded: "sent",
|
|
3110
|
+
/** Asset swaps only: an unfilled offer. */
|
|
3111
|
+
open: "pending",
|
|
3112
|
+
/** Asset swaps only. */
|
|
3113
|
+
filled: "settled",
|
|
3114
|
+
/** The trader's L1 claim on `arkade -> onchain`. */
|
|
3115
|
+
claimed: "settled",
|
|
3116
|
+
/** Terminal success on `arkade -> lightning`: the solver's hash-verified
|
|
3117
|
+
* spend IS the invoice being paid. */
|
|
3118
|
+
paid: "settled",
|
|
3119
|
+
cancelling: "pending",
|
|
3120
|
+
/** Value returned, and the router has no non-loss terminal to say so with. */
|
|
3121
|
+
cancelled: "failed",
|
|
3122
|
+
/** Terminal HERE, not at `refunded` — see the module docblock. */
|
|
3123
|
+
refunding: "failed",
|
|
3124
|
+
/** The trader's value came back. Reaches `onUpdate`, not the handle. */
|
|
3125
|
+
refunded: "failed",
|
|
3126
|
+
/** The solver reclaimed a receive-leg lockup: a loss, and not `refunded`. */
|
|
3127
|
+
lapsed: "failed",
|
|
3128
|
+
/** Never retried silently; `client.recover` drives it. */
|
|
3129
|
+
needs_recovery: "failed",
|
|
3130
|
+
failed: "failed"
|
|
3131
|
+
};
|
|
3132
|
+
var paymentStatusOf = (outcome) => PAYMENT_STATUS[outcome];
|
|
3133
|
+
var isTerminalStatus = (status) => status === "settled" || status === "failed";
|
|
3134
|
+
|
|
3135
|
+
// src/payment/swapRail.ts
|
|
3136
|
+
import { makeHandle } from "@arkade-os/sdk";
|
|
3137
|
+
var SwapPaymentFailedError = class extends Error {
|
|
3138
|
+
constructor(railId, outcome, swap) {
|
|
3139
|
+
super(
|
|
3140
|
+
`${railId}: swap ${swap.id} ended ${outcome}` + (swap.failure === void 0 ? "" : `: ${swap.failure}`) + (swap.blockedReason === void 0 ? "" : ` (${swap.blockedReason})`)
|
|
3141
|
+
);
|
|
3142
|
+
this.railId = railId;
|
|
3143
|
+
this.outcome = outcome;
|
|
3144
|
+
this.swap = swap;
|
|
3145
|
+
}
|
|
3146
|
+
railId;
|
|
3147
|
+
outcome;
|
|
3148
|
+
swap;
|
|
3149
|
+
name = "SwapPaymentFailedError";
|
|
3150
|
+
};
|
|
3151
|
+
var unroutable = (error) => isSwapError(error, "UnsupportedRoute") || isSwapError(error, "AmbiguousDestination");
|
|
3152
|
+
var railAvailable = async (client, input) => {
|
|
3153
|
+
try {
|
|
3154
|
+
return (await client.resolve(input)).eligible > 0;
|
|
3155
|
+
} catch (error) {
|
|
3156
|
+
if (unroutable(error)) return false;
|
|
3157
|
+
throw error;
|
|
3158
|
+
}
|
|
3159
|
+
};
|
|
3160
|
+
var receiverExact = (railId, parts) => {
|
|
3161
|
+
if (parts.total !== parts.amount + parts.fee) {
|
|
3162
|
+
throw new Error(
|
|
3163
|
+
`${railId}: ${parts.total} leaving the wallet is not ${parts.amount} delivered plus ${parts.fee} in fees \u2014 the quote is not receiver-exact`
|
|
3164
|
+
);
|
|
3165
|
+
}
|
|
3166
|
+
return {
|
|
3167
|
+
amount: satsOf(parts.amount, `${railId}.amount`),
|
|
3168
|
+
fee: satsOf(parts.fee, `${railId}.fee`),
|
|
3169
|
+
total: satsOf(parts.total, `${railId}.total`)
|
|
3170
|
+
};
|
|
3171
|
+
};
|
|
3172
|
+
var quoteMeta = (quote) => ({
|
|
3173
|
+
quoteId: quote.id,
|
|
3174
|
+
expiresAt: quote.expiresAt,
|
|
3175
|
+
...quote.refundLocktime === void 0 ? {} : { refundLocktime: quote.refundLocktime },
|
|
3176
|
+
...quote.solver === void 0 ? {} : { solver: quote.solver },
|
|
3177
|
+
...quote.lock === void 0 ? {} : { paymentHash: quote.lock.hash },
|
|
3178
|
+
...quote.market.kind === "restored" ? {} : { market: quote.market.key }
|
|
3179
|
+
});
|
|
3180
|
+
var resultOf = (railId, swap) => ({
|
|
3181
|
+
railId,
|
|
3182
|
+
// tagged, so it joins `client.swaps()`/`onUpdate` for outcomes past this handle's terminal one
|
|
3183
|
+
swapId: swap.id,
|
|
3184
|
+
// the tx that left THIS wallet, as on every other rail; later legs are the client's to report
|
|
3185
|
+
...swap.fundingTxid === void 0 ? {} : { txid: swap.fundingTxid }
|
|
3186
|
+
});
|
|
3187
|
+
var swapHandle = async (railId, client, quote) => makeHandle(railId, async (emit) => {
|
|
3188
|
+
const accepted = await client.accept(quote);
|
|
3189
|
+
return await new Promise((resolve, reject) => {
|
|
3190
|
+
let finished = false;
|
|
3191
|
+
let unsubscribe;
|
|
3192
|
+
const listener = (update) => {
|
|
3193
|
+
if (finished || update.swap.id !== accepted.id) return;
|
|
3194
|
+
const status = paymentStatusOf(update.outcome);
|
|
3195
|
+
const result = resultOf(railId, update.swap);
|
|
3196
|
+
if (!isTerminalStatus(status)) {
|
|
3197
|
+
emit({ status, result });
|
|
3198
|
+
return;
|
|
3199
|
+
}
|
|
3200
|
+
finished = true;
|
|
3201
|
+
unsubscribe?.();
|
|
3202
|
+
if (status === "settled") {
|
|
3203
|
+
emit({ status, result });
|
|
3204
|
+
resolve(result);
|
|
3205
|
+
return;
|
|
3206
|
+
}
|
|
3207
|
+
reject(new SwapPaymentFailedError(railId, update.outcome, update.swap));
|
|
3208
|
+
};
|
|
3209
|
+
unsubscribe = client.onUpdate(listener);
|
|
3210
|
+
if (finished) unsubscribe();
|
|
3211
|
+
});
|
|
3212
|
+
});
|
|
3213
|
+
|
|
3214
|
+
// src/payment/onchainSwap.ts
|
|
3215
|
+
import {
|
|
3216
|
+
assertNoAssets,
|
|
3217
|
+
assetsOf,
|
|
3218
|
+
btcTarget,
|
|
3219
|
+
resolveSendAmount,
|
|
3220
|
+
tryResolveSendAmount
|
|
3221
|
+
} from "@arkade-os/sdk";
|
|
3222
|
+
var ONCHAIN_SWAP_RAIL = "onchain-swap";
|
|
3223
|
+
var claimFeeSats = (deps) => BigInt(Math.ceil((deps.claimVsize ?? ONCHAIN_CLAIM_VSIZE) * deps.claimFeeRateSatVb));
|
|
3224
|
+
function onchainSwapRail(client, deps) {
|
|
3225
|
+
if (!Number.isFinite(deps.claimFeeRateSatVb) || deps.claimFeeRateSatVb <= 0) {
|
|
3226
|
+
throw new Error(
|
|
3227
|
+
`${ONCHAIN_SWAP_RAIL}: claimFeeRateSatVb must be positive, got ${deps.claimFeeRateSatVb}`
|
|
3228
|
+
);
|
|
3229
|
+
}
|
|
3230
|
+
const claimFee = claimFeeSats(deps);
|
|
3231
|
+
const inputFor = (address, amount) => ({
|
|
3232
|
+
to: address,
|
|
3233
|
+
amount: BigInt(amount) + claimFee,
|
|
3234
|
+
amountOn: "take"
|
|
3235
|
+
});
|
|
3236
|
+
return {
|
|
3237
|
+
id: ONCHAIN_SWAP_RAIL,
|
|
3238
|
+
match: (req) => btcTarget(req.raw) !== void 0,
|
|
3239
|
+
available: async (req) => {
|
|
3240
|
+
if (assetsOf(req).length > 0) return false;
|
|
3241
|
+
const address = btcTarget(req.raw);
|
|
3242
|
+
if (address === void 0) return false;
|
|
3243
|
+
const amount = tryResolveSendAmount(req.raw, req.amount);
|
|
3244
|
+
if (amount === void 0) return false;
|
|
3245
|
+
if (BigInt(amount) < ONCHAIN_DUST_SATS) return false;
|
|
3246
|
+
return railAvailable(client, inputFor(address, amount));
|
|
3247
|
+
},
|
|
3248
|
+
quote: async (req) => {
|
|
3249
|
+
const address = btcTarget(req.raw);
|
|
3250
|
+
if (address === void 0) {
|
|
3251
|
+
throw new Error(`${ONCHAIN_SWAP_RAIL}: the request carries no bitcoin address`);
|
|
3252
|
+
}
|
|
3253
|
+
assertNoAssets(ONCHAIN_SWAP_RAIL, req);
|
|
3254
|
+
const amount = resolveSendAmount(ONCHAIN_SWAP_RAIL, req.raw, req.amount);
|
|
3255
|
+
const quote = await client.quote(inputFor(address, amount));
|
|
3256
|
+
const payout = quote.take.amount - claimFee;
|
|
3257
|
+
if (payout < ONCHAIN_DUST_SATS) {
|
|
3258
|
+
throw new Error(
|
|
3259
|
+
`${ONCHAIN_SWAP_RAIL}: the solver's take leg of ${quote.take.amount} sat leaves ${payout} sat after the ${claimFee} sat claim fee, under the ${ONCHAIN_DUST_SATS} sat dust limit the claim is built against`
|
|
3260
|
+
);
|
|
3261
|
+
}
|
|
3262
|
+
const amounts = receiverExact(ONCHAIN_SWAP_RAIL, {
|
|
3263
|
+
amount: payout,
|
|
3264
|
+
// The solver's spread plus the claim the trader pays out of the payout.
|
|
3265
|
+
fee: quote.fee.amount + claimFee,
|
|
3266
|
+
total: quote.give.amount
|
|
3267
|
+
});
|
|
3268
|
+
return {
|
|
3269
|
+
railId: ONCHAIN_SWAP_RAIL,
|
|
3270
|
+
...amounts,
|
|
3271
|
+
meta: {
|
|
3272
|
+
...quoteMeta(quote),
|
|
3273
|
+
claimFeeSats: Number(claimFee),
|
|
3274
|
+
// What the solver locks on L1, before the claim's fee.
|
|
3275
|
+
htlcAmountSats: Number(quote.take.amount)
|
|
3276
|
+
},
|
|
3277
|
+
send: () => swapHandle(ONCHAIN_SWAP_RAIL, client, quote)
|
|
3278
|
+
};
|
|
3279
|
+
}
|
|
3280
|
+
};
|
|
3281
|
+
}
|
|
3282
|
+
|
|
3283
|
+
// src/client/rfqWire.ts
|
|
3284
|
+
var BTC_LEG = {
|
|
3285
|
+
arkade: ARKADE_BTC,
|
|
3286
|
+
lightning: LIGHTNING_BTC,
|
|
3287
|
+
onchain: ONCHAIN_BTC
|
|
3288
|
+
};
|
|
3289
|
+
var rfqLeg = (leg) => leg.assetId === BTC_ASSET_ID ? BTC_LEG[leg.corridor] : `${leg.corridor}:${leg.assetId}`;
|
|
3290
|
+
var rfqPairFor = (give, take) => {
|
|
3291
|
+
const pair = rfqPair(rfqLeg(give), rfqLeg(take));
|
|
3292
|
+
assertPairLength(pair);
|
|
3293
|
+
return pair;
|
|
3294
|
+
};
|
|
3295
|
+
var withCanonicalAmount = (payload, amount) => ({
|
|
3296
|
+
...payload,
|
|
3297
|
+
amount: encodeRfqAmount(amount, "amount")
|
|
3298
|
+
});
|
|
3299
|
+
var parseRfqQuote = (quote) => ({
|
|
3300
|
+
raw: quote,
|
|
3301
|
+
rfqId: quote.rfq_id,
|
|
3302
|
+
pair: quote.pair,
|
|
3303
|
+
give: decodeRfqAmount(quote.from_amount, "from_amount"),
|
|
3304
|
+
take: decodeRfqAmount(quote.to_amount, "to_amount"),
|
|
3305
|
+
solver: quote.solver_pubkey,
|
|
3306
|
+
validUntil: quote.valid_until,
|
|
3307
|
+
...quote.refund_locktime === void 0 ? {} : { refundLocktime: quote.refund_locktime },
|
|
3308
|
+
profile: quote.profile ?? {}
|
|
3309
|
+
});
|
|
3310
|
+
|
|
3311
|
+
// src/client/quoteRfq.ts
|
|
3312
|
+
import { hex as hex6 } from "@scure/base";
|
|
3313
|
+
import {
|
|
3314
|
+
ArkAddress as ArkAddress5,
|
|
3315
|
+
asset as asset4,
|
|
3316
|
+
networkFromArkadeInfo,
|
|
3317
|
+
provisionClaimSecret,
|
|
3318
|
+
provisionRefundKey,
|
|
3319
|
+
toXOnly
|
|
3320
|
+
} from "@arkade-os/sdk";
|
|
3321
|
+
import { quoteOffer as quoteOffer2 } from "@arkade-os/solver-discovery";
|
|
3322
|
+
var lockupOf = (derived) => ({
|
|
3323
|
+
address: derived.address,
|
|
3324
|
+
script: derived.script,
|
|
3325
|
+
pkScript: derived.swapPkScript
|
|
3326
|
+
});
|
|
3327
|
+
var covenantInputs = (input) => {
|
|
3328
|
+
const network = networkFromArkadeInfo(input.info);
|
|
3329
|
+
const arkade = input.corridors.get("arkade").deps;
|
|
3330
|
+
return {
|
|
3331
|
+
operatorPubkey: toXOnly(hex6.decode(input.info.signerPubkey), "ark signer key"),
|
|
3332
|
+
// The resolved per-network pin, never operator-reported: it lands in a covenant leaf
|
|
3333
|
+
// that decides who can move the funds.
|
|
3334
|
+
emulatorPubkey: toXOnly(hex6.decode(arkade.emulatorPubkey), "emulator signer key"),
|
|
3335
|
+
claimDelay: unilateralClaimDelay(Number(input.info.unilateralExitDelay)),
|
|
3336
|
+
hrp: network.hrp
|
|
3337
|
+
};
|
|
3338
|
+
};
|
|
3339
|
+
var sealingKey = (deps) => {
|
|
3340
|
+
const configured = deps.covclaimd?.pubkey;
|
|
3341
|
+
if (configured === void 0) return void 0;
|
|
3342
|
+
const key = hex6.decode(configured);
|
|
3343
|
+
if (key.length !== 33) {
|
|
3344
|
+
throw new Error(
|
|
3345
|
+
`the covclaimd deployment key must be 33-byte compressed hex, got ${key.length} bytes`
|
|
3346
|
+
);
|
|
3347
|
+
}
|
|
3348
|
+
return key;
|
|
3349
|
+
};
|
|
3350
|
+
var pinnedFor = (input) => {
|
|
3351
|
+
if (input.amount === void 0) {
|
|
3352
|
+
throw new Error(`a ${input.route} quote needs an amount and the side it pins`);
|
|
3353
|
+
}
|
|
3354
|
+
return input.amount;
|
|
3355
|
+
};
|
|
3356
|
+
var quoteViaRfq = async (input) => {
|
|
3357
|
+
verifyResponder({
|
|
3358
|
+
attested: input.transport.attestedResponder,
|
|
3359
|
+
expected: input.market.discoveryPubkey,
|
|
3360
|
+
pinnable: input.market.snapshot.live
|
|
3361
|
+
});
|
|
3362
|
+
switch (input.route) {
|
|
3363
|
+
case "arkade->arkade":
|
|
3364
|
+
return quoteArkadeAsset(input);
|
|
3365
|
+
case "arkade->lightning":
|
|
3366
|
+
return quoteLightningSend(input);
|
|
3367
|
+
case "lightning->arkade":
|
|
3368
|
+
return quoteLightningReceive(input);
|
|
3369
|
+
case "arkade->onchain":
|
|
3370
|
+
return quoteOnchainSend(input);
|
|
3371
|
+
}
|
|
3372
|
+
};
|
|
3373
|
+
var quoteArkadeAsset = async (input) => {
|
|
3374
|
+
const pinned = pinnedFor(input);
|
|
3375
|
+
if (pinned.on !== "give") {
|
|
3376
|
+
throw new Error(
|
|
3377
|
+
"an asset swap is exact-in: pin the amount on the give leg. The legs carry different assets, so there is no spread to price a take-side pin back through \u2014 the solver answers `exact_out_unsupported`"
|
|
3378
|
+
);
|
|
3379
|
+
}
|
|
3380
|
+
const sides = assetSidesOf(input.legs);
|
|
3381
|
+
if (input.candidate.card.price_feed === void 0) {
|
|
3382
|
+
throw new UnsupportedRoute(
|
|
3383
|
+
`card ${input.candidate.card.solver} advertises no price feed to measure an asset swap's fee against`,
|
|
3384
|
+
{ give: "arkade", take: "arkade" }
|
|
3385
|
+
);
|
|
3386
|
+
}
|
|
3387
|
+
const pair = rfqPairFor(input.legs.give, input.legs.take);
|
|
3388
|
+
const rfqId = newRfqId();
|
|
3389
|
+
const maker = await makerPosition(input.wallet);
|
|
3390
|
+
const wire = await input.transport.requestQuote(
|
|
3391
|
+
arkadeSwapRequest({
|
|
3392
|
+
rfqId,
|
|
3393
|
+
...sides,
|
|
3394
|
+
amount: pinned.value,
|
|
3395
|
+
makerPkScript: maker.pkScript,
|
|
3396
|
+
makerPublicKey: maker.publicKey
|
|
3397
|
+
})
|
|
3398
|
+
);
|
|
3399
|
+
verifyPair(wire.pair, pair);
|
|
3400
|
+
const parsed = parseRfqQuote(wire);
|
|
3401
|
+
verifyCrossAssetAmount({ pair, pinned, give: parsed.give, take: parsed.take });
|
|
3402
|
+
verifyQuoteTtl({
|
|
3403
|
+
quoteId: input.quoteId,
|
|
3404
|
+
expiresAt: parsed.validUntil,
|
|
3405
|
+
now: input.now,
|
|
3406
|
+
floorSeconds: input.policy?.quoteTtlFloorSeconds
|
|
3407
|
+
});
|
|
3408
|
+
const carrierSats = sides.offerAsset === void 0 ? void 0 : verifiedCarrierSats(wire);
|
|
3409
|
+
const reference = await quoteOffer2(input.candidate.card, {
|
|
3410
|
+
give: input.candidate.give,
|
|
3411
|
+
giveAmount: parsed.give,
|
|
3412
|
+
...carrierSats === void 0 ? {} : { carrierSats },
|
|
3413
|
+
...QUOTE_OPTIONS,
|
|
3414
|
+
fetchImpl: input.feed.fetch
|
|
3415
|
+
});
|
|
3416
|
+
verifyPlanLegs(reference, input.legs, input.candidate.give);
|
|
3417
|
+
const terms = offerTermsFromQuote(wire, sides);
|
|
3418
|
+
const offer = await deriveOffer(input.wallet, {
|
|
3419
|
+
wantAmount: terms.wantAmount,
|
|
3420
|
+
...terms.wantAsset === void 0 ? {} : { wantAsset: terms.wantAsset },
|
|
3421
|
+
...terms.offerAsset === void 0 ? {} : { offerAsset: terms.offerAsset },
|
|
3422
|
+
emulatorPubkey: input.corridors.get("arkade").deps.emulatorPubkey,
|
|
3423
|
+
maker,
|
|
3424
|
+
info: input.info
|
|
3425
|
+
});
|
|
3426
|
+
verifyingDerivation(() => verifyOfferAddress(wire, offer));
|
|
3427
|
+
return {
|
|
3428
|
+
quote: {
|
|
3429
|
+
id: input.quoteId,
|
|
3430
|
+
route: assembleRoute(
|
|
3431
|
+
{ ...input.endpoints.give, instrument: { kind: "wallet" } },
|
|
3432
|
+
{ ...input.endpoints.take, instrument: { kind: "wallet" } }
|
|
3433
|
+
),
|
|
3434
|
+
give: { asset: input.endpoints.give.asset, amount: parsed.give },
|
|
3435
|
+
take: { asset: input.endpoints.take.asset, amount: parsed.take },
|
|
3436
|
+
market: input.market,
|
|
3437
|
+
solver: parsed.solver,
|
|
3438
|
+
expiresAt: parsed.validUntil,
|
|
3439
|
+
// Exactly one leg is BTC, so an asset deposit's carrier is on the payout's unit.
|
|
3440
|
+
fee: {
|
|
3441
|
+
amount: feedSpread(reference, parsed.take, carrierSats),
|
|
3442
|
+
asset: input.endpoints.take.asset
|
|
3443
|
+
}
|
|
3444
|
+
},
|
|
3445
|
+
preparation: {
|
|
3446
|
+
backend: "rfq",
|
|
3447
|
+
route: "arkade->arkade",
|
|
3448
|
+
card: input.candidate.card,
|
|
3449
|
+
rfqId,
|
|
3450
|
+
wire: parsed,
|
|
3451
|
+
offer,
|
|
3452
|
+
...carrierSats === void 0 ? {} : { carrierSats }
|
|
3453
|
+
}
|
|
3454
|
+
};
|
|
3455
|
+
};
|
|
3456
|
+
var assetSidesOf = (legs) => {
|
|
3457
|
+
const giveIsBtc = legs.give.assetId === BTC_ASSET_ID;
|
|
3458
|
+
const takeIsBtc = legs.take.assetId === BTC_ASSET_ID;
|
|
3459
|
+
if (giveIsBtc && takeIsBtc) {
|
|
3460
|
+
throw new UnsupportedRoute("arkade:BTC -> arkade:BTC moves one asset, it swaps nothing", {
|
|
3461
|
+
give: "arkade",
|
|
3462
|
+
take: "arkade"
|
|
3463
|
+
});
|
|
3464
|
+
}
|
|
3465
|
+
if (!giveIsBtc && !takeIsBtc) {
|
|
3466
|
+
throw new UnsupportedRoute(
|
|
3467
|
+
`arkade:${legs.give.assetId} -> arkade:${legs.take.assetId}: an asset swap prices one asset against BTC, so exactly one leg must be BTC`,
|
|
3468
|
+
{ give: "arkade", take: "arkade" }
|
|
3469
|
+
);
|
|
3470
|
+
}
|
|
3471
|
+
return giveIsBtc ? { wantAsset: asset4.AssetId.fromString(legs.take.assetId) } : { offerAsset: asset4.AssetId.fromString(legs.give.assetId) };
|
|
3472
|
+
};
|
|
3473
|
+
var makerPosition = async (wallet) => {
|
|
3474
|
+
const [address, publicKey] = await Promise.all([
|
|
3475
|
+
wallet.getAddress(),
|
|
3476
|
+
wallet.identity.xOnlyPublicKey()
|
|
3477
|
+
]);
|
|
3478
|
+
return { pkScript: ArkAddress5.decode(address).pkScript, publicKey };
|
|
3479
|
+
};
|
|
3480
|
+
var quoteLightningSend = async (input) => {
|
|
3481
|
+
const invoice = input.endpoints.take.instrument;
|
|
3482
|
+
if (invoice?.kind !== "invoice" || invoice.amount === void 0) {
|
|
3483
|
+
throw new Error("a lightning send is quoted against the amountful invoice it pays");
|
|
3484
|
+
}
|
|
3485
|
+
const pair = rfqPairFor(input.legs.give, input.legs.take);
|
|
3486
|
+
const rfqId = newRfqId();
|
|
3487
|
+
const secrets = await provisionRefundKey(input.wallet);
|
|
3488
|
+
const wire = await input.transport.requestQuote(
|
|
3489
|
+
lightningSendRequest({
|
|
3490
|
+
rfqId,
|
|
3491
|
+
invoice: invoice.bolt11,
|
|
3492
|
+
refundAddress: secrets.address,
|
|
3493
|
+
senderPubkey: secrets.pubkey
|
|
3494
|
+
})
|
|
3495
|
+
);
|
|
3496
|
+
verifyPair(wire.pair, pair);
|
|
3497
|
+
const parsed = parseRfqQuote(wire);
|
|
3498
|
+
verifySendInvoice({ invoiced: invoice.amount, give: parsed.give, take: parsed.take });
|
|
3499
|
+
const covenant = covenantInputs(input);
|
|
3500
|
+
const derived = verifyingDerivation(
|
|
3501
|
+
() => deriveLightningSend({
|
|
3502
|
+
quote: wire,
|
|
3503
|
+
paymentHash: invoice.paymentHash,
|
|
3504
|
+
senderPubkey: secrets.pubkey,
|
|
3505
|
+
refundPkScript: secrets.pkScript,
|
|
3506
|
+
now: input.now,
|
|
3507
|
+
...covenant
|
|
3508
|
+
})
|
|
3509
|
+
);
|
|
3510
|
+
verifySendWindow({
|
|
3511
|
+
quote: wire,
|
|
3512
|
+
quoteId: input.quoteId,
|
|
3513
|
+
now: input.now,
|
|
3514
|
+
invoiceExpiresAt: invoice.expiresAt
|
|
3515
|
+
});
|
|
3516
|
+
verifyQuoteTtl({
|
|
3517
|
+
quoteId: input.quoteId,
|
|
3518
|
+
expiresAt: parsed.validUntil,
|
|
3519
|
+
now: input.now,
|
|
3520
|
+
floorSeconds: input.policy?.quoteTtlFloorSeconds
|
|
3521
|
+
});
|
|
3522
|
+
return {
|
|
3523
|
+
quote: {
|
|
3524
|
+
id: input.quoteId,
|
|
3525
|
+
route: assembleRoute(
|
|
3526
|
+
{ ...input.endpoints.give, instrument: { kind: "wallet" } },
|
|
3527
|
+
{ ...input.endpoints.take, instrument: invoice }
|
|
3528
|
+
),
|
|
3529
|
+
give: { asset: input.endpoints.give.asset, amount: parsed.give },
|
|
3530
|
+
take: { asset: input.endpoints.take.asset, amount: parsed.take },
|
|
3531
|
+
lock: { hash: invoice.paymentHash },
|
|
3532
|
+
market: input.market,
|
|
3533
|
+
solver: parsed.solver,
|
|
3534
|
+
expiresAt: parsed.validUntil,
|
|
3535
|
+
refundLocktime: derived.refundLocktime,
|
|
3536
|
+
fee: { amount: parsed.give - parsed.take, asset: input.endpoints.give.asset }
|
|
3537
|
+
},
|
|
3538
|
+
preparation: {
|
|
3539
|
+
backend: "rfq",
|
|
3540
|
+
route: "arkade->lightning",
|
|
3541
|
+
card: input.candidate.card,
|
|
3542
|
+
rfqId,
|
|
3543
|
+
wire: parsed,
|
|
3544
|
+
lockup: lockupOf(derived),
|
|
3545
|
+
contractParams: derived.contractParams,
|
|
3546
|
+
secrets,
|
|
3547
|
+
refundAddress: secrets.address,
|
|
3548
|
+
fundAmount: parsed.give
|
|
3549
|
+
}
|
|
3550
|
+
};
|
|
3551
|
+
};
|
|
3552
|
+
var quoteLightningReceive = async (input) => {
|
|
3553
|
+
const pinned = pinnedFor(input);
|
|
3554
|
+
const pair = rfqPairFor(input.legs.give, input.legs.take);
|
|
3555
|
+
const rfqId = newRfqId();
|
|
3556
|
+
const secrets = await provisionClaimSecret(input.wallet);
|
|
3557
|
+
const paymentHash = hex6.encode(secrets.paymentHash);
|
|
3558
|
+
const payoutAddress = await input.wallet.getAddress();
|
|
3559
|
+
const lightning = input.corridors.get("lightning").deps;
|
|
3560
|
+
const sealTo = sealingKey(lightning);
|
|
3561
|
+
const claimPacket = sealTo ? await sealClaimPacket({ preimage: secrets.preimage, covclaimdPubkey: sealTo }) : void 0;
|
|
3562
|
+
const wire = await input.transport.requestQuote(
|
|
3563
|
+
withCanonicalAmount(
|
|
3564
|
+
lightningReceiveRequest({
|
|
3565
|
+
rfqId,
|
|
3566
|
+
paymentHash,
|
|
3567
|
+
payoutAddress,
|
|
3568
|
+
payoutPubkey: secrets.pubkey,
|
|
3569
|
+
claimPacket: claimPacket?.packet,
|
|
3570
|
+
// Placeholder: `withCanonicalAmount` writes the canonical decimal string.
|
|
3571
|
+
amount: 0,
|
|
3572
|
+
amountSide: toRfqAmountSide(pinned.on)
|
|
3573
|
+
}),
|
|
3574
|
+
pinned.value
|
|
3575
|
+
)
|
|
3576
|
+
);
|
|
3577
|
+
verifyPair(wire.pair, pair);
|
|
3578
|
+
const parsed = parseRfqQuote(wire);
|
|
3579
|
+
verifyQuotedAmount({ pair, pinned, give: parsed.give, take: parsed.take });
|
|
3580
|
+
const covenant = covenantInputs(input);
|
|
3581
|
+
const derived = verifyingDerivation(
|
|
3582
|
+
() => deriveLightningReceive({
|
|
3583
|
+
quote: wire,
|
|
3584
|
+
paymentHash,
|
|
3585
|
+
payoutPubkey: secrets.pubkey,
|
|
3586
|
+
payoutAddress,
|
|
3587
|
+
...covenant
|
|
3588
|
+
})
|
|
3589
|
+
);
|
|
3590
|
+
const { payDeadline } = verifyReceiveInvoiceFacts({
|
|
3591
|
+
invoice: derived.invoice,
|
|
3592
|
+
decode: lightning.decode,
|
|
3593
|
+
paymentHash,
|
|
3594
|
+
payAmount: parsed.give,
|
|
3595
|
+
validUntil: parsed.validUntil
|
|
3596
|
+
});
|
|
3597
|
+
verifyReceiveWindow({
|
|
3598
|
+
quote: wire,
|
|
3599
|
+
quoteId: input.quoteId,
|
|
3600
|
+
payDeadline,
|
|
3601
|
+
now: input.now
|
|
3602
|
+
});
|
|
3603
|
+
verifyQuoteTtl({
|
|
3604
|
+
quoteId: input.quoteId,
|
|
3605
|
+
// The hold invoice's window (minutes) binds, not the quote's (an hour).
|
|
3606
|
+
expiresAt: payDeadline,
|
|
3607
|
+
now: input.now,
|
|
3608
|
+
floorSeconds: input.policy?.quoteTtlFloorSeconds
|
|
3609
|
+
});
|
|
3610
|
+
const artifact = { kind: "invoice", bolt11: derived.invoice };
|
|
3611
|
+
return {
|
|
3612
|
+
quote: {
|
|
3613
|
+
id: input.quoteId,
|
|
3614
|
+
route: assembleRoute(
|
|
3615
|
+
{
|
|
3616
|
+
...input.endpoints.give,
|
|
3617
|
+
instrument: {
|
|
3618
|
+
kind: "invoice",
|
|
3619
|
+
bolt11: derived.invoice,
|
|
3620
|
+
paymentHash,
|
|
3621
|
+
amount: parsed.give,
|
|
3622
|
+
expiresAt: payDeadline
|
|
3623
|
+
}
|
|
3624
|
+
},
|
|
3625
|
+
{ ...input.endpoints.take, instrument: { kind: "wallet" } }
|
|
3626
|
+
),
|
|
3627
|
+
give: { asset: input.endpoints.give.asset, amount: parsed.give },
|
|
3628
|
+
take: { asset: input.endpoints.take.asset, amount: parsed.take },
|
|
3629
|
+
lock: { hash: paymentHash },
|
|
3630
|
+
market: input.market,
|
|
3631
|
+
solver: parsed.solver,
|
|
3632
|
+
expiresAt: payDeadline,
|
|
3633
|
+
refundLocktime: derived.refundLocktime,
|
|
3634
|
+
artifact,
|
|
3635
|
+
fee: { amount: parsed.give - parsed.take, asset: input.endpoints.give.asset }
|
|
3636
|
+
},
|
|
3637
|
+
preparation: {
|
|
3638
|
+
backend: "rfq",
|
|
3639
|
+
route: "lightning->arkade",
|
|
3640
|
+
card: input.candidate.card,
|
|
3641
|
+
rfqId,
|
|
3642
|
+
wire: parsed,
|
|
3643
|
+
lockup: lockupOf(derived),
|
|
3644
|
+
contractParams: derived.contractParams,
|
|
3645
|
+
secrets,
|
|
3646
|
+
payoutAddress,
|
|
3647
|
+
expectedAmount: parsed.take,
|
|
3648
|
+
payDeadline
|
|
3649
|
+
}
|
|
3650
|
+
};
|
|
3651
|
+
};
|
|
3652
|
+
var quoteOnchainSend = async (input) => {
|
|
3653
|
+
const pinned = pinnedFor(input);
|
|
3654
|
+
const destination = input.endpoints.take.instrument;
|
|
3655
|
+
if (destination?.kind !== "address") {
|
|
3656
|
+
throw new Error("an onchain send is quoted against the L1 address it pays");
|
|
3657
|
+
}
|
|
3658
|
+
const l1Network = l1NetworkFromArk(input.info.network);
|
|
3659
|
+
const payoutPkScript = l1ScriptForAddress(destination.address, l1Network);
|
|
3660
|
+
const pair = rfqPairFor(input.legs.give, input.legs.take);
|
|
3661
|
+
const rfqId = newRfqId();
|
|
3662
|
+
const onchain = input.corridors.get("onchain").deps;
|
|
3663
|
+
const claimFee = pinned.on === "take" && onchain.claimFeeRateSatVb !== void 0 ? claimFeeSats({
|
|
3664
|
+
claimFeeRateSatVb: onchain.claimFeeRateSatVb,
|
|
3665
|
+
claimVsize: onchain.claimVsize
|
|
3666
|
+
}) : void 0;
|
|
3667
|
+
const quoted = claimFee === void 0 ? pinned : { on: pinned.on, value: pinned.value + claimFee, source: pinned.source };
|
|
3668
|
+
const secrets = await provisionClaimSecret(input.wallet);
|
|
3669
|
+
const payoutKey = await provisionRefundKey(input.wallet);
|
|
3670
|
+
const paymentHash = hex6.encode(secrets.paymentHash);
|
|
3671
|
+
const wire = await input.transport.requestQuote(
|
|
3672
|
+
withCanonicalAmount(
|
|
3673
|
+
onchainSendRequest({
|
|
3674
|
+
rfqId,
|
|
3675
|
+
paymentHash,
|
|
3676
|
+
payoutPubkey: payoutKey.pubkey,
|
|
3677
|
+
refundAddress: payoutKey.address,
|
|
3678
|
+
senderPubkey: secrets.pubkey,
|
|
3679
|
+
amount: 0,
|
|
3680
|
+
amountSide: toRfqAmountSide(pinned.on)
|
|
3681
|
+
}),
|
|
3682
|
+
quoted.value
|
|
3683
|
+
)
|
|
3684
|
+
);
|
|
3685
|
+
verifyPair(wire.pair, pair);
|
|
3686
|
+
const parsed = parseRfqQuote(wire);
|
|
3687
|
+
verifyQuotedAmount({ pair, pinned: quoted, give: parsed.give, take: parsed.take });
|
|
3688
|
+
if (claimFee !== void 0) {
|
|
3689
|
+
const payout = parsed.take - claimFee;
|
|
3690
|
+
if (payout < ONCHAIN_DUST_SATS) {
|
|
3691
|
+
throw new Error(
|
|
3692
|
+
`arkade -> onchain: the take leg of ${parsed.take} sat leaves ${payout} sat after the ${claimFee} sat claim fee, under the ${ONCHAIN_DUST_SATS} sat dust limit the claim is built against \u2014 refusing before anything is funded`
|
|
3693
|
+
);
|
|
3694
|
+
}
|
|
3695
|
+
}
|
|
3696
|
+
const covenant = covenantInputs(input);
|
|
3697
|
+
const derived = verifyingDerivation(
|
|
3698
|
+
() => deriveOnchainSend({
|
|
3699
|
+
quote: wire,
|
|
3700
|
+
paymentHash,
|
|
3701
|
+
payoutPubkey: payoutKey.pubkey,
|
|
3702
|
+
...covenant,
|
|
3703
|
+
l1Network,
|
|
3704
|
+
refundAddress: payoutKey.address,
|
|
3705
|
+
senderPubkey: secrets.pubkey
|
|
3706
|
+
})
|
|
3707
|
+
);
|
|
3708
|
+
verifySendWindow({
|
|
3709
|
+
quote: wire,
|
|
3710
|
+
quoteId: input.quoteId,
|
|
3711
|
+
now: input.now,
|
|
3712
|
+
onchain: {
|
|
3713
|
+
htlcLocktime: derived.htlcLocktime,
|
|
3714
|
+
minConfirmations: derived.minConfirmations,
|
|
3715
|
+
direction: "send"
|
|
3716
|
+
}
|
|
3717
|
+
});
|
|
3718
|
+
verifyQuoteTtl({
|
|
3719
|
+
quoteId: input.quoteId,
|
|
3720
|
+
expiresAt: parsed.validUntil,
|
|
3721
|
+
now: input.now,
|
|
3722
|
+
floorSeconds: input.policy?.quoteTtlFloorSeconds
|
|
3723
|
+
});
|
|
3724
|
+
const reportedTake = parsed.take - (claimFee ?? 0n);
|
|
3725
|
+
const reportedFee = parsed.give - parsed.take + (claimFee ?? 0n);
|
|
3726
|
+
return {
|
|
3727
|
+
quote: {
|
|
3728
|
+
id: input.quoteId,
|
|
3729
|
+
route: assembleRoute(
|
|
3730
|
+
{ ...input.endpoints.give, instrument: { kind: "wallet" } },
|
|
3731
|
+
{ ...input.endpoints.take, instrument: destination }
|
|
3732
|
+
),
|
|
3733
|
+
give: { asset: input.endpoints.give.asset, amount: parsed.give },
|
|
3734
|
+
take: { asset: input.endpoints.take.asset, amount: reportedTake },
|
|
3735
|
+
lock: { hash: paymentHash },
|
|
3736
|
+
market: input.market,
|
|
3737
|
+
solver: parsed.solver,
|
|
3738
|
+
expiresAt: parsed.validUntil,
|
|
3739
|
+
// Off the derivation, not the wire: it settles which locktime this covenant used.
|
|
3740
|
+
refundLocktime: derived.refundLocktime,
|
|
3741
|
+
fee: { amount: reportedFee, asset: input.endpoints.give.asset }
|
|
3742
|
+
},
|
|
3743
|
+
preparation: {
|
|
3744
|
+
backend: "rfq",
|
|
3745
|
+
route: "arkade->onchain",
|
|
3746
|
+
card: input.candidate.card,
|
|
3747
|
+
rfqId,
|
|
3748
|
+
wire: parsed,
|
|
3749
|
+
lockup: lockupOf(derived),
|
|
3750
|
+
secrets,
|
|
3751
|
+
refundAddress: payoutKey.address,
|
|
3752
|
+
fundAmount: parsed.give,
|
|
3753
|
+
// Gross, not `reportedTake`: netting would accept an HTLC short by the fee.
|
|
3754
|
+
expectedAmount: parsed.take,
|
|
3755
|
+
payoutKey,
|
|
3756
|
+
payoutPkScript,
|
|
3757
|
+
htlc: derived.htlc,
|
|
3758
|
+
htlcParams: derived.htlcParams,
|
|
3759
|
+
l1Network: derived.l1Network,
|
|
3760
|
+
minConfirmations: derived.minConfirmations
|
|
3761
|
+
}
|
|
3762
|
+
};
|
|
3763
|
+
};
|
|
3764
|
+
|
|
3765
|
+
// src/client/verbs.ts
|
|
3766
|
+
import { arkTarget as arkTarget2, resolveSendAmount as resolveSendAmount2 } from "@arkade-os/sdk";
|
|
3767
|
+
var enforceFeeCeiling = (quote, call, policy) => {
|
|
3768
|
+
let ceiling;
|
|
3769
|
+
for (const [source, limit] of [
|
|
3770
|
+
["maxFee", call],
|
|
3771
|
+
["policy.maxFee", policy]
|
|
3772
|
+
]) {
|
|
3773
|
+
if (limit === void 0) continue;
|
|
3774
|
+
if (!sameAsset(limit.asset, quote.fee.asset)) {
|
|
3775
|
+
throw new Error(
|
|
3776
|
+
`${source} is denominated in ${limit.asset} and the quote's fee in ${quote.fee.asset} \u2014 no rate converts one ceiling into the other`
|
|
3777
|
+
);
|
|
3778
|
+
}
|
|
3779
|
+
ceiling = ceiling === void 0 || limit.amount < ceiling ? limit.amount : ceiling;
|
|
3780
|
+
}
|
|
3781
|
+
if (ceiling !== void 0 && quote.fee.amount > ceiling) {
|
|
3782
|
+
throw new MaxFeeExceeded(quote.id, quote.fee.asset, quote.fee.amount, ceiling);
|
|
3783
|
+
}
|
|
3784
|
+
};
|
|
3785
|
+
var settle = async (deps, input, maxFee) => {
|
|
3786
|
+
const quote = await deps.quote(input);
|
|
3787
|
+
enforceFeeCeiling(quote, maxFee, deps.policyMaxFee);
|
|
3788
|
+
return deps.accept(quote);
|
|
3789
|
+
};
|
|
3790
|
+
var pay = async (deps, destination, options = {}) => {
|
|
3791
|
+
const arkade = arkTarget2(destination);
|
|
3792
|
+
if (arkade !== void 0) {
|
|
3793
|
+
const amount = resolveSendAmount2(
|
|
3794
|
+
"ark",
|
|
3795
|
+
destination,
|
|
3796
|
+
options.amount === void 0 ? void 0 : satsOf(options.amount, "amount")
|
|
3797
|
+
);
|
|
3798
|
+
return { kind: "payment", txid: await deps.wallet.send({ address: arkade, amount }) };
|
|
3799
|
+
}
|
|
3800
|
+
const swap = await settle(
|
|
3801
|
+
deps,
|
|
3802
|
+
{
|
|
3803
|
+
to: destination,
|
|
3804
|
+
// The amount beside a destination is what the recipient gets.
|
|
3805
|
+
...options.amount === void 0 ? {} : { amount: options.amount, amountOn: "take" }
|
|
3806
|
+
},
|
|
3807
|
+
options.maxFee
|
|
3808
|
+
);
|
|
3809
|
+
return { kind: "swap", swap };
|
|
3810
|
+
};
|
|
3811
|
+
var receive = async (deps, options) => {
|
|
3812
|
+
const swap = await settle(
|
|
3813
|
+
deps,
|
|
3814
|
+
{
|
|
3815
|
+
via: options.via,
|
|
3816
|
+
...options.asset === void 0 ? {} : { take: options.asset },
|
|
3817
|
+
amount: options.amount,
|
|
3818
|
+
// "Credit me this much", not "let the payer send this much".
|
|
3819
|
+
amountOn: "take"
|
|
3820
|
+
},
|
|
3821
|
+
options.maxFee
|
|
3822
|
+
);
|
|
3823
|
+
if (swap.artifact === void 0) {
|
|
3824
|
+
throw new Error(
|
|
3825
|
+
`receive over ${options.via} returned no artifact \u2014 there is nothing to show a payer`
|
|
3826
|
+
);
|
|
3827
|
+
}
|
|
3828
|
+
return swap;
|
|
3829
|
+
};
|
|
3830
|
+
var exchange = async (deps, options) => settle(
|
|
3831
|
+
deps,
|
|
3832
|
+
{
|
|
3833
|
+
...options.give === void 0 ? {} : { give: options.give },
|
|
3834
|
+
...options.take === void 0 ? {} : { take: options.take },
|
|
3835
|
+
...options.amount === void 0 ? {} : { amount: options.amount },
|
|
3836
|
+
...options.amountOn === void 0 ? {} : { amountOn: options.amountOn }
|
|
3837
|
+
},
|
|
3838
|
+
options.maxFee
|
|
3839
|
+
);
|
|
3840
|
+
|
|
3841
|
+
// src/client/transport.ts
|
|
3842
|
+
var attesting = (transport, responder) => Object.assign(transport, { attestedResponder: responder });
|
|
3843
|
+
var nostrTransportFactory = async (rendezvous) => {
|
|
3844
|
+
const { nostrRfqTransport } = await import("./nostr.js");
|
|
3845
|
+
return attesting(
|
|
3846
|
+
nostrRfqTransport({
|
|
3847
|
+
relays: [...rendezvous.relays],
|
|
3848
|
+
solverPubkey: rendezvous.solverPubkey
|
|
3849
|
+
}),
|
|
3850
|
+
rendezvous.solverPubkey
|
|
3851
|
+
);
|
|
3852
|
+
};
|
|
3853
|
+
|
|
3854
|
+
// src/client/client.ts
|
|
3855
|
+
import { hex as hex7 } from "@scure/base";
|
|
3856
|
+
var PREPARATIONS_HELD = 64;
|
|
3857
|
+
var mintQuoteId = () => hex7.encode(crypto.getRandomValues(new Uint8Array(16)));
|
|
3858
|
+
var createSwapClient = (config) => {
|
|
3859
|
+
const { wallet } = config;
|
|
3860
|
+
const operator = config.operator ?? walletOperator(wallet);
|
|
3861
|
+
const feed = feedFetch(config.fetchImpl ?? fetch);
|
|
3862
|
+
const preparations = /* @__PURE__ */ new Map();
|
|
3863
|
+
const indexer = walletLockupIndexer(wallet);
|
|
3864
|
+
let disposed = false;
|
|
3865
|
+
const ensureLive = (method) => {
|
|
3866
|
+
if (disposed) throw new ClientDisposed(method);
|
|
3867
|
+
};
|
|
3868
|
+
let drive;
|
|
3869
|
+
const driving = () => drive ??= createSwapDrive({
|
|
3870
|
+
wallet,
|
|
3871
|
+
operator,
|
|
3872
|
+
...config.repository === void 0 ? {} : { repository: config.repository },
|
|
3873
|
+
corridors: async () => (await resolved()).corridors,
|
|
3874
|
+
network: async () => (await resolved()).base.networkName,
|
|
3875
|
+
...config.policy?.drive === void 0 ? {} : { mode: config.policy.drive },
|
|
3876
|
+
indexer
|
|
3877
|
+
});
|
|
3878
|
+
let context;
|
|
3879
|
+
const resolved = () => context ??= (async () => {
|
|
3880
|
+
const base = await resolveCorridorBase({
|
|
3881
|
+
wallet,
|
|
3882
|
+
operator,
|
|
3883
|
+
...config.emulatorPubkey === void 0 ? {} : { emulatorPubkey: config.emulatorPubkey },
|
|
3884
|
+
...config.fetchImpl === void 0 ? {} : { fetchImpl: config.fetchImpl },
|
|
3885
|
+
requireLive: false
|
|
3886
|
+
});
|
|
3887
|
+
return {
|
|
3888
|
+
base,
|
|
3889
|
+
corridors: corridorSet(base, config.corridors),
|
|
3890
|
+
discovery: discoveryIndex({
|
|
3891
|
+
network: base.networkName,
|
|
3892
|
+
...config.discovery === void 0 ? {} : { config: config.discovery },
|
|
3893
|
+
...config.repository === void 0 ? {} : { repository: config.repository }
|
|
3894
|
+
})
|
|
3895
|
+
};
|
|
3896
|
+
})().catch((error) => {
|
|
3897
|
+
context = void 0;
|
|
3898
|
+
throw error;
|
|
3899
|
+
});
|
|
3900
|
+
const route = async (input, mode) => {
|
|
3901
|
+
const { base, corridors, discovery } = await resolved();
|
|
3902
|
+
return resolveRoute(input, {
|
|
3903
|
+
corridors,
|
|
3904
|
+
network: base.networkName,
|
|
3905
|
+
discovery,
|
|
3906
|
+
...config.policy === void 0 ? {} : { policy: config.policy },
|
|
3907
|
+
mode
|
|
3908
|
+
});
|
|
3909
|
+
};
|
|
3910
|
+
const remember = (id, preparation) => {
|
|
3911
|
+
preparations.set(id, preparation);
|
|
3912
|
+
if (preparations.size > PREPARATIONS_HELD) {
|
|
3913
|
+
preparations.delete(preparations.keys().next().value);
|
|
3914
|
+
}
|
|
3915
|
+
};
|
|
3916
|
+
const client = {
|
|
3917
|
+
resolve: async (input) => {
|
|
3918
|
+
ensureLive("resolve");
|
|
3919
|
+
return (await route(input, "resolve")).resolution;
|
|
3920
|
+
},
|
|
3921
|
+
quote: async (input) => {
|
|
3922
|
+
ensureLive("quote");
|
|
3923
|
+
const { corridors, discovery } = await resolved();
|
|
3924
|
+
let resolvedRoute = await route(input, "quote");
|
|
3925
|
+
if (resolvedRoute.market?.backend === "rfq" && !resolvedRoute.snapshot.ref.live) {
|
|
3926
|
+
await discovery.load({ refresh: true });
|
|
3927
|
+
resolvedRoute = await route(input, "quote");
|
|
3928
|
+
}
|
|
3929
|
+
const { market } = resolvedRoute;
|
|
3930
|
+
if (market === void 0) {
|
|
3931
|
+
throw new UnsupportedRoute(
|
|
3932
|
+
`no market serves ${resolvedRoute.legs.give.corridor}:${resolvedRoute.legs.give.assetId} -> ${resolvedRoute.legs.take.corridor}:${resolvedRoute.legs.take.assetId} on the active discovery snapshot`,
|
|
3933
|
+
{
|
|
3934
|
+
give: resolvedRoute.legs.give.corridor,
|
|
3935
|
+
take: resolvedRoute.legs.take.corridor
|
|
3936
|
+
}
|
|
3937
|
+
);
|
|
3938
|
+
}
|
|
3939
|
+
const marketRef = resolvedRoute.resolution.market;
|
|
3940
|
+
if (marketRef === void 0 || marketRef.kind !== "card") {
|
|
3941
|
+
throw new Error("a resolved market must carry its card's provenance");
|
|
3942
|
+
}
|
|
3943
|
+
corridors.get(resolvedRoute.legs.give.corridor);
|
|
3944
|
+
corridors.get(resolvedRoute.legs.take.corridor);
|
|
3945
|
+
const quoteId = mintQuoteId();
|
|
3946
|
+
const now = Math.floor(Date.now() / 1e3);
|
|
3947
|
+
if (market.backend === "feed") {
|
|
3948
|
+
const { quote, preparation } = await quoteFromFeed({
|
|
3949
|
+
quoteId,
|
|
3950
|
+
candidate: market,
|
|
3951
|
+
market: marketRef,
|
|
3952
|
+
legs: resolvedRoute.legs,
|
|
3953
|
+
endpoints: { give: resolvedRoute.give, take: resolvedRoute.take },
|
|
3954
|
+
...resolvedRoute.amount === void 0 ? {} : { amount: resolvedRoute.amount },
|
|
3955
|
+
feed,
|
|
3956
|
+
...config.policy === void 0 ? {} : { policy: config.policy },
|
|
3957
|
+
now
|
|
3958
|
+
});
|
|
3959
|
+
remember(quoteId, preparation);
|
|
3960
|
+
return quote;
|
|
3961
|
+
}
|
|
3962
|
+
const info = await liveArkadeInfo(wallet, { requireLive: true });
|
|
3963
|
+
const rendezvous = market.card.discovery_pubkey;
|
|
3964
|
+
if (rendezvous === void 0) {
|
|
3965
|
+
throw new Error(`card ${market.card.solver} names no discovery key to address`);
|
|
3966
|
+
}
|
|
3967
|
+
const transport = await (config.transportFor ?? nostrTransportFactory)({
|
|
3968
|
+
card: market.card,
|
|
3969
|
+
solverPubkey: rendezvous,
|
|
3970
|
+
relays: market.card.transports?.nostr?.relays ?? []
|
|
3971
|
+
});
|
|
3972
|
+
try {
|
|
3973
|
+
const { quote, preparation } = await quoteViaRfq({
|
|
3974
|
+
quoteId,
|
|
3975
|
+
route: resolvedRoute.pair,
|
|
3976
|
+
candidate: market,
|
|
3977
|
+
market: marketRef,
|
|
3978
|
+
legs: resolvedRoute.legs,
|
|
3979
|
+
endpoints: { give: resolvedRoute.give, take: resolvedRoute.take },
|
|
3980
|
+
...resolvedRoute.amount === void 0 ? {} : { amount: resolvedRoute.amount },
|
|
3981
|
+
wallet,
|
|
3982
|
+
info,
|
|
3983
|
+
corridors,
|
|
3984
|
+
transport,
|
|
3985
|
+
feed,
|
|
3986
|
+
...config.policy === void 0 ? {} : { policy: config.policy },
|
|
3987
|
+
now
|
|
3988
|
+
});
|
|
3989
|
+
remember(quoteId, preparation);
|
|
3990
|
+
return quote;
|
|
3991
|
+
} finally {
|
|
3992
|
+
await transport.close().catch(() => {
|
|
3993
|
+
});
|
|
3994
|
+
}
|
|
3995
|
+
},
|
|
3996
|
+
accept: async (quote) => {
|
|
3997
|
+
ensureLive("accept");
|
|
3998
|
+
const { corridors } = await resolved();
|
|
3999
|
+
const drive2 = driving();
|
|
4000
|
+
await drive2.ready;
|
|
4001
|
+
const preparation = preparations.get(quote.id);
|
|
4002
|
+
return acceptQuote({
|
|
4003
|
+
quote,
|
|
4004
|
+
...preparation === void 0 ? {} : { preparation },
|
|
4005
|
+
wallet,
|
|
4006
|
+
repository: config.repository,
|
|
4007
|
+
corridors,
|
|
4008
|
+
drive: drive2,
|
|
4009
|
+
now: Math.floor(Date.now() / 1e3)
|
|
4010
|
+
});
|
|
4011
|
+
},
|
|
4012
|
+
cancel: async (swapId) => {
|
|
4013
|
+
ensureLive("cancel");
|
|
4014
|
+
if (familyOfSwapId(swapId) === "rfq") throw new NotCancellable(swapId);
|
|
4015
|
+
const repository = config.repository;
|
|
4016
|
+
if (repository === void 0) {
|
|
4017
|
+
throw new MissingCorridorDep("arkade", "repository");
|
|
4018
|
+
}
|
|
4019
|
+
const drive2 = driving();
|
|
4020
|
+
await drive2.ready;
|
|
4021
|
+
const record = await repository.getSwapRecord(quoteIdOfSwapId(swapId));
|
|
4022
|
+
if (record === void 0 || record.family !== "offer") {
|
|
4023
|
+
throw new NotCancellable(swapId);
|
|
4024
|
+
}
|
|
4025
|
+
return cancelSwap({ wallet, repository, record, drive: drive2, indexer });
|
|
4026
|
+
},
|
|
4027
|
+
swaps: async (filter) => {
|
|
4028
|
+
ensureLive("swaps");
|
|
4029
|
+
const repository = config.repository;
|
|
4030
|
+
if (repository === void 0) return [];
|
|
4031
|
+
const drive2 = driving();
|
|
4032
|
+
await drive2.ready;
|
|
4033
|
+
const records = await collectSwapRecords(repository);
|
|
4034
|
+
const swaps = [];
|
|
4035
|
+
for (const record of records) {
|
|
4036
|
+
if (!readableRecord(record)) continue;
|
|
4037
|
+
const live = drive2.swap(record.id);
|
|
4038
|
+
swaps.push(live ?? swapOf(record, drive2.outcomeOf(record)));
|
|
4039
|
+
}
|
|
4040
|
+
if (filter === void 0) return swaps;
|
|
4041
|
+
return swaps.filter(
|
|
4042
|
+
(swap) => (filter.family === void 0 || swap.family === filter.family) && (filter.outcome === void 0 || swap.outcome === filter.outcome)
|
|
4043
|
+
);
|
|
4044
|
+
},
|
|
4045
|
+
markets: async () => {
|
|
4046
|
+
ensureLive("markets");
|
|
4047
|
+
const { discovery } = await resolved();
|
|
4048
|
+
const snapshot = await discovery.load();
|
|
4049
|
+
return usableMarkets(snapshot, config.policy).map(
|
|
4050
|
+
(card) => cardMarketOf(card, snapshot.ref, marketKeyOf(card), marketBackendOf(card))
|
|
4051
|
+
);
|
|
4052
|
+
},
|
|
4053
|
+
pay: async (destination, options) => {
|
|
4054
|
+
ensureLive("pay");
|
|
4055
|
+
return pay(verbs, destination, options);
|
|
4056
|
+
},
|
|
4057
|
+
receive: async (options) => {
|
|
4058
|
+
ensureLive("receive");
|
|
4059
|
+
return receive(verbs, options);
|
|
4060
|
+
},
|
|
4061
|
+
exchange: async (options) => {
|
|
4062
|
+
ensureLive("exchange");
|
|
4063
|
+
return exchange(verbs, options);
|
|
4064
|
+
},
|
|
4065
|
+
preparationOf: (id) => {
|
|
4066
|
+
ensureLive("preparationOf");
|
|
4067
|
+
return preparations.get(id);
|
|
4068
|
+
},
|
|
4069
|
+
get ready() {
|
|
4070
|
+
ensureLive("ready");
|
|
4071
|
+
return driving().ready;
|
|
4072
|
+
},
|
|
4073
|
+
// `async` so the refusal is a rejection, as the `Promise<void>` signature promises
|
|
4074
|
+
start: async () => {
|
|
4075
|
+
ensureLive("start");
|
|
4076
|
+
return driving().start();
|
|
4077
|
+
},
|
|
4078
|
+
stop: async () => {
|
|
4079
|
+
ensureLive("stop");
|
|
4080
|
+
return driving().stop();
|
|
4081
|
+
},
|
|
4082
|
+
[Symbol.asyncDispose]: async () => {
|
|
4083
|
+
if (disposed) return;
|
|
4084
|
+
disposed = true;
|
|
4085
|
+
await drive?.dispose();
|
|
4086
|
+
},
|
|
4087
|
+
onUpdate: (fn) => {
|
|
4088
|
+
ensureLive("onUpdate");
|
|
4089
|
+
return driving().onUpdate(fn);
|
|
4090
|
+
},
|
|
4091
|
+
recover: async (id) => {
|
|
4092
|
+
ensureLive("recover");
|
|
4093
|
+
return driving().recover(quoteIdOfSwapId(id));
|
|
4094
|
+
}
|
|
4095
|
+
};
|
|
4096
|
+
const verbs = {
|
|
4097
|
+
wallet,
|
|
4098
|
+
quote: (input) => client.quote(input),
|
|
4099
|
+
accept: (quote) => client.accept(quote),
|
|
4100
|
+
...config.policy?.maxFee === void 0 ? {} : { policyMaxFee: config.policy.maxFee }
|
|
4101
|
+
};
|
|
4102
|
+
return client;
|
|
4103
|
+
};
|
|
4104
|
+
|
|
4105
|
+
export {
|
|
4106
|
+
RAILS,
|
|
4107
|
+
BITCOIN_RAILS,
|
|
4108
|
+
BTC_ASSET_PART,
|
|
4109
|
+
ARKADE_ASSET_NAMESPACE,
|
|
4110
|
+
AssetIdError,
|
|
4111
|
+
isNetworkRef,
|
|
4112
|
+
parseAssetId,
|
|
4113
|
+
isAssetId,
|
|
4114
|
+
formatAssetId,
|
|
4115
|
+
railOf,
|
|
4116
|
+
bitcoinNetworkOf,
|
|
4117
|
+
assetPartOf,
|
|
4118
|
+
sameAsset,
|
|
4119
|
+
btcAssetPart,
|
|
4120
|
+
btcOn,
|
|
4121
|
+
isBtcAsset,
|
|
4122
|
+
isBtcAssetLenient,
|
|
4123
|
+
arkadeAsset,
|
|
4124
|
+
issuanceOf,
|
|
4125
|
+
AmbiguousDestination,
|
|
4126
|
+
UnsupportedRoute,
|
|
4127
|
+
DiscoverySnapshotUnavailable,
|
|
4128
|
+
AmountMismatch,
|
|
4129
|
+
AmountEncodingUnsupported,
|
|
4130
|
+
QuoteVerificationFailed,
|
|
4131
|
+
QuoteExpired,
|
|
4132
|
+
MaxFeeExceeded,
|
|
4133
|
+
InsufficientFunds,
|
|
4134
|
+
AcceptConflict,
|
|
4135
|
+
ClientDisposed,
|
|
4136
|
+
NotCancellable,
|
|
4137
|
+
InconsistentRoute,
|
|
4138
|
+
OperatorUnreachable,
|
|
4139
|
+
MissingCorridorDep,
|
|
4140
|
+
SWAP_ERROR_NAMES,
|
|
4141
|
+
isSwapError,
|
|
4142
|
+
toDiscoveryLeg,
|
|
4143
|
+
INDEXED_NETWORKS,
|
|
4144
|
+
isIndexedNetwork,
|
|
4145
|
+
canonicalAssetId,
|
|
4146
|
+
AmountFormatError,
|
|
4147
|
+
Amount,
|
|
4148
|
+
toAtomicDecimal,
|
|
4149
|
+
fromAtomicDecimal,
|
|
4150
|
+
isAtomicDecimal,
|
|
4151
|
+
toRfqAmountSide,
|
|
4152
|
+
fromRfqAmountSide,
|
|
4153
|
+
encodeRfqAmount,
|
|
4154
|
+
decodeRfqAmount,
|
|
4155
|
+
toSafeNumber,
|
|
4156
|
+
assetSwapIdOf,
|
|
4157
|
+
OFFER_SWAP_ID_PREFIX,
|
|
4158
|
+
RFQ_SWAP_ID_PREFIX,
|
|
4159
|
+
familyOfSwapId,
|
|
4160
|
+
quoteIdOfSwapId,
|
|
4161
|
+
recordEndpoint,
|
|
4162
|
+
recordInstrument,
|
|
4163
|
+
instrumentOf,
|
|
4164
|
+
recordArtifact,
|
|
4165
|
+
artifactOf,
|
|
4166
|
+
recordLeg,
|
|
4167
|
+
legOf,
|
|
4168
|
+
swapOf,
|
|
4169
|
+
fundsFromWallet,
|
|
4170
|
+
conflictingFields,
|
|
4171
|
+
acceptQuote,
|
|
4172
|
+
swapRecordOf,
|
|
4173
|
+
CORRIDORS,
|
|
4174
|
+
railOfCorridor,
|
|
4175
|
+
corridorOfRail,
|
|
4176
|
+
publicAssetId,
|
|
4177
|
+
aliasTableFrom,
|
|
4178
|
+
scopedToRail,
|
|
4179
|
+
arkadeCorridor,
|
|
4180
|
+
DEFAULT_INVOICE_EXPIRY_SECONDS,
|
|
4181
|
+
decodeBolt11,
|
|
4182
|
+
chainSourceOver,
|
|
4183
|
+
esploraTip,
|
|
4184
|
+
esploraChainSource,
|
|
4185
|
+
ONCHAIN_CLAIM_FEE_RATE_SATVB,
|
|
4186
|
+
resolveCorridorDeps,
|
|
4187
|
+
liveArkadeInfo,
|
|
4188
|
+
resolveCorridorBase,
|
|
4189
|
+
CORRIDOR_FACTORIES,
|
|
4190
|
+
corridorSet,
|
|
4191
|
+
REGISTRY_URL,
|
|
4192
|
+
isUsableCard,
|
|
4193
|
+
discoveryIndex,
|
|
4194
|
+
splitRecords,
|
|
4195
|
+
rfqRecordOf,
|
|
4196
|
+
withRfqState,
|
|
4197
|
+
pageRfqRecords,
|
|
4198
|
+
corridorRecordStore,
|
|
4199
|
+
offerFactsOf,
|
|
4200
|
+
offerRecordSource,
|
|
4201
|
+
applyOfferSpend,
|
|
4202
|
+
withDepositFate,
|
|
4203
|
+
fateMoved,
|
|
4204
|
+
restoredOfferRecord,
|
|
4205
|
+
restoredCorridorRecord,
|
|
4206
|
+
walletLockupIndexer,
|
|
4207
|
+
cancelSwap,
|
|
4208
|
+
SwapDriveRefusedError,
|
|
4209
|
+
readableRecord,
|
|
4210
|
+
createSwapDrive,
|
|
4211
|
+
marketKeyOf,
|
|
4212
|
+
isAddressable,
|
|
4213
|
+
marketBackendOf,
|
|
4214
|
+
usableMarkets,
|
|
4215
|
+
eligibleMarkets,
|
|
4216
|
+
chooseMarket,
|
|
4217
|
+
marketRefOf,
|
|
4218
|
+
cardMarketOf,
|
|
4219
|
+
isCardMarket,
|
|
4220
|
+
assembleRoute,
|
|
4221
|
+
resolveRoute,
|
|
4222
|
+
verifyResponder,
|
|
4223
|
+
verifyPair,
|
|
4224
|
+
verifyingDerivation,
|
|
4225
|
+
verifySendWindow,
|
|
4226
|
+
verifyReceiveWindow,
|
|
4227
|
+
verifySendInvoice,
|
|
4228
|
+
verifyReceiveInvoiceFacts,
|
|
4229
|
+
verifyQuoteTtl,
|
|
4230
|
+
verifyQuotedAmount,
|
|
4231
|
+
verifyCrossAssetAmount,
|
|
4232
|
+
verifiedCarrierSats,
|
|
4233
|
+
FEED_TTL_MS,
|
|
4234
|
+
feedFetch,
|
|
4235
|
+
quoteFromFeed,
|
|
4236
|
+
feedSpread,
|
|
4237
|
+
verifyPlanLegs,
|
|
4238
|
+
satsOf,
|
|
4239
|
+
PAYMENT_STATUS,
|
|
4240
|
+
paymentStatusOf,
|
|
4241
|
+
isTerminalStatus,
|
|
4242
|
+
SwapPaymentFailedError,
|
|
4243
|
+
railAvailable,
|
|
4244
|
+
receiverExact,
|
|
4245
|
+
quoteMeta,
|
|
4246
|
+
swapHandle,
|
|
4247
|
+
ONCHAIN_SWAP_RAIL,
|
|
4248
|
+
claimFeeSats,
|
|
4249
|
+
onchainSwapRail,
|
|
4250
|
+
rfqLeg,
|
|
4251
|
+
rfqPairFor,
|
|
4252
|
+
withCanonicalAmount,
|
|
4253
|
+
parseRfqQuote,
|
|
4254
|
+
quoteViaRfq,
|
|
4255
|
+
enforceFeeCeiling,
|
|
4256
|
+
pay,
|
|
4257
|
+
receive,
|
|
4258
|
+
exchange,
|
|
4259
|
+
attesting,
|
|
4260
|
+
nostrTransportFactory,
|
|
4261
|
+
createSwapClient
|
|
4262
|
+
};
|