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