@arkade-os/swap 0.1.0-rc.21 → 0.1.0-rc.23
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +7 -2
- package/dist/advanced.cjs +875 -129
- package/dist/advanced.d.cts +158 -14
- package/dist/advanced.d.ts +158 -14
- package/dist/advanced.js +255 -4
- package/dist/{chunk-ITFCQWPG.js → chunk-DQ2DY2L2.js} +223 -11
- package/dist/{chunk-HUQQVBC4.js → chunk-MZX62KMU.js} +220 -12
- package/dist/{chunk-PVB7EBAM.js → chunk-UFJEO4VV.js} +47 -21
- package/dist/{errors-hm7aqnRM.d.cts → errors-5q4e3PnH.d.cts} +48 -16
- package/dist/{errors-C3h8ANmE.d.ts → errors-DQ35FKJf.d.ts} +48 -16
- package/dist/index.cjs +670 -185
- package/dist/index.d.cts +5 -5
- package/dist/index.d.ts +5 -5
- package/dist/index.js +5 -3
- package/dist/node/index.d.cts +26 -4
- package/dist/node/index.d.ts +26 -4
- package/dist/nostr.cjs +12 -9
- package/dist/nostr.d.cts +1 -1
- package/dist/nostr.d.ts +1 -1
- package/dist/nostr.js +3 -1
- package/dist/{offer-Bd9Yvd8Z.d.ts → offer--IpfzhIm.d.ts} +1 -1
- package/dist/{offer-F88rtL_I.d.cts → offer-DqTXQeP1.d.cts} +1 -1
- package/dist/protocol.cjs +395 -156
- package/dist/protocol.d.cts +45 -8
- package/dist/protocol.d.ts +45 -8
- package/dist/protocol.js +10 -3
- 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-DYnRLPt-.d.ts → repository-B4rQWmS2.d.cts} +88 -20
- package/dist/{repository-BuYWGAKz.d.cts → repository-D_qvJk1S.d.ts} +88 -20
- package/dist/{rfq-60PGpQ_x.d.cts → rfq-BgdgO9OO.d.cts} +16 -7
- package/dist/{rfq-60PGpQ_x.d.ts → rfq-BgdgO9OO.d.ts} +16 -7
- package/dist/{watch-BTyiBLSd.d.ts → watch-BkPz0vf8.d.ts} +1 -1
- package/dist/{watch-M_KY-5ho.d.cts → watch-RRhKuBkh.d.cts} +1 -1
- package/package.json +3 -3
package/dist/protocol.cjs
CHANGED
|
@@ -53,6 +53,7 @@ __export(protocol_exports, {
|
|
|
53
53
|
ONCHAIN_SECONDS_PER_BLOCK: () => ONCHAIN_SECONDS_PER_BLOCK,
|
|
54
54
|
ONCHAIN_SEND_PAIR: () => ONCHAIN_SEND_PAIR,
|
|
55
55
|
OfferCovenantMismatchError: () => OfferCovenantMismatchError,
|
|
56
|
+
OnchainReceiveNeedsChainSource: () => OnchainReceiveNeedsChainSource,
|
|
56
57
|
PreimageNotRecoverableError: () => PreimageNotRecoverableError,
|
|
57
58
|
QUOTE_OPTIONS: () => QUOTE_OPTIONS,
|
|
58
59
|
RFQ_SWAP_RETENTION_SECONDS: () => RFQ_SWAP_RETENTION_SECONDS,
|
|
@@ -107,11 +108,13 @@ __export(protocol_exports, {
|
|
|
107
108
|
makeCachedFeedFetch: () => makeCachedFeedFetch,
|
|
108
109
|
newPreimage: () => newPreimage,
|
|
109
110
|
nextOnchainAction: () => nextOnchainAction,
|
|
111
|
+
nextOnchainReceiveAction: () => nextOnchainReceiveAction,
|
|
110
112
|
normalizeMakerPkScript: () => normalizeMakerPkScript,
|
|
111
113
|
normalizeMakerPublicKey: () => normalizeMakerPublicKey,
|
|
112
114
|
normalizeRfqSwapRecord: () => normalizeRfqSwapRecord,
|
|
113
115
|
offerContract: () => offerContract,
|
|
114
116
|
onchainHtlcScript: () => onchainHtlcScript,
|
|
117
|
+
onchainReceiveProfile: () => onchainReceiveProfile,
|
|
115
118
|
onchainReceiveRequest: () => onchainReceiveRequest,
|
|
116
119
|
onchainSendProfile: () => onchainSendProfile,
|
|
117
120
|
onchainSendRequest: () => onchainSendRequest,
|
|
@@ -161,18 +164,19 @@ __export(protocol_exports, {
|
|
|
161
164
|
module.exports = __toCommonJS(protocol_exports);
|
|
162
165
|
|
|
163
166
|
// src/activity.ts
|
|
164
|
-
var
|
|
167
|
+
var import_sdk14 = require("@arkade-os/sdk");
|
|
165
168
|
var import_base11 = require("@scure/base");
|
|
166
169
|
|
|
167
170
|
// src/swapManager.ts
|
|
168
171
|
var import_base10 = require("@scure/base");
|
|
169
|
-
var
|
|
172
|
+
var import_sdk11 = require("@arkade-os/sdk");
|
|
170
173
|
|
|
171
174
|
// src/onchainHtlc.ts
|
|
172
175
|
var import_base = require("@scure/base");
|
|
173
176
|
var import_sha2 = require("@noble/hashes/sha2.js");
|
|
174
177
|
var import_legacy = require("@noble/hashes/legacy.js");
|
|
175
178
|
var btc = __toESM(require("@scure/btc-signer"), 1);
|
|
179
|
+
var import_sdk = require("@arkade-os/sdk");
|
|
176
180
|
var ONCHAIN_ORDER_MARGIN_SECONDS = 2 * 60 * 60;
|
|
177
181
|
var ONCHAIN_CLAIM_MARGIN_SECONDS = 90 * 60;
|
|
178
182
|
var MAX_MIN_CONFIRMATIONS = 6;
|
|
@@ -195,6 +199,7 @@ var gateError = (reason, message) => {
|
|
|
195
199
|
var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
|
|
196
200
|
async function pollUntil(probe, options, reason, message) {
|
|
197
201
|
const pollMs = options.pollMs ?? 5e3;
|
|
202
|
+
(0, import_sdk.assertTimerMs)("pollMs", pollMs);
|
|
198
203
|
for (; ; ) {
|
|
199
204
|
const value = await probe();
|
|
200
205
|
if (value !== void 0) return value;
|
|
@@ -410,14 +415,14 @@ async function classifyOnchainHtlc(chain, input) {
|
|
|
410
415
|
// src/refund.ts
|
|
411
416
|
var import_base7 = require("@scure/base");
|
|
412
417
|
var import_sha24 = require("@noble/hashes/sha2.js");
|
|
413
|
-
var
|
|
418
|
+
var import_sdk8 = require("@arkade-os/sdk");
|
|
414
419
|
|
|
415
420
|
// src/rfq.ts
|
|
416
421
|
var import_base6 = require("@scure/base");
|
|
417
422
|
var import_solver_discovery = require("@arkade-os/solver-discovery");
|
|
418
423
|
var import_legacy2 = require("@noble/hashes/legacy.js");
|
|
419
|
-
var import_sdk5 = require("@arkade-os/sdk");
|
|
420
424
|
var import_sdk6 = require("@arkade-os/sdk");
|
|
425
|
+
var import_sdk7 = require("@arkade-os/sdk");
|
|
421
426
|
|
|
422
427
|
// src/claimPacket.ts
|
|
423
428
|
var import_base2 = require("@scure/base");
|
|
@@ -461,7 +466,7 @@ var tlv = (type, value) => Uint8Array.from([type, value.length >> 8 & 255, value
|
|
|
461
466
|
|
|
462
467
|
// src/lockupContract.ts
|
|
463
468
|
var import_base3 = require("@scure/base");
|
|
464
|
-
var
|
|
469
|
+
var import_sdk2 = require("@arkade-os/sdk");
|
|
465
470
|
var SWAP_LOCKUP_CONTRACT_TYPE = "vhtlc-v2";
|
|
466
471
|
var SWAP_LOCKUP_CONTRACT_LABEL = "Arkade RFQ swap lockup";
|
|
467
472
|
var SWAP_LOCKUP_CONTRACT_KIND = "rfq-swap-lockup";
|
|
@@ -497,7 +502,7 @@ async function registerLockupContract(contracts, script, address) {
|
|
|
497
502
|
try {
|
|
498
503
|
await contracts.createContract({
|
|
499
504
|
type: SWAP_LOCKUP_CONTRACT_TYPE,
|
|
500
|
-
params:
|
|
505
|
+
params: import_sdk2.VHTLCV2ContractHandler.serializeParams(script.options),
|
|
501
506
|
script: import_base3.hex.encode(script.pkScript),
|
|
502
507
|
address,
|
|
503
508
|
label: SWAP_LOCKUP_CONTRACT_LABEL,
|
|
@@ -508,7 +513,7 @@ async function registerLockupContract(contracts, script, address) {
|
|
|
508
513
|
}
|
|
509
514
|
}
|
|
510
515
|
async function lockupContractParams(contracts, lockupAddress) {
|
|
511
|
-
const script = import_base3.hex.encode(
|
|
516
|
+
const script = import_base3.hex.encode(import_sdk2.ArkAddress.decode(lockupAddress).pkScript);
|
|
512
517
|
const [row] = await contracts.getContracts({ script });
|
|
513
518
|
if (!row) throw new LockupContractMissing(lockupAddress, script);
|
|
514
519
|
return row.params;
|
|
@@ -517,7 +522,7 @@ async function lockupContractParams(contracts, lockupAddress) {
|
|
|
517
522
|
// src/offer.ts
|
|
518
523
|
var import_base5 = require("@scure/base");
|
|
519
524
|
var import_utils2 = require("@scure/btc-signer/utils.js");
|
|
520
|
-
var
|
|
525
|
+
var import_sdk5 = require("@arkade-os/sdk");
|
|
521
526
|
|
|
522
527
|
// src/swap-want-asset.program.json
|
|
523
528
|
var swap_want_asset_program_default = {
|
|
@@ -644,12 +649,12 @@ async function retireOfferContract(manager, swaps, script) {
|
|
|
644
649
|
// src/store.ts
|
|
645
650
|
var import_base4 = require("@scure/base");
|
|
646
651
|
var import_sha23 = require("@noble/hashes/sha2.js");
|
|
647
|
-
var
|
|
652
|
+
var import_sdk4 = require("@arkade-os/sdk");
|
|
648
653
|
|
|
649
654
|
// src/repository.ts
|
|
650
|
-
var
|
|
651
|
-
var collectAssetSwaps = (repository) => (0,
|
|
652
|
-
var collectRfqSwaps = (repository, filter = {}) => (0,
|
|
655
|
+
var import_sdk3 = require("@arkade-os/sdk");
|
|
656
|
+
var collectAssetSwaps = (repository) => (0, import_sdk3.collectPages)((page) => repository.getAssetSwapsPage(page));
|
|
657
|
+
var collectRfqSwaps = (repository, filter = {}) => (0, import_sdk3.collectPages)(
|
|
653
658
|
(page) => repository.getRfqSwapsPage(filter, page)
|
|
654
659
|
);
|
|
655
660
|
|
|
@@ -747,7 +752,7 @@ var preimageForSwapRecord = async (wallet, record) => {
|
|
|
747
752
|
}
|
|
748
753
|
let preimage;
|
|
749
754
|
try {
|
|
750
|
-
preimage = await (0,
|
|
755
|
+
preimage = await (0, import_sdk4.contractPreimage)(wallet, record.signingDescriptor, { stored, salt });
|
|
751
756
|
} catch (cause) {
|
|
752
757
|
throw new PreimageNotRecoverableError(
|
|
753
758
|
"not-derivable",
|
|
@@ -766,8 +771,8 @@ var preimageForSwapRecord = async (wallet, record) => {
|
|
|
766
771
|
|
|
767
772
|
// src/offer.ts
|
|
768
773
|
var swapPrograms = {
|
|
769
|
-
wantAsset:
|
|
770
|
-
wantBtc:
|
|
774
|
+
wantAsset: import_sdk5.arkade.parseArtifact(swap_want_asset_program_default),
|
|
775
|
+
wantBtc: import_sdk5.arkade.parseArtifact(swap_want_btc_program_default)
|
|
771
776
|
};
|
|
772
777
|
function withExitClosure(program, exit) {
|
|
773
778
|
if (!exit) return program;
|
|
@@ -814,7 +819,7 @@ function swapProgramBinding(offer, operatorPubkey) {
|
|
|
814
819
|
}
|
|
815
820
|
function offerContract(offer, operatorPubkey) {
|
|
816
821
|
const { program, args, keys } = swapProgramBinding(offer, operatorPubkey);
|
|
817
|
-
return new
|
|
822
|
+
return new import_sdk5.arkade.ArkadeProgramScript(program, args, keys);
|
|
818
823
|
}
|
|
819
824
|
var OFFER_PACKET_TYPE = 3;
|
|
820
825
|
var FIELDS = {
|
|
@@ -951,8 +956,8 @@ function decodeOffer(data) {
|
|
|
951
956
|
return {
|
|
952
957
|
swapPkScript: need("swapPkScript"),
|
|
953
958
|
wantAmount: readU64(amount),
|
|
954
|
-
...fields.wantAsset && { wantAsset:
|
|
955
|
-
...fields.offerAsset && { offerAsset:
|
|
959
|
+
...fields.wantAsset && { wantAsset: import_sdk5.asset.AssetId.fromBytes(fields.wantAsset) },
|
|
960
|
+
...fields.offerAsset && { offerAsset: import_sdk5.asset.AssetId.fromBytes(fields.offerAsset) },
|
|
956
961
|
makerPkScript: need("makerPkScript"),
|
|
957
962
|
makerPublicKey: need("makerPublicKey"),
|
|
958
963
|
emulatorPubkey: need("emulatorPubkey"),
|
|
@@ -976,15 +981,15 @@ async function registerOfferContract(wallet, info, binding, operatorPubkey, expe
|
|
|
976
981
|
);
|
|
977
982
|
await promoteOfferContract(contractManager, import_base5.hex.encode(expectedPkScript));
|
|
978
983
|
}
|
|
979
|
-
var derivingClient = (wallet, info, contractManager) =>
|
|
984
|
+
var derivingClient = (wallet, info, contractManager) => import_sdk5.arkade.Arkade.connect({
|
|
980
985
|
arkade: { getInfo: async () => info },
|
|
981
986
|
identity: wallet.identity,
|
|
982
|
-
network: (0,
|
|
987
|
+
network: (0, import_sdk5.networkFromArkadeInfo)(info),
|
|
983
988
|
contractManager
|
|
984
989
|
});
|
|
985
990
|
function offerContractParams(client, binding, operatorPubkey, expectedPkScript) {
|
|
986
991
|
const { program, args, keys } = swapProgramBinding(binding, operatorPubkey);
|
|
987
|
-
const contract = new
|
|
992
|
+
const contract = new import_sdk5.arkade.ArkadeContract(client, program, args, keys);
|
|
988
993
|
if (import_base5.hex.encode(contract.pkScript) !== import_base5.hex.encode(expectedPkScript)) {
|
|
989
994
|
throw new Error("derived covenant does not match the offer's swapPkScript");
|
|
990
995
|
}
|
|
@@ -1028,13 +1033,13 @@ async function deriveOffer(wallet, params) {
|
|
|
1028
1033
|
wallet.getAddress(),
|
|
1029
1034
|
wallet.identity.xOnlyPublicKey()
|
|
1030
1035
|
]);
|
|
1031
|
-
return { pkScript:
|
|
1036
|
+
return { pkScript: import_sdk5.ArkAddress.decode(address).pkScript, publicKey };
|
|
1032
1037
|
})()
|
|
1033
1038
|
]);
|
|
1034
|
-
const operatorPubKey = import_base5.hex.decode((0,
|
|
1035
|
-
const network = (0,
|
|
1039
|
+
const operatorPubKey = import_base5.hex.decode((0, import_sdk5.toXOnlySignerHex)(info.signerPubkey));
|
|
1040
|
+
const network = (0, import_sdk5.networkFromArkadeInfo)(info);
|
|
1036
1041
|
const emuKey = import_base5.hex.decode(
|
|
1037
|
-
(0,
|
|
1042
|
+
(0, import_sdk5.toXOnlySignerHex)((0, import_sdk5.resolveEmulatorPubkey)(network, params.emulatorPubkey))
|
|
1038
1043
|
);
|
|
1039
1044
|
const binding = Object.freeze({
|
|
1040
1045
|
wantAmount: params.wantAmount,
|
|
@@ -1122,7 +1127,7 @@ async function prepareOfferCancel(wallet, offerHex, opts) {
|
|
|
1122
1127
|
wallet.getArkadeReader(),
|
|
1123
1128
|
wallet.getArkadeBroadcaster()
|
|
1124
1129
|
]);
|
|
1125
|
-
const client = await
|
|
1130
|
+
const client = await import_sdk5.arkade.Arkade.connect({
|
|
1126
1131
|
arkade: { getInfo: async () => info, ...broadcaster },
|
|
1127
1132
|
indexer: reader,
|
|
1128
1133
|
identity: wallet.identity,
|
|
@@ -1131,18 +1136,18 @@ async function prepareOfferCancel(wallet, offerHex, opts) {
|
|
|
1131
1136
|
contractManager
|
|
1132
1137
|
// no `network`: the row lookup is by script and the payout comes from wallet.getAddress()
|
|
1133
1138
|
});
|
|
1134
|
-
const operatorPubkey = swapAddress ?
|
|
1139
|
+
const operatorPubkey = swapAddress ? import_sdk5.ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
|
|
1135
1140
|
const { program, args, keys } = swapProgramBinding(offer, operatorPubkey);
|
|
1136
1141
|
let rebuilt;
|
|
1137
1142
|
try {
|
|
1138
|
-
rebuilt = new
|
|
1143
|
+
rebuilt = new import_sdk5.arkade.ArkadeProgramScript(program, args, keys);
|
|
1139
1144
|
} catch (cause) {
|
|
1140
1145
|
throw new OfferCovenantMismatchError(import_base5.hex.encode(offer.swapPkScript), { cause });
|
|
1141
1146
|
}
|
|
1142
1147
|
if (import_base5.hex.encode(rebuilt.pkScript) !== import_base5.hex.encode(offer.swapPkScript)) {
|
|
1143
1148
|
throw new OfferCovenantMismatchError(import_base5.hex.encode(offer.swapPkScript));
|
|
1144
1149
|
}
|
|
1145
|
-
const contract = new
|
|
1150
|
+
const contract = new import_sdk5.arkade.ArkadeContract(client, program, args, keys);
|
|
1146
1151
|
const [vtxos, makerAddress] = await Promise.all([contract.getUtxos(), wallet.getAddress()]);
|
|
1147
1152
|
if (!fundingTxid && vtxos.length > 1) {
|
|
1148
1153
|
throw new Error(
|
|
@@ -1151,7 +1156,7 @@ async function prepareOfferCancel(wallet, offerHex, opts) {
|
|
|
1151
1156
|
}
|
|
1152
1157
|
const vtxo = fundingTxid ? vtxos.find((v) => v.txid === fundingTxid) : vtxos[0];
|
|
1153
1158
|
if (!vtxo) throw new NoSpendableDepositError();
|
|
1154
|
-
const makerPkScript =
|
|
1159
|
+
const makerPkScript = import_sdk5.ArkAddress.decode(makerAddress).pkScript;
|
|
1155
1160
|
const cancel = contract.functions.cancel().from({ txid: vtxo.txid, vout: vtxo.vout, value: vtxo.value }).to(makerPkScript, BigInt(vtxo.value));
|
|
1156
1161
|
for (const a of vtxo.assets ?? []) {
|
|
1157
1162
|
cancel.withAsset({
|
|
@@ -1166,7 +1171,7 @@ async function prepareOfferCancel(wallet, offerHex, opts) {
|
|
|
1166
1171
|
send: async () => (await cancel.send()).txid
|
|
1167
1172
|
};
|
|
1168
1173
|
}
|
|
1169
|
-
var ASSET_CARRIER_SATS = BigInt(
|
|
1174
|
+
var ASSET_CARRIER_SATS = BigInt(import_sdk5.ASSET_CARRIER_SATS);
|
|
1170
1175
|
async function fillOffer(wallet, arkServerUrl, offerHex, opts) {
|
|
1171
1176
|
const {
|
|
1172
1177
|
fund,
|
|
@@ -1194,25 +1199,25 @@ async function fillOffer(wallet, arkServerUrl, offerHex, opts) {
|
|
|
1194
1199
|
}
|
|
1195
1200
|
}
|
|
1196
1201
|
const contractManager = await wallet.getContractManager();
|
|
1197
|
-
const client = await
|
|
1198
|
-
arkade: new
|
|
1199
|
-
indexer: new
|
|
1202
|
+
const client = await import_sdk5.arkade.Arkade.connect({
|
|
1203
|
+
arkade: new import_sdk5.RestArkProvider(arkServerUrl),
|
|
1204
|
+
indexer: new import_sdk5.RestIndexerProvider(arkServerUrl),
|
|
1200
1205
|
identity: wallet.identity,
|
|
1201
1206
|
contractManager,
|
|
1202
|
-
emulator: typeof emulator === "string" ? new
|
|
1207
|
+
emulator: typeof emulator === "string" ? new import_sdk5.RestEmulatorProvider(emulator) : emulator,
|
|
1203
1208
|
// only for the client's own emulatorKey, which this fill never derives against (the offer's
|
|
1204
1209
|
// key is bound below) — but it must still resolve on a network with no pinned key
|
|
1205
1210
|
...emulatorPubkey ? { emulatorPubkey } : {}
|
|
1206
1211
|
});
|
|
1207
|
-
const serverKey = swapAddress ?
|
|
1212
|
+
const serverKey = swapAddress ? import_sdk5.ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
|
|
1208
1213
|
const { program, args, keys } = swapProgramBinding(offer, serverKey);
|
|
1209
|
-
const rebuilt = new
|
|
1214
|
+
const rebuilt = new import_sdk5.arkade.ArkadeProgramScript(program, args, keys);
|
|
1210
1215
|
if (import_base5.hex.encode(rebuilt.pkScript) !== import_base5.hex.encode(offer.swapPkScript)) {
|
|
1211
1216
|
throw new Error(
|
|
1212
1217
|
"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"
|
|
1213
1218
|
);
|
|
1214
1219
|
}
|
|
1215
|
-
const contract = new
|
|
1220
|
+
const contract = new import_sdk5.arkade.ArkadeContract(client, program, args, keys);
|
|
1216
1221
|
const [vtxos, takerAddress] = await Promise.all([contract.getUtxos(), wallet.getAddress()]);
|
|
1217
1222
|
if (!fundingTxid && vtxos.length > 1) {
|
|
1218
1223
|
throw new Error(
|
|
@@ -1230,7 +1235,7 @@ async function fillOffer(wallet, arkServerUrl, offerHex, opts) {
|
|
|
1230
1235
|
);
|
|
1231
1236
|
}
|
|
1232
1237
|
}
|
|
1233
|
-
const payout = payoutScript ??
|
|
1238
|
+
const payout = payoutScript ?? import_sdk5.ArkAddress.decode(takerAddress).pkScript;
|
|
1234
1239
|
const makerSats = wantedAssetId === void 0 ? offer.wantAmount : assetCarrierSats;
|
|
1235
1240
|
const fill = contract.functions.fulfill().from({ txid: vtxo.txid, vout: vtxo.vout, value: vtxo.value }).fund(fund).to(offer.makerPkScript, makerSats).change(payout);
|
|
1236
1241
|
const held = /* @__PURE__ */ new Map();
|
|
@@ -1520,6 +1525,12 @@ var assertFundable = (input) => {
|
|
|
1520
1525
|
const fail = (reason, message) => {
|
|
1521
1526
|
throw gateError(reason, message);
|
|
1522
1527
|
};
|
|
1528
|
+
if (input.quote.pair.split("->").some((leg) => leg.startsWith("ethereum:"))) {
|
|
1529
|
+
fail(
|
|
1530
|
+
"evm_funding_unavailable",
|
|
1531
|
+
"EVM funding is unavailable until local contract, finality, and deadline verification is implemented"
|
|
1532
|
+
);
|
|
1533
|
+
}
|
|
1523
1534
|
if (input.quote.valid_until === void 0) {
|
|
1524
1535
|
fail("quote_malformed", "quote carries no valid_until");
|
|
1525
1536
|
}
|
|
@@ -1653,6 +1664,7 @@ var httpTransport = (baseUrl, options = {}) => {
|
|
|
1653
1664
|
};
|
|
1654
1665
|
var relayTransport = (relayUrl, options) => {
|
|
1655
1666
|
const timeoutMs = options.timeoutMs ?? 3e4;
|
|
1667
|
+
(0, import_sdk6.assertTimerMs)("timeoutMs", timeoutMs);
|
|
1656
1668
|
const Ctor = options.WebSocketCtor ?? WebSocket;
|
|
1657
1669
|
const pending = /* @__PURE__ */ new Map();
|
|
1658
1670
|
let sequence = 0;
|
|
@@ -1756,7 +1768,7 @@ var seconds = (value) => ({
|
|
|
1756
1768
|
type: "seconds",
|
|
1757
1769
|
value: BigInt(value)
|
|
1758
1770
|
});
|
|
1759
|
-
var suiteVhtlc = (params, roles) => new
|
|
1771
|
+
var suiteVhtlc = (params, roles) => new import_sdk6.VHTLC.ScriptV2({
|
|
1760
1772
|
sender: roles.sender,
|
|
1761
1773
|
receiver: roles.receiver,
|
|
1762
1774
|
server: params.operatorPubkey,
|
|
@@ -1803,7 +1815,7 @@ function deriveLightningSend(input) {
|
|
|
1803
1815
|
throw new Error("lightning-send quote is missing profile.receiver_pk_script");
|
|
1804
1816
|
}
|
|
1805
1817
|
const contractParams = {
|
|
1806
|
-
solverPubkey: (0,
|
|
1818
|
+
solverPubkey: (0, import_sdk6.toXOnly)(import_base6.hex.decode(quote.solver_pubkey), "solver key"),
|
|
1807
1819
|
refundLocktime: quote.refund_locktime,
|
|
1808
1820
|
operatorPubkey: input.operatorPubkey,
|
|
1809
1821
|
paymentHash: input.paymentHash,
|
|
@@ -1833,7 +1845,7 @@ function deriveLightningSend(input) {
|
|
|
1833
1845
|
}
|
|
1834
1846
|
async function requestLightningSend(wallet, transport, params) {
|
|
1835
1847
|
const rfqId = params.rfqId ?? newRfqId();
|
|
1836
|
-
const secrets = await (0,
|
|
1848
|
+
const secrets = await (0, import_sdk7.provisionRefundKey)(wallet);
|
|
1837
1849
|
const senderPubkey = secrets.pubkey;
|
|
1838
1850
|
const refundAddress = secrets.address;
|
|
1839
1851
|
const info = await wallet.getArkadeInfo({ requireLive: true });
|
|
@@ -1852,16 +1864,16 @@ async function requestLightningSend(wallet, transport, params) {
|
|
|
1852
1864
|
`quote from_amount ${quote.from_amount} is below the invoice amount \u2014 a negative spread is not a quote`
|
|
1853
1865
|
);
|
|
1854
1866
|
}
|
|
1855
|
-
const operatorPubkey = (0,
|
|
1856
|
-
const network = (0,
|
|
1867
|
+
const operatorPubkey = (0, import_sdk6.toXOnly)(import_base6.hex.decode(info.signerPubkey), "ark signer key");
|
|
1868
|
+
const network = (0, import_sdk6.networkFromArkadeInfo)(info);
|
|
1857
1869
|
const derived = deriveLightningSend({
|
|
1858
1870
|
quote,
|
|
1859
1871
|
paymentHash: params.invoice.paymentHash,
|
|
1860
1872
|
senderPubkey,
|
|
1861
1873
|
refundPkScript: secrets.pkScript,
|
|
1862
1874
|
operatorPubkey,
|
|
1863
|
-
emulatorPubkey: (0,
|
|
1864
|
-
import_base6.hex.decode((0,
|
|
1875
|
+
emulatorPubkey: (0, import_sdk6.toXOnly)(
|
|
1876
|
+
import_base6.hex.decode((0, import_sdk6.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
|
|
1865
1877
|
"emulator signer key"
|
|
1866
1878
|
),
|
|
1867
1879
|
claimDelay,
|
|
@@ -1940,7 +1952,7 @@ async function requestArkadeSwap(wallet, transport, params) {
|
|
|
1940
1952
|
wallet.getAddress(),
|
|
1941
1953
|
wallet.identity.xOnlyPublicKey()
|
|
1942
1954
|
]);
|
|
1943
|
-
const makerPkScript =
|
|
1955
|
+
const makerPkScript = import_sdk6.ArkAddress.decode(makerAddress).pkScript;
|
|
1944
1956
|
const pair = rfqPair(
|
|
1945
1957
|
params.offerAsset ? arkadeAssetLeg(params.offerAsset) : ARKADE_BTC,
|
|
1946
1958
|
params.wantAsset ? arkadeAssetLeg(params.wantAsset) : ARKADE_BTC
|
|
@@ -2010,11 +2022,11 @@ async function requestArkadeSwap(wallet, transport, params) {
|
|
|
2010
2022
|
}
|
|
2011
2023
|
var l1NetworkFromArk = (network) => network === "bitcoin" ? "bitcoin" : network === "regtest" ? "regtest" : "testnet";
|
|
2012
2024
|
var serverTerms = (info, emulatorPubkey) => {
|
|
2013
|
-
const network = (0,
|
|
2025
|
+
const network = (0, import_sdk6.networkFromArkadeInfo)(info);
|
|
2014
2026
|
return {
|
|
2015
|
-
operatorPubkey: (0,
|
|
2016
|
-
emulatorPubkey: (0,
|
|
2017
|
-
import_base6.hex.decode((0,
|
|
2027
|
+
operatorPubkey: (0, import_sdk6.toXOnly)(import_base6.hex.decode(info.signerPubkey), "ark signer key"),
|
|
2028
|
+
emulatorPubkey: (0, import_sdk6.toXOnly)(
|
|
2029
|
+
import_base6.hex.decode((0, import_sdk6.resolveEmulatorPubkey)(network, emulatorPubkey)),
|
|
2018
2030
|
"emulator signer key"
|
|
2019
2031
|
),
|
|
2020
2032
|
claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
|
|
@@ -2077,7 +2089,7 @@ function deriveOnchainSend(input) {
|
|
|
2077
2089
|
throw new Error("onchain-send quote is missing a binding field");
|
|
2078
2090
|
}
|
|
2079
2091
|
const contractParams = {
|
|
2080
|
-
solverPubkey: (0,
|
|
2092
|
+
solverPubkey: (0, import_sdk6.toXOnly)(import_base6.hex.decode(quote.solver_pubkey), "solver key"),
|
|
2081
2093
|
refundLocktime,
|
|
2082
2094
|
operatorPubkey: input.operatorPubkey,
|
|
2083
2095
|
paymentHash: input.paymentHash,
|
|
@@ -2085,7 +2097,7 @@ function deriveOnchainSend(input) {
|
|
|
2085
2097
|
emulatorPubkey: input.emulatorPubkey,
|
|
2086
2098
|
senderPubkey: input.senderPubkey,
|
|
2087
2099
|
receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
|
|
2088
|
-
refundPkScript:
|
|
2100
|
+
refundPkScript: import_sdk6.ArkAddress.decode(input.refundAddress).pkScript
|
|
2089
2101
|
};
|
|
2090
2102
|
const { script, address } = matchQuotedLockup(
|
|
2091
2103
|
quote,
|
|
@@ -2096,7 +2108,7 @@ function deriveOnchainSend(input) {
|
|
|
2096
2108
|
const htlcParams = {
|
|
2097
2109
|
paymentHash: input.paymentHash,
|
|
2098
2110
|
claimKey: input.payoutPubkey,
|
|
2099
|
-
refundKey: (0,
|
|
2111
|
+
refundKey: (0, import_sdk6.toXOnly)(import_base6.hex.decode(htlcPubkey), "solver L1 htlc key"),
|
|
2100
2112
|
refundLocktime: htlcLocktime
|
|
2101
2113
|
};
|
|
2102
2114
|
const htlc = onchainHtlcScript(htlcParams, input.l1Network);
|
|
@@ -2116,7 +2128,7 @@ function deriveOnchainSend(input) {
|
|
|
2116
2128
|
}
|
|
2117
2129
|
async function requestOnchainSend(wallet, transport, params) {
|
|
2118
2130
|
const rfqId = params.rfqId ?? newRfqId();
|
|
2119
|
-
const secrets = await (0,
|
|
2131
|
+
const secrets = await (0, import_sdk7.provisionClaimSecret)(wallet, { preimage: params.preimage });
|
|
2120
2132
|
if (secrets.mustPersistPreimage) {
|
|
2121
2133
|
console.warn(
|
|
2122
2134
|
"[swap] this swap's preimage cannot be re-derived from the seed and MUST be persisted with the record before funding"
|
|
@@ -2258,7 +2270,7 @@ function lightningReceiveContract(params) {
|
|
|
2258
2270
|
}
|
|
2259
2271
|
var matchReceiveLockup = (input, refundLocktime, solverRefundPkScriptHex) => {
|
|
2260
2272
|
const contractParams = {
|
|
2261
|
-
solverPubkey: (0,
|
|
2273
|
+
solverPubkey: (0, import_sdk6.toXOnly)(import_base6.hex.decode(input.quote.solver_pubkey), "solver key"),
|
|
2262
2274
|
refundLocktime,
|
|
2263
2275
|
operatorPubkey: input.operatorPubkey,
|
|
2264
2276
|
paymentHash: input.paymentHash,
|
|
@@ -2266,7 +2278,7 @@ var matchReceiveLockup = (input, refundLocktime, solverRefundPkScriptHex) => {
|
|
|
2266
2278
|
emulatorPubkey: input.emulatorPubkey,
|
|
2267
2279
|
solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
|
|
2268
2280
|
payoutPubkey: input.payoutPubkey,
|
|
2269
|
-
payoutPkScript:
|
|
2281
|
+
payoutPkScript: import_sdk6.ArkAddress.decode(input.payoutAddress).pkScript
|
|
2270
2282
|
};
|
|
2271
2283
|
const matched = matchQuotedLockup(
|
|
2272
2284
|
input.quote,
|
|
@@ -2303,7 +2315,7 @@ function deriveLightningReceive(input) {
|
|
|
2303
2315
|
};
|
|
2304
2316
|
}
|
|
2305
2317
|
var provisionReceive = async (wallet, covclaimdPubkey, persistBefore) => {
|
|
2306
|
-
const secrets = await (0,
|
|
2318
|
+
const secrets = await (0, import_sdk7.provisionClaimSecret)(wallet);
|
|
2307
2319
|
if (secrets.mustPersistPreimage) {
|
|
2308
2320
|
console.warn(
|
|
2309
2321
|
`[swap] this swap's preimage cannot be re-derived from the seed and MUST be persisted with the record before ${persistBefore}`
|
|
@@ -2319,15 +2331,29 @@ var provisionReceive = async (wallet, covclaimdPubkey, persistBefore) => {
|
|
|
2319
2331
|
const claimPacket = covclaimdPubkey ? await sealClaimPacket({ preimage, covclaimdPubkey }) : void 0;
|
|
2320
2332
|
return { secrets, paymentHash, payoutPubkey, info, payoutAddress, claimPacket };
|
|
2321
2333
|
};
|
|
2334
|
+
var quoteReceive = async (wallet, transport, covclaimdPubkey, persistBefore, request) => {
|
|
2335
|
+
for (let attempt = 0; ; attempt++) {
|
|
2336
|
+
const provisioned = await provisionReceive(wallet, covclaimdPubkey, persistBefore);
|
|
2337
|
+
try {
|
|
2338
|
+
return { ...provisioned, quote: await transport.requestQuote(request(provisioned)) };
|
|
2339
|
+
} catch (error) {
|
|
2340
|
+
const conflict = error instanceof SwapRefusal && error.reason === "quote_conflict";
|
|
2341
|
+
if (!conflict || attempt >= 1) throw error;
|
|
2342
|
+
}
|
|
2343
|
+
}
|
|
2344
|
+
};
|
|
2322
2345
|
async function requestLightningReceive(wallet, transport, params) {
|
|
2323
2346
|
const rfqId = params.rfqId ?? newRfqId();
|
|
2324
|
-
const { secrets, paymentHash, payoutPubkey, info, payoutAddress,
|
|
2325
|
-
|
|
2326
|
-
|
|
2347
|
+
const { secrets, paymentHash, payoutPubkey, info, payoutAddress, quote } = await quoteReceive(
|
|
2348
|
+
wallet,
|
|
2349
|
+
transport,
|
|
2350
|
+
params.covclaimdPubkey,
|
|
2351
|
+
"paying",
|
|
2352
|
+
({ paymentHash: paymentHash2, payoutAddress: payoutAddress2, payoutPubkey: payoutPubkey2, claimPacket }) => lightningReceiveRequest({
|
|
2327
2353
|
rfqId,
|
|
2328
|
-
paymentHash,
|
|
2329
|
-
payoutAddress,
|
|
2330
|
-
payoutPubkey,
|
|
2354
|
+
paymentHash: paymentHash2,
|
|
2355
|
+
payoutAddress: payoutAddress2,
|
|
2356
|
+
payoutPubkey: payoutPubkey2,
|
|
2331
2357
|
claimPacket: claimPacket?.packet,
|
|
2332
2358
|
amount: params.amount,
|
|
2333
2359
|
amountSide: params.amountSide
|
|
@@ -2387,21 +2413,20 @@ function deriveOnchainReceive(input) {
|
|
|
2387
2413
|
refundLocktime,
|
|
2388
2414
|
solverRefundPkScriptHex
|
|
2389
2415
|
).matched;
|
|
2390
|
-
const
|
|
2391
|
-
|
|
2392
|
-
|
|
2393
|
-
|
|
2394
|
-
|
|
2395
|
-
|
|
2396
|
-
|
|
2397
|
-
input.l1Network
|
|
2398
|
-
);
|
|
2416
|
+
const htlcParams = {
|
|
2417
|
+
paymentHash: input.paymentHash,
|
|
2418
|
+
claimKey: (0, import_sdk6.toXOnly)(import_base6.hex.decode(claimPubkey), "solver L1 claim key"),
|
|
2419
|
+
refundKey: input.refundPubkey,
|
|
2420
|
+
refundLocktime: htlcLocktime
|
|
2421
|
+
};
|
|
2422
|
+
const htlc = onchainHtlcScript(htlcParams, input.l1Network);
|
|
2399
2423
|
if (htlc.address !== htlcAddress) throw new AddressMismatch(htlc.address, htlcAddress);
|
|
2400
2424
|
return {
|
|
2401
2425
|
address,
|
|
2402
2426
|
swapPkScript: script.pkScript,
|
|
2403
2427
|
script,
|
|
2404
2428
|
htlc,
|
|
2429
|
+
htlcParams,
|
|
2405
2430
|
refundLocktime,
|
|
2406
2431
|
htlcLocktime,
|
|
2407
2432
|
minConfirmations
|
|
@@ -2409,13 +2434,16 @@ function deriveOnchainReceive(input) {
|
|
|
2409
2434
|
}
|
|
2410
2435
|
async function requestOnchainReceive(wallet, transport, params) {
|
|
2411
2436
|
const rfqId = params.rfqId ?? newRfqId();
|
|
2412
|
-
const { secrets, paymentHash, payoutPubkey, info, payoutAddress,
|
|
2413
|
-
|
|
2414
|
-
|
|
2437
|
+
const { secrets, paymentHash, payoutPubkey, info, payoutAddress, quote } = await quoteReceive(
|
|
2438
|
+
wallet,
|
|
2439
|
+
transport,
|
|
2440
|
+
params.covclaimdPubkey,
|
|
2441
|
+
"funding",
|
|
2442
|
+
({ paymentHash: paymentHash2, payoutAddress: payoutAddress2, payoutPubkey: payoutPubkey2, claimPacket }) => onchainReceiveRequest({
|
|
2415
2443
|
rfqId,
|
|
2416
|
-
paymentHash,
|
|
2417
|
-
payoutAddress,
|
|
2418
|
-
payoutPubkey,
|
|
2444
|
+
paymentHash: paymentHash2,
|
|
2445
|
+
payoutAddress: payoutAddress2,
|
|
2446
|
+
payoutPubkey: payoutPubkey2,
|
|
2419
2447
|
refundPubkey: params.refundPubkey,
|
|
2420
2448
|
claimPacket: claimPacket?.packet,
|
|
2421
2449
|
amount: params.amount,
|
|
@@ -2502,7 +2530,7 @@ async function findLockupVtxos(contracts, swapPkScript) {
|
|
|
2502
2530
|
const out = [];
|
|
2503
2531
|
for (const vtxo of row?.vtxos ?? []) {
|
|
2504
2532
|
if (vtxo.isUnrolled) continue;
|
|
2505
|
-
if ((0,
|
|
2533
|
+
if ((0, import_sdk8.isVtxoSpent)(vtxo)) continue;
|
|
2506
2534
|
const key = `${vtxo.txid}:${vtxo.vout}`;
|
|
2507
2535
|
if (seen.has(key)) continue;
|
|
2508
2536
|
seen.add(key);
|
|
@@ -2517,14 +2545,14 @@ async function findLockupVtxos(contracts, swapPkScript) {
|
|
|
2517
2545
|
}
|
|
2518
2546
|
var hashesTo = (candidate, paymentHash) => import_base7.hex.encode((0, import_sha24.sha256)(candidate)) === paymentHash;
|
|
2519
2547
|
var candidateWitnessItems = (tx, inputIndex) => [
|
|
2520
|
-
...(0,
|
|
2548
|
+
...(0, import_sdk8.getArkPsbtFields)(tx, inputIndex, import_sdk8.ConditionWitness).flat(),
|
|
2521
2549
|
...tx.getInput(inputIndex).finalScriptWitness ?? []
|
|
2522
2550
|
];
|
|
2523
2551
|
async function readLockupFate(indexer, input) {
|
|
2524
2552
|
const { vtxos } = await indexer.getVtxos({ scripts: [import_base7.hex.encode(input.swapPkScript)] });
|
|
2525
2553
|
const all = vtxos ?? [];
|
|
2526
2554
|
if (all.length === 0) return { fate: "unknown" };
|
|
2527
|
-
const exited = all.filter((vtxo) => vtxo.isUnrolled && !(0,
|
|
2555
|
+
const exited = all.filter((vtxo) => vtxo.isUnrolled && !(0, import_sdk8.isVtxoSpent)(vtxo));
|
|
2528
2556
|
if (exited.length > 0) {
|
|
2529
2557
|
return {
|
|
2530
2558
|
fate: "exited",
|
|
@@ -2534,7 +2562,7 @@ async function readLockupFate(indexer, input) {
|
|
|
2534
2562
|
const spentBy = /* @__PURE__ */ new Map();
|
|
2535
2563
|
let everySpendNamed = true;
|
|
2536
2564
|
for (const vtxo of all) {
|
|
2537
|
-
if (!(0,
|
|
2565
|
+
if (!(0, import_sdk8.isVtxoSpent)(vtxo)) return { fate: "open" };
|
|
2538
2566
|
if (vtxo.spentBy)
|
|
2539
2567
|
spentBy.set(vtxo.spentBy, {
|
|
2540
2568
|
checkpointTxid: vtxo.spentBy,
|
|
@@ -2548,7 +2576,7 @@ async function readLockupFate(indexer, input) {
|
|
|
2548
2576
|
for (const raw of txs) {
|
|
2549
2577
|
let tx;
|
|
2550
2578
|
try {
|
|
2551
|
-
tx =
|
|
2579
|
+
tx = import_sdk8.Transaction.fromPSBT(import_base7.base64.decode(raw));
|
|
2552
2580
|
} catch {
|
|
2553
2581
|
continue;
|
|
2554
2582
|
}
|
|
@@ -2578,10 +2606,10 @@ var assertNoneSwept = (vtxos, contract) => {
|
|
|
2578
2606
|
};
|
|
2579
2607
|
var operatorUnrollScript = async (operator, network) => {
|
|
2580
2608
|
const info = await operator.getInfo();
|
|
2581
|
-
return (0,
|
|
2609
|
+
return (0, import_sdk8.assertValidServerUnrollScript)(
|
|
2582
2610
|
info.checkpointTapscript,
|
|
2583
|
-
(0,
|
|
2584
|
-
advertisedForfeitPubkey: (0,
|
|
2611
|
+
(0, import_sdk8.resolveCheckpointExitDelayPolicy)(network ?? (0, import_sdk8.networkFromArkadeInfo)(info), {
|
|
2612
|
+
advertisedForfeitPubkey: (0, import_sdk8.toXOnly)(import_base7.hex.decode(info.forfeitPubkey), "forfeit key")
|
|
2585
2613
|
})
|
|
2586
2614
|
);
|
|
2587
2615
|
};
|
|
@@ -2607,7 +2635,7 @@ async function pushRefundWithoutReceiver(operator, input) {
|
|
|
2607
2635
|
const serverUnrollScript = await operatorUnrollScript(operator, input.network);
|
|
2608
2636
|
const leaf = input.contract.refundWithoutReceiver();
|
|
2609
2637
|
const amount = input.vtxos.reduce((sum, vtxo) => sum + vtxo.value, 0);
|
|
2610
|
-
const { arkTx: tx, checkpoints } = (0,
|
|
2638
|
+
const { arkTx: tx, checkpoints } = (0, import_sdk8.buildOffchainTx)(
|
|
2611
2639
|
lockupInputs(input.vtxos, input.contract, leaf),
|
|
2612
2640
|
[{ script: refundPkScript, amount: BigInt(amount) }],
|
|
2613
2641
|
serverUnrollScript
|
|
@@ -2617,8 +2645,8 @@ async function pushRefundWithoutReceiver(operator, input) {
|
|
|
2617
2645
|
import_base7.base64.encode(signedTx.toPSBT()),
|
|
2618
2646
|
checkpoints.map((c) => import_base7.base64.encode(c.toPSBT()))
|
|
2619
2647
|
);
|
|
2620
|
-
(0,
|
|
2621
|
-
const matched = (0,
|
|
2648
|
+
(0, import_sdk8.assertSubmittedArkTxid)(submitted, signedTx, "refundWithoutReceiver");
|
|
2649
|
+
const matched = (0, import_sdk8.matchServerCheckpoints)(
|
|
2622
2650
|
submitted.signedCheckpointTxs,
|
|
2623
2651
|
checkpoints,
|
|
2624
2652
|
"refundWithoutReceiver"
|
|
@@ -2634,6 +2662,7 @@ async function pushRefundWithoutReceiver(operator, input) {
|
|
|
2634
2662
|
var REFUND_MTP_LAG_SECONDS = 2 * 60 * 60;
|
|
2635
2663
|
async function refundIfUnresolved(transport, operator, contracts, indexer, input) {
|
|
2636
2664
|
const pollMs = input.pollMs ?? 5e3;
|
|
2665
|
+
(0, import_sdk8.assertTimerMs)("pollMs", pollMs);
|
|
2637
2666
|
const now = input.now ?? (() => Math.floor(Date.now() / 1e3));
|
|
2638
2667
|
const attemptDeadline = input.attemptDeadline ?? input.refundLocktime + REFUND_MTP_LAG_SECONDS;
|
|
2639
2668
|
for (; ; ) {
|
|
@@ -2682,7 +2711,7 @@ async function refundIfUnresolved(transport, operator, contracts, indexer, input
|
|
|
2682
2711
|
}
|
|
2683
2712
|
|
|
2684
2713
|
// src/rfqRecord.ts
|
|
2685
|
-
var
|
|
2714
|
+
var import_sdk9 = require("@arkade-os/sdk");
|
|
2686
2715
|
var import_base9 = require("@scure/base");
|
|
2687
2716
|
|
|
2688
2717
|
// src/rfqSwapState.ts
|
|
@@ -2911,9 +2940,80 @@ var OnchainSendCorridor = {
|
|
|
2911
2940
|
// Our own L1 claim only: `funding` is the solver's tx, not a row this wallet made.
|
|
2912
2941
|
activityTxids: (profile) => profile.claimTxid ? [profile.claimTxid] : []
|
|
2913
2942
|
};
|
|
2943
|
+
function onchainReceiveProfile(result) {
|
|
2944
|
+
return {
|
|
2945
|
+
claimKey: import_base8.hex.encode(result.htlcParams.claimKey),
|
|
2946
|
+
refundKey: import_base8.hex.encode(result.htlcParams.refundKey),
|
|
2947
|
+
htlcLocktime: result.htlcParams.refundLocktime,
|
|
2948
|
+
network: result.l1Network,
|
|
2949
|
+
htlcAddress: result.htlc.address,
|
|
2950
|
+
minConfirmations: result.minConfirmations,
|
|
2951
|
+
refundPkScript: import_base8.hex.encode(result.refundPkScript),
|
|
2952
|
+
...result.refundDescriptor === void 0 ? {} : { refundDescriptor: result.refundDescriptor }
|
|
2953
|
+
};
|
|
2954
|
+
}
|
|
2955
|
+
var OnchainReceiveCorridor = {
|
|
2956
|
+
kind: "onchain_receive",
|
|
2957
|
+
project: (swap) => {
|
|
2958
|
+
const receive = swap;
|
|
2959
|
+
return {
|
|
2960
|
+
expectedAmount: receive.expectedAmount,
|
|
2961
|
+
...receive.claimTxid ? { claimTxid: receive.claimTxid } : {},
|
|
2962
|
+
...receive.funding ? { funding: receive.funding } : {}
|
|
2963
|
+
};
|
|
2964
|
+
},
|
|
2965
|
+
hydrate(profile) {
|
|
2966
|
+
const { paymentHash } = hydrateHashlock(profile);
|
|
2967
|
+
if (typeof profile.expectedAmount !== "number" || !Number.isFinite(profile.expectedAmount)) {
|
|
2968
|
+
throw new Error("onchain_receive record carries no expectedAmount; it cannot claim");
|
|
2969
|
+
}
|
|
2970
|
+
if (!profile.claimKey || !profile.refundKey) {
|
|
2971
|
+
throw new Error(
|
|
2972
|
+
"onchain_receive record carries no L1 keys; its HTLC cannot be rebuilt and the trader's own funding could never be taken back"
|
|
2973
|
+
);
|
|
2974
|
+
}
|
|
2975
|
+
if (!Number.isInteger(profile.minConfirmations) || profile.minConfirmations < 1) {
|
|
2976
|
+
throw new Error(
|
|
2977
|
+
`onchain_receive record carries no usable minConfirmations (${String(profile.minConfirmations)}); the confirmation gate cannot be checked`
|
|
2978
|
+
);
|
|
2979
|
+
}
|
|
2980
|
+
if (!profile.refundPkScript) {
|
|
2981
|
+
throw new Error(
|
|
2982
|
+
"onchain_receive record carries no refundPkScript; its L1 refund could not be built, so the trader's funding would be stranded"
|
|
2983
|
+
);
|
|
2984
|
+
}
|
|
2985
|
+
const htlc = onchainHtlcScript(
|
|
2986
|
+
{
|
|
2987
|
+
paymentHash,
|
|
2988
|
+
claimKey: import_base8.hex.decode(profile.claimKey),
|
|
2989
|
+
refundKey: import_base8.hex.decode(profile.refundKey),
|
|
2990
|
+
refundLocktime: profile.htlcLocktime
|
|
2991
|
+
},
|
|
2992
|
+
profile.network
|
|
2993
|
+
);
|
|
2994
|
+
if (htlc.address !== profile.htlcAddress) {
|
|
2995
|
+
throw new Error(
|
|
2996
|
+
`onchain_receive record's L1 inputs derive ${htlc.address}, but the funding went to ${String(profile.htlcAddress)} \u2014 these are not this swap's`
|
|
2997
|
+
);
|
|
2998
|
+
}
|
|
2999
|
+
return {
|
|
3000
|
+
paymentHash,
|
|
3001
|
+
htlc,
|
|
3002
|
+
expectedAmount: profile.expectedAmount,
|
|
3003
|
+
minConfirmations: profile.minConfirmations,
|
|
3004
|
+
refundPkScript: import_base8.hex.decode(profile.refundPkScript),
|
|
3005
|
+
...profile.claimTxid ? { claimTxid: profile.claimTxid } : {},
|
|
3006
|
+
...profile.funding ? { funding: profile.funding } : {}
|
|
3007
|
+
};
|
|
3008
|
+
},
|
|
3009
|
+
claimSecret: (profile) => ({ ...profile.signer, ...profile.hashlock }),
|
|
3010
|
+
// The L1 refund is the record's own `refundTxid`, read by the activity resolver directly.
|
|
3011
|
+
activityTxids: (profile) => profile.claimTxid ? [profile.claimTxid] : []
|
|
3012
|
+
};
|
|
2914
3013
|
rfqCorridorHandlers.register(LightningSendCorridor);
|
|
2915
3014
|
rfqCorridorHandlers.register(LightningReceiveCorridor);
|
|
2916
3015
|
rfqCorridorHandlers.register(OnchainSendCorridor);
|
|
3016
|
+
rfqCorridorHandlers.register(OnchainReceiveCorridor);
|
|
2917
3017
|
|
|
2918
3018
|
// src/rfqRecord.ts
|
|
2919
3019
|
var RFQ_SWAP_RETENTION_SECONDS = 30 * 24 * 60 * 60;
|
|
@@ -2957,7 +3057,7 @@ function assertSameSwap(origin, swap) {
|
|
|
2957
3057
|
`rfq swap record is a ${origin.kind} origin paired with a ${swap.kind} swap`
|
|
2958
3058
|
);
|
|
2959
3059
|
}
|
|
2960
|
-
const funded = import_base9.hex.encode(
|
|
3060
|
+
const funded = import_base9.hex.encode(import_sdk9.ArkAddress.decode(origin.lockupAddress).pkScript);
|
|
2961
3061
|
const watched = import_base9.hex.encode(swap.lockupPkScript);
|
|
2962
3062
|
if (funded !== watched) {
|
|
2963
3063
|
throw new Error(
|
|
@@ -3004,8 +3104,8 @@ function rfqSwapOriginOf(record) {
|
|
|
3004
3104
|
};
|
|
3005
3105
|
}
|
|
3006
3106
|
function lockupScript(params, lockupAddress) {
|
|
3007
|
-
const script =
|
|
3008
|
-
const funded =
|
|
3107
|
+
const script = import_sdk9.VHTLCV2ContractHandler.createScript(params);
|
|
3108
|
+
const funded = import_sdk9.ArkAddress.decode(lockupAddress).pkScript;
|
|
3009
3109
|
if (import_base9.hex.encode(funded) !== import_base9.hex.encode(script.pkScript)) {
|
|
3010
3110
|
throw new Error(
|
|
3011
3111
|
`rfq swap covenant params derive ${import_base9.hex.encode(script.pkScript)}, but the record's lockup address holds ${import_base9.hex.encode(funded)} \u2014 these params are not this swap's`
|
|
@@ -3041,7 +3141,7 @@ function shouldRetainRfqSwap(record, now) {
|
|
|
3041
3141
|
}
|
|
3042
3142
|
|
|
3043
3143
|
// src/refundBlocked.ts
|
|
3044
|
-
var
|
|
3144
|
+
var import_sdk10 = require("@arkade-os/sdk");
|
|
3045
3145
|
var RefundNotLocallyPossibleError = class extends Error {
|
|
3046
3146
|
constructor(reason, message, options) {
|
|
3047
3147
|
super(message, options);
|
|
@@ -3058,16 +3158,16 @@ async function senderIdentityForSwapRecord(wallet, record) {
|
|
|
3058
3158
|
);
|
|
3059
3159
|
}
|
|
3060
3160
|
try {
|
|
3061
|
-
return await (0,
|
|
3161
|
+
return await (0, import_sdk10.contractSigner)(wallet, record.signingDescriptor);
|
|
3062
3162
|
} catch (cause) {
|
|
3063
|
-
if (cause instanceof
|
|
3163
|
+
if (cause instanceof import_sdk10.WalletCannotSignError) {
|
|
3064
3164
|
throw new RefundNotLocallyPossibleError(
|
|
3065
3165
|
"unsignable-wallet",
|
|
3066
3166
|
`this wallet holds ${record.signingDescriptor} but cannot sign with it; attach its signer`,
|
|
3067
3167
|
{ cause }
|
|
3068
3168
|
);
|
|
3069
3169
|
}
|
|
3070
|
-
if (cause instanceof
|
|
3170
|
+
if (cause instanceof import_sdk10.ForeignDescriptorError) {
|
|
3071
3171
|
throw new RefundNotLocallyPossibleError(
|
|
3072
3172
|
"foreign-descriptor",
|
|
3073
3173
|
`this wallet cannot derive ${record.signingDescriptor}; the swap was created on another wallet`,
|
|
@@ -3094,12 +3194,29 @@ function nextOnchainAction(input) {
|
|
|
3094
3194
|
return input.htlcLocktime - input.now >= ONCHAIN_CLAIM_MARGIN_SECONDS ? "claim" : "claim_window_closed";
|
|
3095
3195
|
}
|
|
3096
3196
|
}
|
|
3197
|
+
function nextOnchainReceiveAction(input) {
|
|
3198
|
+
switch (input.phase.phase) {
|
|
3199
|
+
case "unfunded":
|
|
3200
|
+
case "awaiting_confirmations":
|
|
3201
|
+
case "claimable":
|
|
3202
|
+
return "wait";
|
|
3203
|
+
case "claimed":
|
|
3204
|
+
return "taken";
|
|
3205
|
+
case "swept":
|
|
3206
|
+
return "refunded";
|
|
3207
|
+
case "refundable":
|
|
3208
|
+
return input.settled ? "taken" : "refund";
|
|
3209
|
+
}
|
|
3210
|
+
}
|
|
3097
3211
|
var RFQ_CONFIGURATION_REFUSAL = {
|
|
3098
3212
|
noClaimLockupCallback: "no claimLockup callback is wired, so this wallet cannot claim the lockup",
|
|
3099
3213
|
noCallbacksForClaim: "no callbacks are wired, so this wallet cannot claim the lockup",
|
|
3100
3214
|
noClaimOnchainCallback: "no claimOnchain callback is wired, so this wallet cannot claim the L1 fill",
|
|
3101
3215
|
autoActionsDisabled: "automatic actions are disabled, so this wallet will not push the refund",
|
|
3102
|
-
noCallbacksForRefund: "no callbacks are wired, so this wallet cannot push the refund"
|
|
3216
|
+
noCallbacksForRefund: "no callbacks are wired, so this wallet cannot push the refund",
|
|
3217
|
+
noRefundOnchainCallback: "no refundOnchain callback is wired, so this wallet cannot take the L1 funding back",
|
|
3218
|
+
noCallbacksForL1Refund: "no callbacks are wired, so this wallet cannot take the L1 funding back",
|
|
3219
|
+
autoActionsDisabledForL1Refund: "automatic actions are disabled, so this wallet will not push the L1 refund"
|
|
3103
3220
|
};
|
|
3104
3221
|
var RFQ_CONFIGURATION_REFUSALS = Object.values(RFQ_CONFIGURATION_REFUSAL);
|
|
3105
3222
|
var RfqSwapOriginRequired = class extends Error {
|
|
@@ -3113,6 +3230,16 @@ var RfqSwapOriginRequired = class extends Error {
|
|
|
3113
3230
|
this.rfqId = rfqId;
|
|
3114
3231
|
}
|
|
3115
3232
|
};
|
|
3233
|
+
var OnchainReceiveNeedsChainSource = class extends Error {
|
|
3234
|
+
rfqId;
|
|
3235
|
+
constructor(rfqId) {
|
|
3236
|
+
super(
|
|
3237
|
+
`rfq swap ${rfqId} is an onchain_receive swap and this manager has no ChainSource; its L1 refund could be neither seen nor made, so it is refused rather than monitored blind`
|
|
3238
|
+
);
|
|
3239
|
+
this.name = "OnchainReceiveNeedsChainSource";
|
|
3240
|
+
this.rfqId = rfqId;
|
|
3241
|
+
}
|
|
3242
|
+
};
|
|
3116
3243
|
var notify = (listeners, call) => {
|
|
3117
3244
|
for (const listener of listeners) {
|
|
3118
3245
|
try {
|
|
@@ -3177,6 +3304,7 @@ var RfqSwapManager = class _RfqSwapManager {
|
|
|
3177
3304
|
timer = null;
|
|
3178
3305
|
running = false;
|
|
3179
3306
|
constructor(deps, config = {}) {
|
|
3307
|
+
(0, import_sdk11.assertTimerMs)("pollIntervalMs", config.pollIntervalMs);
|
|
3180
3308
|
this.deps = deps;
|
|
3181
3309
|
this.config = {
|
|
3182
3310
|
enableAutoActions: config.enableAutoActions ?? true,
|
|
@@ -3232,6 +3360,9 @@ var RfqSwapManager = class _RfqSwapManager {
|
|
|
3232
3360
|
let swap;
|
|
3233
3361
|
try {
|
|
3234
3362
|
swap = rebuildRfqSwap(record, await params(record));
|
|
3363
|
+
if (swap.kind === "onchain_receive" && !this.deps.chain) {
|
|
3364
|
+
throw new OnchainReceiveNeedsChainSource(swap.rfqId);
|
|
3365
|
+
}
|
|
3235
3366
|
} catch (error) {
|
|
3236
3367
|
failed.push({
|
|
3237
3368
|
rfqId: record.rfqId,
|
|
@@ -3366,6 +3497,9 @@ var RfqSwapManager = class _RfqSwapManager {
|
|
|
3366
3497
|
* origin, one remembered from an earlier `addSwap`, or the stored record (one read).
|
|
3367
3498
|
*/
|
|
3368
3499
|
async admit(swap, origin) {
|
|
3500
|
+
if (swap.kind === "onchain_receive" && !this.deps.chain) {
|
|
3501
|
+
throw new OnchainReceiveNeedsChainSource(swap.rfqId);
|
|
3502
|
+
}
|
|
3369
3503
|
if (origin) {
|
|
3370
3504
|
assertSameSwap(origin, swap);
|
|
3371
3505
|
this.origins.set(swap.rfqId, origin);
|
|
@@ -3514,7 +3648,7 @@ var RfqSwapManager = class _RfqSwapManager {
|
|
|
3514
3648
|
});
|
|
3515
3649
|
return;
|
|
3516
3650
|
}
|
|
3517
|
-
if (!(0,
|
|
3651
|
+
if (!(0, import_sdk11.isContractVtxoEvent)(event)) return;
|
|
3518
3652
|
const swap = this.byLockupScript.get(event.contractScript);
|
|
3519
3653
|
if (!swap) return;
|
|
3520
3654
|
void this.pollSwap(swap).catch(() => {
|
|
@@ -3632,6 +3766,7 @@ var RfqSwapManager = class _RfqSwapManager {
|
|
|
3632
3766
|
} catch {
|
|
3633
3767
|
fate = { fate: "unknown" };
|
|
3634
3768
|
}
|
|
3769
|
+
if (swap.kind === "onchain_receive") return this.driveOnchainReceive(swap, fate);
|
|
3635
3770
|
if (fate.fate === "claimed" || fate.fate === "returned") {
|
|
3636
3771
|
this.stampLockupSpends(swap, fate.spends);
|
|
3637
3772
|
if (fate.fate === "claimed") this.stampSettlementPreimage(swap, fate.preimage);
|
|
@@ -3741,8 +3876,8 @@ var RfqSwapManager = class _RfqSwapManager {
|
|
|
3741
3876
|
this.setState(swap, "claimed");
|
|
3742
3877
|
this.emitAction(swap, "claimLockup");
|
|
3743
3878
|
} catch (error) {
|
|
3744
|
-
const ark = (0,
|
|
3745
|
-
if ((0,
|
|
3879
|
+
const ark = (0, import_sdk11.isArkError)(error) ? error : (0, import_sdk11.maybeArkError)(error);
|
|
3880
|
+
if ((0, import_sdk11.isArkError)(ark, import_sdk11.ArkErrorName.VTXO_ALREADY_SPENT)) {
|
|
3746
3881
|
if (swap.claimFailure !== void 0) {
|
|
3747
3882
|
delete swap.claimFailure;
|
|
3748
3883
|
this.touch(swap);
|
|
@@ -3754,6 +3889,94 @@ var RfqSwapManager = class _RfqSwapManager {
|
|
|
3754
3889
|
this.emitFailed(swap, error);
|
|
3755
3890
|
}
|
|
3756
3891
|
}
|
|
3892
|
+
/** `settled` ends the swap; `returned` does NOT, signalling their L1
|
|
3893
|
+
* funding is stranded. */
|
|
3894
|
+
async driveOnchainReceive(swap, fate) {
|
|
3895
|
+
const settled = fate.fate === "claimed";
|
|
3896
|
+
if (settled || fate.fate === "returned") this.stampLockupSpends(swap, fate.spends);
|
|
3897
|
+
if (settled) {
|
|
3898
|
+
this.setState(swap, "settled");
|
|
3899
|
+
return;
|
|
3900
|
+
}
|
|
3901
|
+
const l1 = await this.driveOnchainRefund(swap, swap.claimTxid !== void 0);
|
|
3902
|
+
if (fate.fate === "returned") {
|
|
3903
|
+
if (l1.verdict === "resolved") this.setState(swap, "refunded");
|
|
3904
|
+
else if (l1.blocked) this.block(swap, l1.blocked);
|
|
3905
|
+
return;
|
|
3906
|
+
}
|
|
3907
|
+
if (fate.fate === "exited") return this.blockExitedLockup(swap, fate);
|
|
3908
|
+
if (l1.verdict === "live" && this.config.now() >= swap.refundLocktime + REFUND_MTP_LAG_SECONDS) {
|
|
3909
|
+
return this.block(
|
|
3910
|
+
swap,
|
|
3911
|
+
l1.blocked ?? "the Arkade claim window closed unclaimed and the L1 HTLC is still funded \u2014 holding the swap open until its refund leaf opens"
|
|
3912
|
+
);
|
|
3913
|
+
}
|
|
3914
|
+
if (swap.refundTxid || l1.attempted) {
|
|
3915
|
+
return this.block(
|
|
3916
|
+
swap,
|
|
3917
|
+
"the L1 funding was refunded, so claiming the lockup too would take both sides of the trade \u2014 the solver's reclaim ends this swap"
|
|
3918
|
+
);
|
|
3919
|
+
}
|
|
3920
|
+
await this.driveReceiveClaim(swap);
|
|
3921
|
+
if (l1.blocked && !isRfqSwapTerminal(swap.state)) this.block(swap, l1.blocked);
|
|
3922
|
+
}
|
|
3923
|
+
/** `resolved`: the HTLC can hold nothing more. `blocked` is a refusal the
|
|
3924
|
+
* caller applies once the Arkade arm has run. No give-up branch. */
|
|
3925
|
+
async driveOnchainRefund(swap, claimSubmitted) {
|
|
3926
|
+
if (!this.deps.chain) return { verdict: "live" };
|
|
3927
|
+
let phase;
|
|
3928
|
+
try {
|
|
3929
|
+
phase = await classifyOnchainHtlc(this.deps.chain, {
|
|
3930
|
+
htlc: swap.htlc,
|
|
3931
|
+
minConfirmations: swap.minConfirmations,
|
|
3932
|
+
funding: swap.funding
|
|
3933
|
+
});
|
|
3934
|
+
} catch {
|
|
3935
|
+
return { verdict: "live" };
|
|
3936
|
+
}
|
|
3937
|
+
if ("utxo" in phase && !swap.funding) {
|
|
3938
|
+
swap.funding = { txid: phase.utxo.txid, vout: phase.utxo.vout };
|
|
3939
|
+
this.touch(swap);
|
|
3940
|
+
}
|
|
3941
|
+
if (phase.phase === "unfunded" && !swap.funding) return { verdict: "resolved" };
|
|
3942
|
+
switch (nextOnchainReceiveAction({ phase, settled: claimSubmitted })) {
|
|
3943
|
+
case "taken":
|
|
3944
|
+
return { verdict: "resolved" };
|
|
3945
|
+
case "refunded":
|
|
3946
|
+
if (phase.phase === "swept" && !swap.refundTxid) {
|
|
3947
|
+
swap.refundTxid = phase.txid;
|
|
3948
|
+
this.touch(swap);
|
|
3949
|
+
}
|
|
3950
|
+
return { verdict: "resolved" };
|
|
3951
|
+
case "wait":
|
|
3952
|
+
return { verdict: "live" };
|
|
3953
|
+
case "refund":
|
|
3954
|
+
break;
|
|
3955
|
+
}
|
|
3956
|
+
if (phase.phase !== "refundable") return { verdict: "live" };
|
|
3957
|
+
if (swap.refundTxid) return { verdict: "live" };
|
|
3958
|
+
if (!this.callbacks?.refundOnchain) {
|
|
3959
|
+
return {
|
|
3960
|
+
verdict: "live",
|
|
3961
|
+
blocked: this.callbacks ? RFQ_CONFIGURATION_REFUSAL.noRefundOnchainCallback : RFQ_CONFIGURATION_REFUSAL.noCallbacksForL1Refund
|
|
3962
|
+
};
|
|
3963
|
+
}
|
|
3964
|
+
if (!this.config.enableAutoActions) {
|
|
3965
|
+
return {
|
|
3966
|
+
verdict: "live",
|
|
3967
|
+
blocked: RFQ_CONFIGURATION_REFUSAL.autoActionsDisabledForL1Refund
|
|
3968
|
+
};
|
|
3969
|
+
}
|
|
3970
|
+
try {
|
|
3971
|
+
const { txid } = await this.callbacks.refundOnchain(swap, phase.utxo);
|
|
3972
|
+
swap.refundTxid = txid;
|
|
3973
|
+
this.touch(swap);
|
|
3974
|
+
this.emitAction(swap, "refundOnchain");
|
|
3975
|
+
} catch (error) {
|
|
3976
|
+
this.emitFailed(swap, error);
|
|
3977
|
+
}
|
|
3978
|
+
return { verdict: "live", attempted: true };
|
|
3979
|
+
}
|
|
3757
3980
|
/** `handled` ends the pass; `continue` falls through to the refund gate. */
|
|
3758
3981
|
async driveOnchain(swap) {
|
|
3759
3982
|
if (!this.deps.chain) {
|
|
@@ -4032,10 +4255,10 @@ var RfqSwapManager = class _RfqSwapManager {
|
|
|
4032
4255
|
this.waiters.delete(swap.rfqId);
|
|
4033
4256
|
}
|
|
4034
4257
|
};
|
|
4035
|
-
var traderClaimTxid = (swap) => swap.kind === "
|
|
4258
|
+
var traderClaimTxid = (swap) => swap.kind === "lightning_send" ? void 0 : swap.claimTxid;
|
|
4036
4259
|
var isPayoutDecided = (swap) => swap.state === "settled" || swap.state === "refunded" || swap.kind === "onchain_send" && swap.claimTxid !== void 0;
|
|
4037
4260
|
var outcomeOf = (swap) => {
|
|
4038
|
-
const lostReceive = swap.kind === "lightning_receive" && swap.state === "refunded";
|
|
4261
|
+
const lostReceive = (swap.kind === "lightning_receive" || swap.kind === "onchain_receive") && swap.state === "refunded";
|
|
4039
4262
|
return {
|
|
4040
4263
|
state: swap.state,
|
|
4041
4264
|
txid: lostReceive ? swap.refundTxid : traderClaimTxid(swap) ?? swap.refundTxid
|
|
@@ -4043,18 +4266,18 @@ var outcomeOf = (swap) => {
|
|
|
4043
4266
|
};
|
|
4044
4267
|
var outcomeOfRecord = (stored) => {
|
|
4045
4268
|
const record = normalizeRfqSwapRecord(stored);
|
|
4046
|
-
const profileClaim = record.kind === "
|
|
4269
|
+
const profileClaim = record.kind === "lightning_send" ? void 0 : record.profile.claimTxid;
|
|
4047
4270
|
const claimTxid = typeof profileClaim === "string" ? profileClaim : void 0;
|
|
4048
4271
|
return {
|
|
4049
4272
|
state: record.state,
|
|
4050
|
-
txid: record.kind === "lightning_receive" && record.state === "refunded" ? record.refundTxid : claimTxid ?? record.refundTxid
|
|
4273
|
+
txid: (record.kind === "lightning_receive" || record.kind === "onchain_receive") && record.state === "refunded" ? record.refundTxid : claimTxid ?? record.refundTxid
|
|
4051
4274
|
};
|
|
4052
4275
|
};
|
|
4053
4276
|
var errorMessage = (error) => error instanceof Error ? error.message : String(error);
|
|
4054
4277
|
var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
|
|
4055
4278
|
|
|
4056
4279
|
// src/client/corridors/lightning.ts
|
|
4057
|
-
var
|
|
4280
|
+
var import_sdk12 = require("@arkade-os/sdk");
|
|
4058
4281
|
var INVOICE_HRPS = [
|
|
4059
4282
|
["lnbcrt", ["regtest"]],
|
|
4060
4283
|
["lntbs", ["signet", "mutinynet"]],
|
|
@@ -4084,7 +4307,7 @@ var lightningCorridor = Object.assign(
|
|
|
4084
4307
|
deps,
|
|
4085
4308
|
drive: LIGHTNING_DRIVE,
|
|
4086
4309
|
matches(raw) {
|
|
4087
|
-
const invoice = (0,
|
|
4310
|
+
const invoice = (0, import_sdk12.invoiceTarget)(raw);
|
|
4088
4311
|
if (invoice === void 0) return void 0;
|
|
4089
4312
|
const networks = networksOfInvoiceHrp(invoice);
|
|
4090
4313
|
if (networks === void 0) {
|
|
@@ -4130,11 +4353,11 @@ var lightningCorridor = Object.assign(
|
|
|
4130
4353
|
};
|
|
4131
4354
|
}
|
|
4132
4355
|
}),
|
|
4133
|
-
{ target:
|
|
4356
|
+
{ target: import_sdk12.invoiceTarget }
|
|
4134
4357
|
);
|
|
4135
4358
|
|
|
4136
4359
|
// src/client/corridors/onchain.ts
|
|
4137
|
-
var
|
|
4360
|
+
var import_sdk13 = require("@arkade-os/sdk");
|
|
4138
4361
|
var btc2 = __toESM(require("@scure/btc-signer"), 1);
|
|
4139
4362
|
var ONCHAIN_DRIVE = {
|
|
4140
4363
|
take: {
|
|
@@ -4144,6 +4367,14 @@ var ONCHAIN_DRIVE = {
|
|
|
4144
4367
|
],
|
|
4145
4368
|
actions: ["claimOnchain", "refundArkade"],
|
|
4146
4369
|
seams: ["indexer", "chain"]
|
|
4370
|
+
},
|
|
4371
|
+
give: {
|
|
4372
|
+
lockups: [
|
|
4373
|
+
{ covenant: "arkade_lockup", owner: "solver", deadline: "refund_locktime" },
|
|
4374
|
+
{ covenant: "onchain_htlc", owner: "trader", deadline: "htlc_refund_locktime" }
|
|
4375
|
+
],
|
|
4376
|
+
actions: ["claimLockup", "refundOnchain"],
|
|
4377
|
+
seams: ["indexer", "chain"]
|
|
4147
4378
|
}
|
|
4148
4379
|
};
|
|
4149
4380
|
var onchainCorridor = Object.assign(
|
|
@@ -4154,14 +4385,14 @@ var onchainCorridor = Object.assign(
|
|
|
4154
4385
|
deps,
|
|
4155
4386
|
drive: ONCHAIN_DRIVE,
|
|
4156
4387
|
matches(raw) {
|
|
4157
|
-
const target = (0,
|
|
4388
|
+
const target = (0, import_sdk13.btcTarget)(raw);
|
|
4158
4389
|
if (target === void 0) return void 0;
|
|
4159
4390
|
try {
|
|
4160
4391
|
btc2.Address(L1_NETWORKS[l1]).decode(target);
|
|
4161
4392
|
} catch {
|
|
4162
4393
|
return { refused: `this is not a ${l1} address` };
|
|
4163
4394
|
}
|
|
4164
|
-
const amount =
|
|
4395
|
+
const amount = import_sdk13.BIP21.amountSats(raw);
|
|
4165
4396
|
return {
|
|
4166
4397
|
claimed: {
|
|
4167
4398
|
kind: "address",
|
|
@@ -4172,19 +4403,21 @@ var onchainCorridor = Object.assign(
|
|
|
4172
4403
|
}
|
|
4173
4404
|
};
|
|
4174
4405
|
},
|
|
4175
|
-
{ target:
|
|
4406
|
+
{ target: import_sdk13.btcTarget }
|
|
4176
4407
|
);
|
|
4177
4408
|
|
|
4178
4409
|
// src/client/outcome.ts
|
|
4179
4410
|
var CORRIDOR_PASS = {
|
|
4180
4411
|
lightning_send: LIGHTNING_DRIVE.take,
|
|
4181
4412
|
lightning_receive: LIGHTNING_DRIVE.give,
|
|
4182
|
-
onchain_send: ONCHAIN_DRIVE.take
|
|
4413
|
+
onchain_send: ONCHAIN_DRIVE.take,
|
|
4414
|
+
onchain_receive: ONCHAIN_DRIVE.give
|
|
4183
4415
|
};
|
|
4184
4416
|
var LOCKUP_OWNER = {
|
|
4185
4417
|
lightning_send: CORRIDOR_PASS.lightning_send.lockups[0].owner,
|
|
4186
4418
|
lightning_receive: CORRIDOR_PASS.lightning_receive.lockups[0].owner,
|
|
4187
|
-
onchain_send: CORRIDOR_PASS.onchain_send.lockups[0].owner
|
|
4419
|
+
onchain_send: CORRIDOR_PASS.onchain_send.lockups[0].owner,
|
|
4420
|
+
onchain_receive: CORRIDOR_PASS.onchain_receive.lockups[0].owner
|
|
4188
4421
|
};
|
|
4189
4422
|
var at = (outcome) => () => outcome;
|
|
4190
4423
|
var CORRIDOR_OUTCOME = {
|
|
@@ -4205,8 +4438,9 @@ var CORRIDOR_OUTCOME = {
|
|
|
4205
4438
|
needs_counterparty: at("needs_recovery"),
|
|
4206
4439
|
// Matched by the hash, not our txid, so a claim that lands without us counts.
|
|
4207
4440
|
settled: at("claimed"),
|
|
4208
|
-
// The inversion: a receive lockup's non-claim leaves are all the solver's.
|
|
4209
|
-
refunded
|
|
4441
|
+
// The inversion: a receive lockup's non-claim leaves are all the solver's. On
|
|
4442
|
+
// `onchain_receive` the swap is `refunded` only once the trader's own L1 half is.
|
|
4443
|
+
refunded: (kind) => kind === "onchain_receive" ? "refunded" : "lapsed",
|
|
4210
4444
|
failed: at("failed")
|
|
4211
4445
|
}
|
|
4212
4446
|
};
|
|
@@ -4234,7 +4468,8 @@ var ACTIVITY_TOKEN = {
|
|
|
4234
4468
|
var LABELS = {
|
|
4235
4469
|
lightning_send: "Lightning send",
|
|
4236
4470
|
lightning_receive: "Lightning receive",
|
|
4237
|
-
onchain_send: "Onchain send"
|
|
4471
|
+
onchain_send: "Onchain send",
|
|
4472
|
+
onchain_receive: "Onchain receive"
|
|
4238
4473
|
};
|
|
4239
4474
|
var outcomeToken = (kind, state) => ACTIVITY_TOKEN[corridorOutcome(kind, state)];
|
|
4240
4475
|
function swapActivityResolver(deps) {
|
|
@@ -4298,7 +4533,7 @@ async function activityInputOf(stored, indexer) {
|
|
|
4298
4533
|
async function lockupTxids(indexer, record, wantFunding) {
|
|
4299
4534
|
let script;
|
|
4300
4535
|
try {
|
|
4301
|
-
script = import_base11.hex.encode(
|
|
4536
|
+
script = import_base11.hex.encode(import_sdk14.ArkAddress.decode(record.lockupAddress).pkScript);
|
|
4302
4537
|
} catch {
|
|
4303
4538
|
return [];
|
|
4304
4539
|
}
|
|
@@ -4387,7 +4622,7 @@ var chainSourceFrom = (provider, network) => {
|
|
|
4387
4622
|
};
|
|
4388
4623
|
|
|
4389
4624
|
// src/claim.ts
|
|
4390
|
-
var
|
|
4625
|
+
var import_sdk15 = require("@arkade-os/sdk");
|
|
4391
4626
|
var LockupAmountMismatchError = class extends Error {
|
|
4392
4627
|
name = "LockupAmountMismatchError";
|
|
4393
4628
|
reason = "amount_mismatch";
|
|
@@ -4419,8 +4654,8 @@ async function pushClaim(operator, input) {
|
|
|
4419
4654
|
assertPreimageMatches(input.preimage, input.contract.options.preimageHash);
|
|
4420
4655
|
const serverUnrollScript = await operatorUnrollScript(operator, input.network);
|
|
4421
4656
|
const leaf = input.contract.claim();
|
|
4422
|
-
const txid = await (0,
|
|
4423
|
-
identity: (0,
|
|
4657
|
+
const txid = await (0, import_sdk15.signAndSubmitOffchainTx)({
|
|
4658
|
+
identity: (0, import_sdk15.claimWithPreimageIdentity)(input.receiver, input.preimage),
|
|
4424
4659
|
provider: operator,
|
|
4425
4660
|
inputs: lockupInputs(input.vtxos, input.contract, leaf),
|
|
4426
4661
|
// One aggregate output: this leaf inspects nothing about the output set.
|
|
@@ -4449,7 +4684,7 @@ async function claimReceiveLockup(contracts, operator, input) {
|
|
|
4449
4684
|
|
|
4450
4685
|
// src/markets.ts
|
|
4451
4686
|
var import_solver_discovery2 = require("@arkade-os/solver-discovery");
|
|
4452
|
-
var
|
|
4687
|
+
var import_sdk16 = require("@arkade-os/sdk");
|
|
4453
4688
|
|
|
4454
4689
|
// src/marketShape.ts
|
|
4455
4690
|
var MARKET_CORRIDORS = ["arkade", "bolt11", "bitcoin", "eip155"];
|
|
@@ -4483,6 +4718,7 @@ var marketCorridor = (market, side) => {
|
|
|
4483
4718
|
// src/markets.ts
|
|
4484
4719
|
var QUOTE_OPTIONS = { safetyBps: 0 };
|
|
4485
4720
|
var makeCachedFeedFetch = (ttlMs = 3e4, fetchImpl = fetch) => {
|
|
4721
|
+
(0, import_sdk16.assertNonNegativeMs)("ttlMs", ttlMs);
|
|
4486
4722
|
const cache = /* @__PURE__ */ new Map();
|
|
4487
4723
|
const inflight = /* @__PURE__ */ new Map();
|
|
4488
4724
|
return async (input, init) => {
|
|
@@ -4625,17 +4861,17 @@ var validatePlan = (plan, giveBalance, dust) => {
|
|
|
4625
4861
|
const receiveIsBtc = plan.receive.asset.id === BTC_ASSET_ID;
|
|
4626
4862
|
if (depositIsBtc || receiveIsBtc) {
|
|
4627
4863
|
const btcSide = depositIsBtc ? plan.deposit.atomic : plan.receive.atomic;
|
|
4628
|
-
if ((0,
|
|
4864
|
+
if ((0, import_sdk16.isSubdust)(btcSide, dust)) return "below-dust";
|
|
4629
4865
|
}
|
|
4630
4866
|
return void 0;
|
|
4631
4867
|
};
|
|
4632
4868
|
|
|
4633
4869
|
// src/payment/crossAsset.ts
|
|
4634
|
-
var
|
|
4870
|
+
var import_sdk17 = require("@arkade-os/sdk");
|
|
4635
4871
|
var CROSS_ASSET_RAIL = "cross-asset";
|
|
4636
4872
|
var parseAssetId = (assetId) => {
|
|
4637
4873
|
try {
|
|
4638
|
-
return
|
|
4874
|
+
return import_sdk17.asset.AssetId.fromString(assetId);
|
|
4639
4875
|
} catch {
|
|
4640
4876
|
return void 0;
|
|
4641
4877
|
}
|
|
@@ -4653,9 +4889,9 @@ function crossAssetRail(deps) {
|
|
|
4653
4889
|
};
|
|
4654
4890
|
return {
|
|
4655
4891
|
id: CROSS_ASSET_RAIL,
|
|
4656
|
-
match: (req) => (0,
|
|
4892
|
+
match: (req) => (0, import_sdk17.arkTarget)(req.raw) !== void 0,
|
|
4657
4893
|
available: async (req) => {
|
|
4658
|
-
const assets = (0,
|
|
4894
|
+
const assets = (0, import_sdk17.assetsOf)(req);
|
|
4659
4895
|
if (assets.length !== 1) return false;
|
|
4660
4896
|
const [asset3] = assets;
|
|
4661
4897
|
if (asset3.assetId === BTC_ASSET_ID) return false;
|
|
@@ -4665,8 +4901,8 @@ function crossAssetRail(deps) {
|
|
|
4665
4901
|
return planned !== void 0 && planned.error === void 0;
|
|
4666
4902
|
},
|
|
4667
4903
|
quote: async (req, ctx) => {
|
|
4668
|
-
const payTo = (0,
|
|
4669
|
-
const asset3 = (0,
|
|
4904
|
+
const payTo = (0, import_sdk17.arkTarget)(req.raw);
|
|
4905
|
+
const asset3 = (0, import_sdk17.resolveAssetAmount)(CROSS_ASSET_RAIL, req);
|
|
4670
4906
|
const wantAsset = parseAssetId(asset3.assetId);
|
|
4671
4907
|
if (!wantAsset) {
|
|
4672
4908
|
throw new Error(
|
|
@@ -4689,7 +4925,7 @@ function crossAssetRail(deps) {
|
|
|
4689
4925
|
);
|
|
4690
4926
|
}
|
|
4691
4927
|
const depositSats = Number(plan.deposit.atomic);
|
|
4692
|
-
const carrier = deps.carrierSats ??
|
|
4928
|
+
const carrier = deps.carrierSats ?? import_sdk17.ASSET_CARRIER_SATS;
|
|
4693
4929
|
return {
|
|
4694
4930
|
railId: CROSS_ASSET_RAIL,
|
|
4695
4931
|
// OPEN QUESTION for review: `total = amount + fee` forces the
|
|
@@ -4707,7 +4943,7 @@ function crossAssetRail(deps) {
|
|
|
4707
4943
|
priceDisplay: plan.priceDisplay,
|
|
4708
4944
|
give: plan.give
|
|
4709
4945
|
},
|
|
4710
|
-
send: async () => (0,
|
|
4946
|
+
send: async () => (0, import_sdk17.makeHandle)(CROSS_ASSET_RAIL, async (emit) => {
|
|
4711
4947
|
const offer = await createOffer(ctx.wallet, {
|
|
4712
4948
|
wantAmount: asset3.amount,
|
|
4713
4949
|
wantAsset,
|
|
@@ -4791,10 +5027,10 @@ var solverRendezvous = (markets, payoutCorridor, amountSats, fallbackEmulatorPub
|
|
|
4791
5027
|
};
|
|
4792
5028
|
|
|
4793
5029
|
// src/payment/solverLightning.ts
|
|
4794
|
-
var
|
|
5030
|
+
var import_sdk19 = require("@arkade-os/sdk");
|
|
4795
5031
|
|
|
4796
5032
|
// src/payment/solverOnchain.ts
|
|
4797
|
-
var
|
|
5033
|
+
var import_sdk18 = require("@arkade-os/sdk");
|
|
4798
5034
|
var SOLVER_ONCHAIN_RAIL = "solver-onchain";
|
|
4799
5035
|
var solverOnchainRendezvous = (markets, amountSats, fallbackEmulatorPubkey) => solverRendezvous(markets, "onchain", amountSats, fallbackEmulatorPubkey);
|
|
4800
5036
|
async function fundSolverSend(railId, ctx, emit, deps, swap, settledFields) {
|
|
@@ -4821,24 +5057,24 @@ function solverOnchainRail(deps) {
|
|
|
4821
5057
|
const rendezvousFor = async (amount) => solverOnchainRendezvous(await deps.discover(), amount, deps.fallbackEmulatorPubkey);
|
|
4822
5058
|
return {
|
|
4823
5059
|
id: SOLVER_ONCHAIN_RAIL,
|
|
4824
|
-
match: (req) => (0,
|
|
5060
|
+
match: (req) => (0, import_sdk18.btcTarget)(req.raw) !== void 0,
|
|
4825
5061
|
available: async (req) => {
|
|
4826
|
-
if ((0,
|
|
4827
|
-
const address = (0,
|
|
5062
|
+
if ((0, import_sdk18.assetsOf)(req).length > 0) return false;
|
|
5063
|
+
const address = (0, import_sdk18.btcTarget)(req.raw);
|
|
4828
5064
|
if (!address) return false;
|
|
4829
5065
|
try {
|
|
4830
5066
|
l1ScriptForAddress(address, deps.l1Network);
|
|
4831
5067
|
} catch {
|
|
4832
5068
|
return false;
|
|
4833
5069
|
}
|
|
4834
|
-
const amount = (0,
|
|
5070
|
+
const amount = (0, import_sdk18.tryResolveSendAmount)(req.raw, req.amount);
|
|
4835
5071
|
if (amount === void 0) return false;
|
|
4836
5072
|
return await rendezvousFor(amount) !== void 0;
|
|
4837
5073
|
},
|
|
4838
5074
|
quote: async (req, ctx) => {
|
|
4839
|
-
const address = (0,
|
|
4840
|
-
(0,
|
|
4841
|
-
const amount = (0,
|
|
5075
|
+
const address = (0, import_sdk18.btcTarget)(req.raw);
|
|
5076
|
+
(0, import_sdk18.assertNoAssets)(SOLVER_ONCHAIN_RAIL, req);
|
|
5077
|
+
const amount = (0, import_sdk18.resolveSendAmount)(SOLVER_ONCHAIN_RAIL, req.raw, req.amount);
|
|
4842
5078
|
const payoutPkScript = l1ScriptForAddress(address, deps.l1Network);
|
|
4843
5079
|
const rendezvous = await rendezvousFor(amount);
|
|
4844
5080
|
if (!rendezvous) {
|
|
@@ -4877,7 +5113,7 @@ function solverOnchainRail(deps) {
|
|
|
4877
5113
|
// not knowable now, so `amount` is the payout, not the net.
|
|
4878
5114
|
claimFeeDeductedFromPayout: true
|
|
4879
5115
|
},
|
|
4880
|
-
send: async () => (0,
|
|
5116
|
+
send: async () => (0, import_sdk18.makeHandle)(SOLVER_ONCHAIN_RAIL, async (emit) => {
|
|
4881
5117
|
assertFundable({
|
|
4882
5118
|
quote: swap.quote,
|
|
4883
5119
|
now: Math.floor(Date.now() / 1e3),
|
|
@@ -4904,7 +5140,7 @@ function solverOnchainRail(deps) {
|
|
|
4904
5140
|
// src/payment/solverLightning.ts
|
|
4905
5141
|
var SOLVER_LIGHTNING_RAIL = "solver-lightning";
|
|
4906
5142
|
var factsOf = (raw, decode, now) => {
|
|
4907
|
-
const invoice = (0,
|
|
5143
|
+
const invoice = (0, import_sdk19.invoiceTarget)(raw);
|
|
4908
5144
|
if (!invoice) return void 0;
|
|
4909
5145
|
let facts;
|
|
4910
5146
|
try {
|
|
@@ -4916,22 +5152,22 @@ var factsOf = (raw, decode, now) => {
|
|
|
4916
5152
|
if (facts.expiresAt <= now) return void 0;
|
|
4917
5153
|
return facts;
|
|
4918
5154
|
};
|
|
4919
|
-
var contradicts = (req, facts) => req.amount !== void 0 && req.amount !== facts.amountSats && req.amount !==
|
|
5155
|
+
var contradicts = (req, facts) => req.amount !== void 0 && req.amount !== facts.amountSats && req.amount !== import_sdk19.BIP21.amountSats(req.raw);
|
|
4920
5156
|
var solverLightningRendezvous = (markets, amountSats, fallbackEmulatorPubkey) => solverRendezvous(markets, "lightning", amountSats, fallbackEmulatorPubkey);
|
|
4921
5157
|
function solverLightningRail(deps) {
|
|
4922
5158
|
const rendezvousFor = async (amountSats) => solverLightningRendezvous(await deps.discover(), amountSats, deps.fallbackEmulatorPubkey);
|
|
4923
5159
|
return {
|
|
4924
5160
|
id: SOLVER_LIGHTNING_RAIL,
|
|
4925
|
-
match: (req) => (0,
|
|
5161
|
+
match: (req) => (0, import_sdk19.invoiceTarget)(req.raw) !== void 0,
|
|
4926
5162
|
available: async (req) => {
|
|
4927
|
-
if ((0,
|
|
5163
|
+
if ((0, import_sdk19.assetsOf)(req).length > 0) return false;
|
|
4928
5164
|
const facts = factsOf(req.raw, deps.decodeInvoice, Math.floor(Date.now() / 1e3));
|
|
4929
5165
|
if (!facts) return false;
|
|
4930
5166
|
if (contradicts(req, facts)) return false;
|
|
4931
5167
|
return await rendezvousFor(facts.amountSats) !== void 0;
|
|
4932
5168
|
},
|
|
4933
5169
|
quote: async (req, ctx) => {
|
|
4934
|
-
(0,
|
|
5170
|
+
(0, import_sdk19.assertNoAssets)(SOLVER_LIGHTNING_RAIL, req);
|
|
4935
5171
|
const facts = factsOf(req.raw, deps.decodeInvoice, Math.floor(Date.now() / 1e3));
|
|
4936
5172
|
if (!facts) {
|
|
4937
5173
|
throw new Error(
|
|
@@ -4974,7 +5210,7 @@ function solverLightningRail(deps) {
|
|
|
4974
5210
|
invoiceExpiresAt: facts.expiresAt,
|
|
4975
5211
|
solverPubkey: rendezvous.solverPubkey
|
|
4976
5212
|
},
|
|
4977
|
-
send: async () => (0,
|
|
5213
|
+
send: async () => (0, import_sdk19.makeHandle)(SOLVER_LIGHTNING_RAIL, async (emit) => {
|
|
4978
5214
|
assertFundable({
|
|
4979
5215
|
quote: swap.quote,
|
|
4980
5216
|
invoiceExpiresAt: facts.expiresAt,
|
|
@@ -4996,7 +5232,7 @@ function solverLightningRail(deps) {
|
|
|
4996
5232
|
|
|
4997
5233
|
// src/restore.ts
|
|
4998
5234
|
var import_base14 = require("@scure/base");
|
|
4999
|
-
var
|
|
5235
|
+
var import_sdk20 = require("@arkade-os/sdk");
|
|
5000
5236
|
var TXS_PER_REQUEST = 50;
|
|
5001
5237
|
async function fetchParsedTxs(indexer, txids) {
|
|
5002
5238
|
const parsedByTxid = /* @__PURE__ */ new Map();
|
|
@@ -5012,7 +5248,7 @@ async function fetchParsedTxs(indexer, txids) {
|
|
|
5012
5248
|
if (result.status !== "fulfilled") continue;
|
|
5013
5249
|
for (const psbt of result.value) {
|
|
5014
5250
|
try {
|
|
5015
|
-
const parsed =
|
|
5251
|
+
const parsed = import_sdk20.Transaction.fromPSBT(import_base14.base64.decode(psbt));
|
|
5016
5252
|
parsedByTxid.set(parsed.id, parsed);
|
|
5017
5253
|
} catch {
|
|
5018
5254
|
}
|
|
@@ -5041,7 +5277,7 @@ function classifySpend(offer, operatorPubkey, spendTx, deposit) {
|
|
|
5041
5277
|
if (!input.txid || input.index !== deposit.vout) continue;
|
|
5042
5278
|
if (import_base14.hex.encode(input.txid) !== deposit.txid) continue;
|
|
5043
5279
|
for (const leaf of input.tapLeafScript ?? []) {
|
|
5044
|
-
const spent = import_base14.hex.encode((0,
|
|
5280
|
+
const spent = import_base14.hex.encode((0, import_sdk20.scriptFromTapLeafScript)(leaf));
|
|
5045
5281
|
if (leaves.returned.some((back) => spent === import_base14.hex.encode(back))) return "cancelled";
|
|
5046
5282
|
if (leaves.fulfill && spent === import_base14.hex.encode(leaves.fulfill)) return "fulfilled";
|
|
5047
5283
|
}
|
|
@@ -5095,7 +5331,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
|
|
|
5095
5331
|
if (!fundingTx) continue;
|
|
5096
5332
|
fetchedTxids.push(txid);
|
|
5097
5333
|
try {
|
|
5098
|
-
const packet =
|
|
5334
|
+
const packet = import_sdk20.Extension.fromTx(parsed).getPacketByType(OFFER_PACKET_TYPE);
|
|
5099
5335
|
if (!packet) continue;
|
|
5100
5336
|
const payload = packet.serialize();
|
|
5101
5337
|
found.push({
|
|
@@ -5207,7 +5443,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
|
|
|
5207
5443
|
|
|
5208
5444
|
// src/watch.ts
|
|
5209
5445
|
var import_base15 = require("@scure/base");
|
|
5210
|
-
var
|
|
5446
|
+
var import_sdk21 = require("@arkade-os/sdk");
|
|
5211
5447
|
var TERMINAL = ["fulfilled", "cancelled", "recoverable"];
|
|
5212
5448
|
var assetSwapSource = (repository) => ({
|
|
5213
5449
|
list: () => getAssetSwaps(repository),
|
|
@@ -5239,7 +5475,7 @@ async function watchOfferSwaps({
|
|
|
5239
5475
|
wallet.getAddress(),
|
|
5240
5476
|
wallet.getArkadeReader()
|
|
5241
5477
|
]);
|
|
5242
|
-
const operatorPubkey =
|
|
5478
|
+
const operatorPubkey = import_sdk21.ArkAddress.decode(address).serverPubKey;
|
|
5243
5479
|
let queue = Promise.resolve();
|
|
5244
5480
|
const enqueue = (task) => {
|
|
5245
5481
|
queue = queue.then(task).catch(() => {
|
|
@@ -5254,7 +5490,7 @@ async function watchOfferSwaps({
|
|
|
5254
5490
|
return classifyDepositSpend(
|
|
5255
5491
|
decodeOffer(import_base15.hex.decode(swap.offerHex)),
|
|
5256
5492
|
operatorPubkey,
|
|
5257
|
-
txs.map((psbt) =>
|
|
5493
|
+
txs.map((psbt) => import_sdk21.Transaction.fromPSBT(import_base15.base64.decode(psbt))),
|
|
5258
5494
|
{ txid: vtxo.txid, vout: vtxo.vout }
|
|
5259
5495
|
);
|
|
5260
5496
|
} catch {
|
|
@@ -5282,7 +5518,7 @@ async function watchOfferSwaps({
|
|
|
5282
5518
|
}
|
|
5283
5519
|
};
|
|
5284
5520
|
const unsubscribe = manager.onContractEvent((event) => {
|
|
5285
|
-
if (!(0,
|
|
5521
|
+
if (!(0, import_sdk21.isContractVtxoEvent)(event) || event.type !== "vtxo_spent") return;
|
|
5286
5522
|
enqueue(() => handleSpend(event));
|
|
5287
5523
|
});
|
|
5288
5524
|
return {
|
|
@@ -5315,6 +5551,7 @@ async function watchOfferSwaps({
|
|
|
5315
5551
|
ONCHAIN_SECONDS_PER_BLOCK,
|
|
5316
5552
|
ONCHAIN_SEND_PAIR,
|
|
5317
5553
|
OfferCovenantMismatchError,
|
|
5554
|
+
OnchainReceiveNeedsChainSource,
|
|
5318
5555
|
PreimageNotRecoverableError,
|
|
5319
5556
|
QUOTE_OPTIONS,
|
|
5320
5557
|
RFQ_SWAP_RETENTION_SECONDS,
|
|
@@ -5369,11 +5606,13 @@ async function watchOfferSwaps({
|
|
|
5369
5606
|
makeCachedFeedFetch,
|
|
5370
5607
|
newPreimage,
|
|
5371
5608
|
nextOnchainAction,
|
|
5609
|
+
nextOnchainReceiveAction,
|
|
5372
5610
|
normalizeMakerPkScript,
|
|
5373
5611
|
normalizeMakerPublicKey,
|
|
5374
5612
|
normalizeRfqSwapRecord,
|
|
5375
5613
|
offerContract,
|
|
5376
5614
|
onchainHtlcScript,
|
|
5615
|
+
onchainReceiveProfile,
|
|
5377
5616
|
onchainReceiveRequest,
|
|
5378
5617
|
onchainSendProfile,
|
|
5379
5618
|
onchainSendRequest,
|