@arkade-os/swap 0.0.21 → 0.0.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 +30 -24
- package/dist/{chunk-6ZUS47GA.js → chunk-PJF4DWD7.js} +31 -0
- package/dist/index.cjs +267 -46
- package/dist/index.d.cts +16 -4
- package/dist/index.d.ts +16 -4
- package/dist/index.js +244 -49
- package/dist/repositories/realm/index.cjs +43 -0
- package/dist/repositories/realm/index.d.cts +3 -1
- package/dist/repositories/realm/index.d.ts +3 -1
- package/dist/repositories/realm/index.js +33 -1
- package/dist/repositories/sqlite/index.cjs +39 -0
- package/dist/repositories/sqlite/index.d.cts +3 -1
- package/dist/repositories/sqlite/index.d.ts +3 -1
- package/dist/repositories/sqlite/index.js +29 -1
- package/dist/{repository-PNlTFdsj.d.ts → repository-BT33JsPT.d.ts} +47 -28
- package/dist/{repository-CZYc8Y38.d.cts → repository-CSBh-0NH.d.cts} +47 -28
- package/package.json +2 -2
package/dist/index.d.ts
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
import { ProvisionedKey, ProvisionedClaimSecret, ArkTxInput, asset, RelativeTimelock, IWallet, EmulatorProvider, arkade, RestIndexerProvider, Transaction, IContractManager, OnchainProvider, PaymentRail, Asset, VHTLC, Identity, ActivityResolver } from '@arkade-os/sdk';
|
|
2
|
-
import { S as SwapSecretsProjection, R as RfqSwapRecord, A as AssetSwapRepository, a as AssetSwap, M as MarketsCacheEntry,
|
|
3
|
-
export {
|
|
2
|
+
import { S as SwapSecretsProjection, R as RfqSwapRecord, A as AssetSwapRepository, a as AssetSwap, b as RfqSwapState, c as RfqHistoryCursor, M as MarketsCacheEntry, d as RefundArkProvider, L as LockupContractSource, e as LockupVtxo, f as RfqSwap, g as ArkadeRefundResult, h as LockupSpendIndexer } from './repository-BT33JsPT.js';
|
|
3
|
+
export { i as AssetSwapStatus, j as AvailableRfqSwapManagerCallbacks, B as BTC_ASSET_ID, I as InMemoryAssetSwapRepository, k as LightningReceiveSwap, l as LightningSendSwap, m as LockupFate, n as LockupNeedsRecoveryError, o as LockupParams, p as LockupSpend, O as OnchainSendAction, q as OnchainSendSwap, P as PersistableRfqSwap, r as PreimageBlockedReason, s as PreimageNotRecoverableError, t as REFUND_MTP_LAG_SECONDS, u as RFQ_RESOLVED_STATES, v as RFQ_SWAP_ACTIVE_STATES, w as RFQ_SWAP_MAX_PAGE_SIZE, x as RFQ_SWAP_RETENTION_SECONDS, y as RFQ_SWAP_TERMINAL_STATES, z as RefundOutcome, C as RfqRestoreFailure, D as RfqRestoreOptions, E as RfqRestoreResult, F as RfqSwapActionName, G as RfqSwapLockup, H as RfqSwapManager, J as RfqSwapManagerCallbacks, K as RfqSwapManagerConfig, N as RfqSwapManagerDeps, Q as RfqSwapManagerEvents, T as RfqSwapOrigin, U as RfqSwapOriginRequired, V as RfqSwapOutcome, W as RfqSwapRecordStore, X as SwapContractRegistry, Y as addAssetSwap, Z as awaitRfqResolution, _ as createRfqSwapRecord, $ as findLockupVtxos, a0 as getAssetSwaps, a1 as getAssetSwapsOrThrow, a2 as isRfqSwapTerminal, a3 as isRfqTerminal, a4 as nextOnchainAction, a5 as preimageForSwapRecord, a6 as pushRefundWithoutReceiver, a7 as readLockupFate, a8 as rebuildRfqSwap, a9 as refundIfUnresolved, aa as rfqSwapOriginOf, ab as shouldRetainRfqSwap, ac as swapSecretsToRecord, ad as updateAssetSwap, ae as updateAssetSwapBestEffort, af as updateRfqSwapRecord } from './repository-BT33JsPT.js';
|
|
4
4
|
import { Network, LocalCardInput, DiscoveredMarket, Side, OfferPlan } from '@arkade-os/solver-discovery';
|
|
5
5
|
import { O as OnchainNetwork, a as OnchainHtlc, b as OnchainHtlcParams, C as ChainSource, R as RfqTransport, r as requestOnchainSend, I as InvoiceFacts, c as requestLightningSend } from './rfq-B95nPfaa.js';
|
|
6
6
|
export { A as ARKADE_ASSET, d as ARKADE_BTC, e as AddressMismatch, f as ChainUtxo, H as HtlcUtxo, L as LIGHTNING_BTC, g as LIGHTNING_RECEIVE_PAIR, h as LIGHTNING_SEND_PAIR, i as LOCKTIME_THRESHOLD, j as LightningReceiveTreeParams, k as LightningSendTreeParams, M as MAX_MIN_CONFIRMATIONS, l as MIN_CLAIM_WINDOW_SECONDS, m as MIN_HEADROOM_SECONDS, n as ONCHAIN_BTC, o as ONCHAIN_CLAIM_MARGIN_SECONDS, p as ONCHAIN_DUST_SATS, q as ONCHAIN_ORDER_MARGIN_SECONDS, s as ONCHAIN_RECEIVE_PAIR, t as ONCHAIN_SECONDS_PER_BLOCK, u as ONCHAIN_SEND_PAIR, v as OnchainHtlcPhase, w as RFQ_REFUSAL_ERROR_CODES, x as RFQ_TERMINAL_STATES, y as RelaySocket, z as RfqQuote, B as RfqRefusalDetail, D as RfqRefusalErrorCode, E as RfqRefusalReason, F as RfqRefusalUnit, G as RfqStatus, S as SOLO_REFUND_HEADROOM_SECONDS, J as SwapRefusal, K as arkadeAssetLeg, N as arkadeSwapRequest, P as assertArkadeFundable, Q as assertFundable, T as assertReceivable, U as awaitOnchainFill, V as buildHtlcClaim, W as buildHtlcRefund, X as canonicalAssetAmount, Y as claimOnchainFill, Z as classifyOnchainHtlc, _ as deriveLightningReceive, $ as deriveOnchainReceive, a0 as deriveOnchainSend, a1 as extractPreimage, a2 as httpTransport, a3 as isRfqRefusalErrorCode, a4 as l1ScriptForAddress, a5 as lightningReceiveRequest, a6 as lightningSendRequest, a7 as lightningSendVtxoScript, a8 as newPreimage, a9 as newRfqId, aa as normalizeMakerPkScript, ab as normalizeMakerPublicKey, ac as offerTermsFromQuote, ad as onchainHtlcScript, ae as onchainReceiveRequest, af as onchainSendRequest, ag as paymentHashOf, ah as receiveVtxoScript, ai as relayTransport, aj as requestArkadeSwap, ak as requestLightningReceive, al as requestOnchainReceive, am as rfqPair, an as unilateralClaimDelay, ao as unilateralRefundDelay, ap as unilateralRefundWithoutReceiverDelay, aq as verifyLockupAddress, ar as verifyOfferAddress, as as verifyReceiveInvoice } from './rfq-B95nPfaa.js';
|
|
@@ -577,6 +577,8 @@ declare class IndexedDbAssetSwapRepository implements AssetSwapRepository {
|
|
|
577
577
|
saveRfqSwap(record: RfqSwapRecord): Promise<void>;
|
|
578
578
|
getRfqSwap(rfqId: string): Promise<RfqSwapRecord | undefined>;
|
|
579
579
|
getAllRfqSwaps(): Promise<RfqSwapRecord[]>;
|
|
580
|
+
getRfqSwapsPage(state: RfqSwapState, afterId: string | undefined, limit: number): Promise<RfqSwapRecord[]>;
|
|
581
|
+
getRfqSwapsUpdatedPage(state: RfqSwapState, since: number, after: RfqHistoryCursor | undefined, limit: number): Promise<RfqSwapRecord[]>;
|
|
580
582
|
removeRfqSwap(rfqId: string): Promise<void>;
|
|
581
583
|
getScannedTxids(): Promise<Set<string>>;
|
|
582
584
|
markTxidsScanned(txids: Iterable<string>): Promise<void>;
|
|
@@ -1479,7 +1481,7 @@ declare function swapActivityResolver(deps: {
|
|
|
1479
1481
|
listSwaps(): Promise<readonly SwapActivityInput[]>;
|
|
1480
1482
|
}): ActivityResolver;
|
|
1481
1483
|
interface RfqSwapActivityDeps {
|
|
1482
|
-
repository: Pick<AssetSwapRepository, "getAllRfqSwaps">;
|
|
1484
|
+
repository: Pick<AssetSwapRepository, "getAllRfqSwaps" | "getRfqSwapsPage" | "getRfqSwapsUpdatedPage">;
|
|
1483
1485
|
/**
|
|
1484
1486
|
* Consulted only for what a record cannot answer: a record written before
|
|
1485
1487
|
* `fundingArkTxid` existed, and the counterparty's spend on a swap that
|
|
@@ -1505,5 +1507,15 @@ interface RfqSwapActivityDeps {
|
|
|
1505
1507
|
* what they already are.
|
|
1506
1508
|
*/
|
|
1507
1509
|
declare function rfqSwapActivityInputs(deps: RfqSwapActivityDeps): Promise<SwapActivityInput[]>;
|
|
1510
|
+
interface RfqSwapActivityPage {
|
|
1511
|
+
inputs: SwapActivityInput[];
|
|
1512
|
+
nextCursor?: string;
|
|
1513
|
+
}
|
|
1514
|
+
declare function rfqSwapActivityInputsPage(deps: RfqSwapActivityDeps, state: RfqSwapState, afterId: string | undefined, limit: number): Promise<RfqSwapActivityPage>;
|
|
1515
|
+
interface RfqSwapDatedActivityPage {
|
|
1516
|
+
inputs: SwapActivityInput[];
|
|
1517
|
+
nextCursor?: RfqHistoryCursor;
|
|
1518
|
+
}
|
|
1519
|
+
declare function rfqSwapActivityInputsSincePage(deps: RfqSwapActivityDeps, state: RfqSwapState, since: number, after: RfqHistoryCursor | undefined, limit: number): Promise<RfqSwapDatedActivityPage>;
|
|
1508
1520
|
|
|
1509
|
-
export { ASSET_CARRIER_SATS, ArkadeRefundResult, type ArkadeRefunderDeps, AssetSwap, AssetSwapRepository, type AssetSwapRestoreChange, CLAIM_PACKET_TYPE, CROSS_ASSET_RAIL, ChainSource, type ClaimArkProvider, type ClaimPacketInput, type ClaimPacketShape, type CovclaimdClient, type CovclaimdInfo, CovclaimdRevealError, type CrossAssetPhase, type CrossAssetRailDeps, type CrossAssetSwap, type DiscoverMarketsOptions, type FillFunding, IndexedDbAssetSwapRepository, InvoiceFacts, type LightningReceiveProfile, type LightningSendProfile, LockupAmountMismatchError, LockupContractMissing, type LockupContractReader, LockupContractSource, type LockupContractWriter, LockupRegistrationFailed, LockupSpendIndexer, LockupVtxo, MARKET_CORRIDORS, type MarketCorridor, type MarketLike, MarketsCacheEntry, OFFER_PACKET_TYPE, type Offer, type OfferContractRetirer, type OfferSwapWatcher, OnchainHtlc, OnchainHtlcParams, OnchainNetwork, type OnchainSendProfile, type PlanError, QUOTE_OPTIONS, RefundArkProvider, type RefundBlockedReason, RefundNotLocallyPossibleError, type RegisterAssetSwapRestoreOptions, type RestoreAssetSwapRepositoryOptions, type RestoreAssetSwapRepositoryResult, type RestoreIndexer, type RevealParams, type RfqClaimSecretProjection, type RfqHashlockProjection, type RfqSignerProjection, RfqSwap, type RfqSwapActivityDeps, RfqSwapRecord, RfqSwapState, RfqTransport, SEALED_CIPHERTEXT_LENGTH, SOLVER_LIGHTNING_RAIL, SOLVER_ONCHAIN_RAIL, SWAP_LOCKUP_CONTRACT_KIND, SWAP_LOCKUP_CONTRACT_LABEL, SWAP_LOCKUP_CONTRACT_TYPE, type SealedClaimPacket, type SolverLightningRailDeps, type SolverLightningSend, type SolverOnchainRailDeps, type SolverOnchainSend, type SolverRendezvous, type SpendKind, type SwapActivityInput, SwapSecretsProjection, type Tx, type WatchOfferSwapsParams, appendArkadeScript, arkadeRefunder, awaitLockupFunding, cancelOffer, chainSourceFrom, claimPacketShape, claimReceiveLockup, classifyDepositSpend, classifySpend, covclaimdClient, createOffer, crossAssetRail, decodeOffer, discoverMarkets, encodeOffer, fillOffer, findMarket, isRfqMarket, lockupContractParams, makeCachedFeedFetch, marketAssetId, marketCorridor, marketPairLabel, offerVtxoScript, onchainSendProfile, pushClaim, registerAssetSwapRestore, registerLockupContract, requestLightningSend, requestOnchainSend, restoreAssetSwapRepository, restoreAssetSwaps, restoreOfferCoverage, retireSettledOfferContracts, revealClaimPacket, revealFieldsFromScript, rfqClaimSecretOf, rfqSecretsProfile, rfqSignerOf, rfqSwapActivityInputs, sealClaimPacket, senderIdentityForSwapRecord, solverLightningRail, solverLightningRendezvous, solverOnchainRail, solverOnchainRendezvous, solverRendezvous, spendTxidsOf, spendUpdate, swapActivityResolver, swapPrograms, validatePlan, watchOfferSwaps };
|
|
1521
|
+
export { ASSET_CARRIER_SATS, ArkadeRefundResult, type ArkadeRefunderDeps, AssetSwap, AssetSwapRepository, type AssetSwapRestoreChange, CLAIM_PACKET_TYPE, CROSS_ASSET_RAIL, ChainSource, type ClaimArkProvider, type ClaimPacketInput, type ClaimPacketShape, type CovclaimdClient, type CovclaimdInfo, CovclaimdRevealError, type CrossAssetPhase, type CrossAssetRailDeps, type CrossAssetSwap, type DiscoverMarketsOptions, type FillFunding, IndexedDbAssetSwapRepository, InvoiceFacts, type LightningReceiveProfile, type LightningSendProfile, LockupAmountMismatchError, LockupContractMissing, type LockupContractReader, LockupContractSource, type LockupContractWriter, LockupRegistrationFailed, LockupSpendIndexer, LockupVtxo, MARKET_CORRIDORS, type MarketCorridor, type MarketLike, MarketsCacheEntry, OFFER_PACKET_TYPE, type Offer, type OfferContractRetirer, type OfferSwapWatcher, OnchainHtlc, OnchainHtlcParams, OnchainNetwork, type OnchainSendProfile, type PlanError, QUOTE_OPTIONS, RefundArkProvider, type RefundBlockedReason, RefundNotLocallyPossibleError, type RegisterAssetSwapRestoreOptions, type RestoreAssetSwapRepositoryOptions, type RestoreAssetSwapRepositoryResult, type RestoreIndexer, type RevealParams, type RfqClaimSecretProjection, type RfqHashlockProjection, RfqHistoryCursor, type RfqSignerProjection, RfqSwap, type RfqSwapActivityDeps, type RfqSwapActivityPage, type RfqSwapDatedActivityPage, RfqSwapRecord, RfqSwapState, RfqTransport, SEALED_CIPHERTEXT_LENGTH, SOLVER_LIGHTNING_RAIL, SOLVER_ONCHAIN_RAIL, SWAP_LOCKUP_CONTRACT_KIND, SWAP_LOCKUP_CONTRACT_LABEL, SWAP_LOCKUP_CONTRACT_TYPE, type SealedClaimPacket, type SolverLightningRailDeps, type SolverLightningSend, type SolverOnchainRailDeps, type SolverOnchainSend, type SolverRendezvous, type SpendKind, type SwapActivityInput, SwapSecretsProjection, type Tx, type WatchOfferSwapsParams, appendArkadeScript, arkadeRefunder, awaitLockupFunding, cancelOffer, chainSourceFrom, claimPacketShape, claimReceiveLockup, classifyDepositSpend, classifySpend, covclaimdClient, createOffer, crossAssetRail, decodeOffer, discoverMarkets, encodeOffer, fillOffer, findMarket, isRfqMarket, lockupContractParams, makeCachedFeedFetch, marketAssetId, marketCorridor, marketPairLabel, offerVtxoScript, onchainSendProfile, pushClaim, registerAssetSwapRestore, registerLockupContract, requestLightningSend, requestOnchainSend, restoreAssetSwapRepository, restoreAssetSwaps, restoreOfferCoverage, retireSettledOfferContracts, revealClaimPacket, revealFieldsFromScript, rfqClaimSecretOf, rfqSecretsProfile, rfqSignerOf, rfqSwapActivityInputs, rfqSwapActivityInputsPage, rfqSwapActivityInputsSincePage, sealClaimPacket, senderIdentityForSwapRecord, solverLightningRail, solverLightningRendezvous, solverOnchainRail, solverOnchainRendezvous, solverRendezvous, spendTxidsOf, spendUpdate, swapActivityResolver, swapPrograms, validatePlan, watchOfferSwaps };
|
package/dist/index.js
CHANGED
|
@@ -103,8 +103,11 @@ import {
|
|
|
103
103
|
} from "./chunk-QJKMTPRQ.js";
|
|
104
104
|
import {
|
|
105
105
|
InMemoryAssetSwapRepository,
|
|
106
|
+
RFQ_SWAP_MAX_PAGE_SIZE,
|
|
107
|
+
assertRfqSwapPageLimit,
|
|
108
|
+
assertRfqSwapSince,
|
|
106
109
|
marketsCacheKey
|
|
107
|
-
} from "./chunk-
|
|
110
|
+
} from "./chunk-PJF4DWD7.js";
|
|
108
111
|
|
|
109
112
|
// src/markets.ts
|
|
110
113
|
import {
|
|
@@ -311,11 +314,13 @@ import {
|
|
|
311
314
|
promisifyRequest
|
|
312
315
|
} from "@arkade-os/sdk";
|
|
313
316
|
var DEFAULT_DB_NAME = "arkade-intents";
|
|
314
|
-
var DB_VERSION =
|
|
317
|
+
var DB_VERSION = 3;
|
|
315
318
|
var STORE_SWAPS = "swaps";
|
|
316
319
|
var STORE_RFQ_SWAPS = "rfqSwaps";
|
|
317
320
|
var STORE_SCANNED = "scannedTxids";
|
|
318
321
|
var STORE_MARKETS = "markets";
|
|
322
|
+
var HISTORY_INDEX = "byStateUpdatedAtAndRfqId";
|
|
323
|
+
var PAGE_INDEX = "byStateAndRfqId";
|
|
319
324
|
var STORES = [
|
|
320
325
|
[STORE_SWAPS, { keyPath: "id" }],
|
|
321
326
|
// v2. Separate from `swaps` rather than sharing it: the two record types
|
|
@@ -326,10 +331,16 @@ var STORES = [
|
|
|
326
331
|
];
|
|
327
332
|
function initDatabase(db, oldVersion, transaction) {
|
|
328
333
|
void oldVersion;
|
|
329
|
-
void transaction;
|
|
330
334
|
for (const [name, options] of STORES) {
|
|
331
335
|
if (!db.objectStoreNames.contains(name)) db.createObjectStore(name, options);
|
|
332
336
|
}
|
|
337
|
+
const rfq = transaction?.objectStore(STORE_RFQ_SWAPS);
|
|
338
|
+
if (rfq && !rfq.indexNames.contains(HISTORY_INDEX)) {
|
|
339
|
+
rfq.createIndex(HISTORY_INDEX, ["state", "updatedAt", "rfqId"]);
|
|
340
|
+
}
|
|
341
|
+
if (rfq && !rfq.indexNames.contains(PAGE_INDEX)) {
|
|
342
|
+
rfq.createIndex(PAGE_INDEX, ["state", "rfqId"]);
|
|
343
|
+
}
|
|
333
344
|
}
|
|
334
345
|
var IndexedDbAssetSwapRepository = class {
|
|
335
346
|
version = 4;
|
|
@@ -371,6 +382,28 @@ var IndexedDbAssetSwapRepository = class {
|
|
|
371
382
|
async getAllRfqSwaps() {
|
|
372
383
|
return promisifyRequest((await this.readStore(STORE_RFQ_SWAPS)).getAll());
|
|
373
384
|
}
|
|
385
|
+
async getRfqSwapsPage(state, afterId, limit) {
|
|
386
|
+
assertRfqSwapPageLimit(limit);
|
|
387
|
+
const range = IDBKeyRange.bound(
|
|
388
|
+
[state, afterId ?? ""],
|
|
389
|
+
[state, "\uFFFF"],
|
|
390
|
+
afterId !== void 0
|
|
391
|
+
);
|
|
392
|
+
const index = (await this.readStore(STORE_RFQ_SWAPS)).index(PAGE_INDEX);
|
|
393
|
+
return promisifyRequest(index.getAll(range, limit));
|
|
394
|
+
}
|
|
395
|
+
async getRfqSwapsUpdatedPage(state, since, after, limit) {
|
|
396
|
+
assertRfqSwapPageLimit(limit);
|
|
397
|
+
assertRfqSwapSince(since);
|
|
398
|
+
const useCursor = after !== void 0 && after.updatedAt >= since;
|
|
399
|
+
const range = IDBKeyRange.bound(
|
|
400
|
+
useCursor ? [state, after.updatedAt, after.rfqId] : [state, since, ""],
|
|
401
|
+
[state, Number.MAX_SAFE_INTEGER, "\uFFFF"],
|
|
402
|
+
useCursor
|
|
403
|
+
);
|
|
404
|
+
const index = (await this.readStore(STORE_RFQ_SWAPS)).index(HISTORY_INDEX);
|
|
405
|
+
return promisifyRequest(index.getAll(range, limit));
|
|
406
|
+
}
|
|
374
407
|
async removeRfqSwap(rfqId) {
|
|
375
408
|
await this.write(STORE_RFQ_SWAPS, (store) => {
|
|
376
409
|
store.delete(rfqId);
|
|
@@ -966,6 +999,12 @@ import { hex as hex3 } from "@scure/base";
|
|
|
966
999
|
|
|
967
1000
|
// src/rfqSwapState.ts
|
|
968
1001
|
var RFQ_SWAP_TERMINAL_STATES = ["settled", "refunded", "failed"];
|
|
1002
|
+
var RFQ_SWAP_ACTIVE_STATES = [
|
|
1003
|
+
"pending",
|
|
1004
|
+
"claimable",
|
|
1005
|
+
"claimed",
|
|
1006
|
+
"needs_counterparty"
|
|
1007
|
+
];
|
|
969
1008
|
var isRfqSwapTerminal = (state) => RFQ_SWAP_TERMINAL_STATES.includes(state);
|
|
970
1009
|
|
|
971
1010
|
// src/rfqRecord.ts
|
|
@@ -1744,7 +1783,7 @@ import {
|
|
|
1744
1783
|
assertSubmittedArkTxid,
|
|
1745
1784
|
buildOffchainTx,
|
|
1746
1785
|
getArkPsbtFields,
|
|
1747
|
-
|
|
1786
|
+
isVtxoSpent,
|
|
1748
1787
|
matchServerCheckpoints
|
|
1749
1788
|
} from "@arkade-os/sdk";
|
|
1750
1789
|
var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
|
|
@@ -1800,7 +1839,7 @@ async function findLockupVtxos(contracts, swapPkScript) {
|
|
|
1800
1839
|
const out = [];
|
|
1801
1840
|
for (const vtxo of row?.vtxos ?? []) {
|
|
1802
1841
|
if (vtxo.isUnrolled) continue;
|
|
1803
|
-
if (
|
|
1842
|
+
if (isVtxoSpent(vtxo)) continue;
|
|
1804
1843
|
const key = `${vtxo.txid}:${vtxo.vout}`;
|
|
1805
1844
|
if (seen.has(key)) continue;
|
|
1806
1845
|
seen.add(key);
|
|
@@ -1824,7 +1863,7 @@ async function readLockupFate(indexer, input) {
|
|
|
1824
1863
|
const { vtxos } = await indexer.getVtxos({ scripts: [hex8.encode(input.swapPkScript)] });
|
|
1825
1864
|
const all = vtxos ?? [];
|
|
1826
1865
|
if (all.length === 0) return { fate: "unknown" };
|
|
1827
|
-
const exited = all.filter((vtxo) => vtxo.isUnrolled && !
|
|
1866
|
+
const exited = all.filter((vtxo) => vtxo.isUnrolled && !isVtxoSpent(vtxo));
|
|
1828
1867
|
if (exited.length > 0) {
|
|
1829
1868
|
return {
|
|
1830
1869
|
fate: "exited",
|
|
@@ -1834,7 +1873,7 @@ async function readLockupFate(indexer, input) {
|
|
|
1834
1873
|
const spentBy = /* @__PURE__ */ new Map();
|
|
1835
1874
|
let everySpendNamed = true;
|
|
1836
1875
|
for (const vtxo of all) {
|
|
1837
|
-
if (!
|
|
1876
|
+
if (!isVtxoSpent(vtxo)) return { fate: "open" };
|
|
1838
1877
|
if (vtxo.spentBy)
|
|
1839
1878
|
spentBy.set(vtxo.spentBy, {
|
|
1840
1879
|
checkpointTxid: vtxo.spentBy,
|
|
@@ -2138,7 +2177,10 @@ function arkadeRefunder(deps) {
|
|
|
2138
2177
|
// src/swapManager.ts
|
|
2139
2178
|
import { hex as hex10 } from "@scure/base";
|
|
2140
2179
|
import {
|
|
2141
|
-
|
|
2180
|
+
ArkErrorName,
|
|
2181
|
+
isArkError,
|
|
2182
|
+
isContractVtxoEvent as isContractVtxoEvent2,
|
|
2183
|
+
maybeArkError
|
|
2142
2184
|
} from "@arkade-os/sdk";
|
|
2143
2185
|
function nextOnchainAction(input) {
|
|
2144
2186
|
switch (input.phase.phase) {
|
|
@@ -2174,7 +2216,8 @@ var notify = (listeners, call) => {
|
|
|
2174
2216
|
}
|
|
2175
2217
|
}
|
|
2176
2218
|
};
|
|
2177
|
-
var RfqSwapManager = class {
|
|
2219
|
+
var RfqSwapManager = class _RfqSwapManager {
|
|
2220
|
+
static POLL_CONCURRENCY = 16;
|
|
2178
2221
|
deps;
|
|
2179
2222
|
config;
|
|
2180
2223
|
callbacks = null;
|
|
@@ -2239,9 +2282,12 @@ var RfqSwapManager = class {
|
|
|
2239
2282
|
claimedOutpoints = /* @__PURE__ */ new Map();
|
|
2240
2283
|
/** Live `onContractEvent` subscription, held so `stop()` can drop it. */
|
|
2241
2284
|
unsubscribeContracts = null;
|
|
2242
|
-
/**
|
|
2243
|
-
* answers instead of throwing "not found". Cleared by {@link removeSwap}. */
|
|
2285
|
+
/** Recent terminal swaps; older durable outcomes are read from the record store on demand. */
|
|
2244
2286
|
finished = /* @__PURE__ */ new Map();
|
|
2287
|
+
/** Explicit removals stay suppressed for this manager lifetime; normal completions never enter this set.
|
|
2288
|
+
* Each maps to its removal sequence, so restore can tell a removal made during its rebuild. */
|
|
2289
|
+
removed = /* @__PURE__ */ new Map();
|
|
2290
|
+
removalSeq = 0;
|
|
2245
2291
|
waiters = /* @__PURE__ */ new Map();
|
|
2246
2292
|
/**
|
|
2247
2293
|
* The request-time origin of each swap the manager may have to CREATE a
|
|
@@ -2260,6 +2306,8 @@ var RfqSwapManager = class {
|
|
|
2260
2306
|
dirty = /* @__PURE__ */ new Set();
|
|
2261
2307
|
/** Race guard: one action at a time per swap. */
|
|
2262
2308
|
inProgress = /* @__PURE__ */ new Set();
|
|
2309
|
+
activePolls = 0;
|
|
2310
|
+
pollWaiters = /* @__PURE__ */ new Set();
|
|
2263
2311
|
timer = null;
|
|
2264
2312
|
running = false;
|
|
2265
2313
|
constructor(deps, config = {}) {
|
|
@@ -2304,8 +2352,7 @@ var RfqSwapManager = class {
|
|
|
2304
2352
|
* Rebuild every stored swap and take over monitoring them.
|
|
2305
2353
|
*
|
|
2306
2354
|
* The composition a consumer otherwise writes by hand, and the one place
|
|
2307
|
-
*
|
|
2308
|
-
* (`shouldRetainRfqSwap`), the lockup's contract row supplies the covenant
|
|
2355
|
+
* three pieces meet: the lockup's contract row supplies the covenant
|
|
2309
2356
|
* (`lockupContractParams`), `rebuildRfqSwap` turns a record back into a
|
|
2310
2357
|
* live swap, and each rebuilt swap arrives with its own origin, so nothing
|
|
2311
2358
|
* is asked of the caller.
|
|
@@ -2315,9 +2362,10 @@ var RfqSwapManager = class {
|
|
|
2315
2362
|
* forced to start driving money to do it. Call this first and `start()`
|
|
2316
2363
|
* after; a manager already running polls the restored swaps at once.
|
|
2317
2364
|
*
|
|
2318
|
-
*
|
|
2319
|
-
*
|
|
2320
|
-
*
|
|
2365
|
+
* The default loads only active states through bounded pages when the
|
|
2366
|
+
* repository supports them. Terminal history stays durable and a late
|
|
2367
|
+
* completion lookup reads one record by key. `includeTerminal` opts into
|
|
2368
|
+
* the previous all-record result when a caller needs it.
|
|
2321
2369
|
*
|
|
2322
2370
|
* **A record that cannot be rebuilt is reported, never swallowed and never
|
|
2323
2371
|
* fatal.** `rebuildRfqSwap` throws by design when the covenant params do
|
|
@@ -2329,13 +2377,12 @@ var RfqSwapManager = class {
|
|
|
2329
2377
|
async restoreFromRepository(options = {}) {
|
|
2330
2378
|
const repository = this.requireRepository("restoreFromRepository");
|
|
2331
2379
|
const params = options.params ?? this.paramsFromContracts();
|
|
2332
|
-
const records = await repository.getAllRfqSwaps();
|
|
2333
|
-
const pruned = await this.dropRetired(repository, records);
|
|
2334
|
-
const retired = new Set(pruned);
|
|
2335
2380
|
const restored = [];
|
|
2336
2381
|
const failed = [];
|
|
2337
|
-
|
|
2338
|
-
if (
|
|
2382
|
+
const restore = async (record) => {
|
|
2383
|
+
if (!options.includeTerminal && isRfqSwapTerminal(record.state)) return;
|
|
2384
|
+
if (this.monitored.has(record.rfqId)) return;
|
|
2385
|
+
const removedAt = this.removed.get(record.rfqId);
|
|
2339
2386
|
let swap;
|
|
2340
2387
|
try {
|
|
2341
2388
|
swap = rebuildRfqSwap(record, await params(record));
|
|
@@ -2344,19 +2391,50 @@ var RfqSwapManager = class {
|
|
|
2344
2391
|
rfqId: record.rfqId,
|
|
2345
2392
|
error: error instanceof Error ? error : new Error(errorMessage(error))
|
|
2346
2393
|
});
|
|
2347
|
-
|
|
2394
|
+
return;
|
|
2395
|
+
}
|
|
2396
|
+
if (this.monitored.has(record.rfqId)) return;
|
|
2397
|
+
if (this.removed.get(record.rfqId) !== removedAt) return;
|
|
2398
|
+
this.removed.delete(record.rfqId);
|
|
2399
|
+
if (isRfqSwapTerminal(swap.state)) this.rememberFinished(swap, true);
|
|
2400
|
+
else {
|
|
2401
|
+
this.origins.set(record.rfqId, rfqSwapOriginOf(record));
|
|
2402
|
+
this.track(swap);
|
|
2348
2403
|
}
|
|
2349
|
-
this.origins.set(record.rfqId, rfqSwapOriginOf(record));
|
|
2350
|
-
if (isRfqSwapTerminal(swap.state)) this.finished.set(swap.rfqId, swap);
|
|
2351
|
-
else this.track(swap);
|
|
2352
2404
|
restored.push(swap);
|
|
2405
|
+
};
|
|
2406
|
+
if (repository.getRfqSwapsPage && !options.includeTerminal) {
|
|
2407
|
+
for (const state of RFQ_SWAP_ACTIVE_STATES) {
|
|
2408
|
+
let afterId;
|
|
2409
|
+
for (; ; ) {
|
|
2410
|
+
const page = await repository.getRfqSwapsPage(state, afterId, 256);
|
|
2411
|
+
if (page.length === 0) break;
|
|
2412
|
+
if (page.length > 256)
|
|
2413
|
+
throw new Error("getRfqSwapsPage exceeded its requested limit");
|
|
2414
|
+
let cursor = afterId ?? "";
|
|
2415
|
+
for (const record of page) {
|
|
2416
|
+
if (record.state !== state || record.rfqId <= cursor) {
|
|
2417
|
+
throw new Error(
|
|
2418
|
+
"getRfqSwapsPage returned an unordered or mismatched page"
|
|
2419
|
+
);
|
|
2420
|
+
}
|
|
2421
|
+
cursor = record.rfqId;
|
|
2422
|
+
await restore(record);
|
|
2423
|
+
}
|
|
2424
|
+
afterId = cursor;
|
|
2425
|
+
if (page.length < 256) break;
|
|
2426
|
+
}
|
|
2427
|
+
}
|
|
2428
|
+
} else {
|
|
2429
|
+
const records = await repository.getAllRfqSwaps();
|
|
2430
|
+
for (const record of records) {
|
|
2431
|
+
await restore(record);
|
|
2432
|
+
}
|
|
2353
2433
|
}
|
|
2354
2434
|
if (this.running) {
|
|
2355
|
-
await
|
|
2356
|
-
restored.filter((swap) => this.monitored.has(swap.rfqId)).map((swap) => this.pollSwap(swap))
|
|
2357
|
-
);
|
|
2435
|
+
await this.pollMany(restored.filter((swap) => this.monitored.has(swap.rfqId)));
|
|
2358
2436
|
}
|
|
2359
|
-
return { restored, failed, pruned };
|
|
2437
|
+
return { restored, failed, pruned: [] };
|
|
2360
2438
|
}
|
|
2361
2439
|
/**
|
|
2362
2440
|
* Drop stored records that are terminal and past
|
|
@@ -2367,10 +2445,8 @@ var RfqSwapManager = class {
|
|
|
2367
2445
|
* lives in `shouldRetainRfqSwap`, which this defers to rather than
|
|
2368
2446
|
* restating.
|
|
2369
2447
|
*
|
|
2370
|
-
*
|
|
2371
|
-
*
|
|
2372
|
-
* at boot. {@link restoreFromRepository} runs it first, so the boot path
|
|
2373
|
-
* needs no separate call.
|
|
2448
|
+
* This legacy deletion API is explicit; normal restore preserves history.
|
|
2449
|
+
* It loads every stored record: no backend offers indexed deletion for it.
|
|
2374
2450
|
*/
|
|
2375
2451
|
async pruneRetiredSwaps() {
|
|
2376
2452
|
const repository = this.deps.repository;
|
|
@@ -2383,12 +2459,15 @@ var RfqSwapManager = class {
|
|
|
2383
2459
|
for (const record of records) {
|
|
2384
2460
|
if (shouldRetainRfqSwap(record, now)) continue;
|
|
2385
2461
|
await repository.removeRfqSwap(record.rfqId);
|
|
2386
|
-
this.
|
|
2387
|
-
if (!this.monitored.has(record.rfqId)) this.origins.delete(record.rfqId);
|
|
2462
|
+
this.forgetRetired(record.rfqId);
|
|
2388
2463
|
dropped.push(record.rfqId);
|
|
2389
2464
|
}
|
|
2390
2465
|
return dropped;
|
|
2391
2466
|
}
|
|
2467
|
+
forgetRetired(rfqId) {
|
|
2468
|
+
this.finished.delete(rfqId);
|
|
2469
|
+
if (!this.monitored.has(rfqId)) this.origins.delete(rfqId);
|
|
2470
|
+
}
|
|
2392
2471
|
requireRepository(method) {
|
|
2393
2472
|
const repository = this.deps.repository;
|
|
2394
2473
|
if (!repository) {
|
|
@@ -2413,8 +2492,7 @@ var RfqSwapManager = class {
|
|
|
2413
2492
|
/**
|
|
2414
2493
|
* Load records and begin monitoring. Runs one pass immediately — a caller
|
|
2415
2494
|
* resuming after a restart may be well past a deadline already — then
|
|
2416
|
-
* every `pollIntervalMs`.
|
|
2417
|
-
* so {@link waitForSwapCompletion} can answer for them.
|
|
2495
|
+
* every `pollIntervalMs`. Terminal outcomes in a repository are read on demand.
|
|
2418
2496
|
*
|
|
2419
2497
|
* Calling it again while running loads the records and returns rather than
|
|
2420
2498
|
* re-arming — dropping them silently would strand a funded swap on a
|
|
@@ -2431,8 +2509,11 @@ var RfqSwapManager = class {
|
|
|
2431
2509
|
async start(swaps = []) {
|
|
2432
2510
|
for (const swap of swaps) await this.admit(swap);
|
|
2433
2511
|
for (const swap of swaps) {
|
|
2434
|
-
|
|
2435
|
-
|
|
2512
|
+
this.removed.delete(swap.rfqId);
|
|
2513
|
+
if (isRfqSwapTerminal(swap.state)) {
|
|
2514
|
+
this.rememberFinished(swap);
|
|
2515
|
+
this.origins.delete(swap.rfqId);
|
|
2516
|
+
} else this.track(swap);
|
|
2436
2517
|
}
|
|
2437
2518
|
if (this.running) return;
|
|
2438
2519
|
this.running = true;
|
|
@@ -2477,8 +2558,10 @@ var RfqSwapManager = class {
|
|
|
2477
2558
|
*/
|
|
2478
2559
|
async addSwap(swap, origin) {
|
|
2479
2560
|
await this.admit(swap, origin);
|
|
2561
|
+
this.removed.delete(swap.rfqId);
|
|
2480
2562
|
if (isRfqSwapTerminal(swap.state)) {
|
|
2481
|
-
this.
|
|
2563
|
+
this.rememberFinished(swap);
|
|
2564
|
+
this.origins.delete(swap.rfqId);
|
|
2482
2565
|
return;
|
|
2483
2566
|
}
|
|
2484
2567
|
this.track(swap);
|
|
@@ -2514,6 +2597,7 @@ var RfqSwapManager = class {
|
|
|
2514
2597
|
* manager stops driving the swap. Retiring the row is reserved for a swap
|
|
2515
2598
|
* that reached a terminal state, where the lockup is provably done. */
|
|
2516
2599
|
async removeSwap(rfqId) {
|
|
2600
|
+
this.removed.set(rfqId, ++this.removalSeq);
|
|
2517
2601
|
this.untrack(rfqId);
|
|
2518
2602
|
this.finished.delete(rfqId);
|
|
2519
2603
|
this.registered.delete(rfqId);
|
|
@@ -2537,6 +2621,7 @@ var RfqSwapManager = class {
|
|
|
2537
2621
|
async isProcessing(rfqId) {
|
|
2538
2622
|
return this.inProgress.has(rfqId);
|
|
2539
2623
|
}
|
|
2624
|
+
/** `finishedSwaps` counts terminal swaps cached in memory, not those only in the repository. */
|
|
2540
2625
|
async getStats() {
|
|
2541
2626
|
return {
|
|
2542
2627
|
isRunning: this.running,
|
|
@@ -2556,7 +2641,30 @@ var RfqSwapManager = class {
|
|
|
2556
2641
|
* no-op for any swap already being worked on.
|
|
2557
2642
|
*/
|
|
2558
2643
|
async poll() {
|
|
2559
|
-
await
|
|
2644
|
+
await this.pollMany([...this.monitored.values()]);
|
|
2645
|
+
}
|
|
2646
|
+
async pollMany(swaps) {
|
|
2647
|
+
for (let i = 0; i < swaps.length; i += _RfqSwapManager.POLL_CONCURRENCY) {
|
|
2648
|
+
await Promise.allSettled(
|
|
2649
|
+
swaps.slice(i, i + _RfqSwapManager.POLL_CONCURRENCY).map((swap) => this.pollSwap(swap))
|
|
2650
|
+
);
|
|
2651
|
+
}
|
|
2652
|
+
}
|
|
2653
|
+
async acquirePollSlot() {
|
|
2654
|
+
if (this.activePolls < _RfqSwapManager.POLL_CONCURRENCY) {
|
|
2655
|
+
this.activePolls++;
|
|
2656
|
+
} else {
|
|
2657
|
+
await new Promise((resolve) => this.pollWaiters.add(resolve));
|
|
2658
|
+
}
|
|
2659
|
+
return () => {
|
|
2660
|
+
const next = this.pollWaiters.values().next().value;
|
|
2661
|
+
if (next) {
|
|
2662
|
+
this.pollWaiters.delete(next);
|
|
2663
|
+
next();
|
|
2664
|
+
} else {
|
|
2665
|
+
this.activePolls--;
|
|
2666
|
+
}
|
|
2667
|
+
};
|
|
2560
2668
|
}
|
|
2561
2669
|
/**
|
|
2562
2670
|
* Resolve once this swap's PAYOUT is decided — which for onchain-send is
|
|
@@ -2575,6 +2683,15 @@ var RfqSwapManager = class {
|
|
|
2575
2683
|
*/
|
|
2576
2684
|
async waitForSwapCompletion(rfqId) {
|
|
2577
2685
|
const swap = this.monitored.get(rfqId) ?? this.finished.get(rfqId);
|
|
2686
|
+
if (!swap && !this.removed.has(rfqId) && this.deps.repository) {
|
|
2687
|
+
const record = await this.deps.repository.getRfqSwap(rfqId);
|
|
2688
|
+
if (record && !this.removed.has(rfqId) && isRfqSwapTerminal(record.state)) {
|
|
2689
|
+
if (record.state === "failed") {
|
|
2690
|
+
throw new Error(record.failure ?? `swap ${rfqId} failed`);
|
|
2691
|
+
}
|
|
2692
|
+
return outcomeOfRecord(record);
|
|
2693
|
+
}
|
|
2694
|
+
}
|
|
2578
2695
|
if (!swap) throw new Error(`swap ${rfqId} is not monitored`);
|
|
2579
2696
|
if (swap.state === "failed") throw new Error(swap.failure ?? `swap ${rfqId} failed`);
|
|
2580
2697
|
if (isPayoutDecided(swap)) return outcomeOf(swap);
|
|
@@ -2717,16 +2834,21 @@ var RfqSwapManager = class {
|
|
|
2717
2834
|
if (this.inProgress.has(swap.rfqId)) return;
|
|
2718
2835
|
if (!this.monitored.has(swap.rfqId)) return;
|
|
2719
2836
|
this.inProgress.add(swap.rfqId);
|
|
2837
|
+
const release = await this.acquirePollSlot();
|
|
2720
2838
|
try {
|
|
2721
|
-
await this.runPass(swap);
|
|
2839
|
+
if (this.monitored.has(swap.rfqId)) await this.runPass(swap);
|
|
2722
2840
|
} finally {
|
|
2723
|
-
|
|
2724
|
-
|
|
2725
|
-
|
|
2726
|
-
|
|
2727
|
-
|
|
2841
|
+
try {
|
|
2842
|
+
const persisted = this.dirty.has(swap.rfqId) ? await this.save(swap) : true;
|
|
2843
|
+
if (persisted) {
|
|
2844
|
+
this.dirty.delete(swap.rfqId);
|
|
2845
|
+
this.settleWaiters(swap);
|
|
2846
|
+
if (isRfqSwapTerminal(swap.state)) this.finalize(swap);
|
|
2847
|
+
}
|
|
2848
|
+
} finally {
|
|
2849
|
+
this.inProgress.delete(swap.rfqId);
|
|
2850
|
+
release();
|
|
2728
2851
|
}
|
|
2729
|
-
this.inProgress.delete(swap.rfqId);
|
|
2730
2852
|
}
|
|
2731
2853
|
}
|
|
2732
2854
|
async runPass(swap) {
|
|
@@ -2870,6 +2992,11 @@ var RfqSwapManager = class {
|
|
|
2870
2992
|
this.setState(swap, "claimed");
|
|
2871
2993
|
this.emitAction(swap, "claimLockup");
|
|
2872
2994
|
} catch (error) {
|
|
2995
|
+
const ark = isArkError(error) ? error : maybeArkError(error);
|
|
2996
|
+
if (isArkError(ark, ArkErrorName.VTXO_ALREADY_SPENT)) {
|
|
2997
|
+
this.lastClaimError.delete(swap.rfqId);
|
|
2998
|
+
return;
|
|
2999
|
+
}
|
|
2873
3000
|
this.lastClaimError.set(swap.rfqId, errorMessage(error));
|
|
2874
3001
|
this.emitFailed(swap, error);
|
|
2875
3002
|
}
|
|
@@ -3148,8 +3275,10 @@ var RfqSwapManager = class {
|
|
|
3148
3275
|
finalize(swap) {
|
|
3149
3276
|
if (!this.monitored.has(swap.rfqId)) return;
|
|
3150
3277
|
this.untrack(swap.rfqId);
|
|
3151
|
-
this.
|
|
3278
|
+
this.rememberFinished(swap, true);
|
|
3152
3279
|
this.retireContract(swap);
|
|
3280
|
+
this.registered.delete(swap.rfqId);
|
|
3281
|
+
this.origins.delete(swap.rfqId);
|
|
3153
3282
|
if (swap.state === "failed") {
|
|
3154
3283
|
notify(
|
|
3155
3284
|
this.swapFailedListeners,
|
|
@@ -3159,6 +3288,10 @@ var RfqSwapManager = class {
|
|
|
3159
3288
|
}
|
|
3160
3289
|
notify(this.swapCompletedListeners, (listener) => listener(swap));
|
|
3161
3290
|
}
|
|
3291
|
+
rememberFinished(swap, durable = false) {
|
|
3292
|
+
if (durable && this.deps.repository) this.finished.delete(swap.rfqId);
|
|
3293
|
+
else this.finished.set(swap.rfqId, swap);
|
|
3294
|
+
}
|
|
3162
3295
|
settleWaiters(swap) {
|
|
3163
3296
|
const waiting = this.waiters.get(swap.rfqId);
|
|
3164
3297
|
if (!waiting) return;
|
|
@@ -3192,6 +3325,14 @@ var outcomeOf = (swap) => {
|
|
|
3192
3325
|
txid: lostReceive ? swap.refundArkTxid : traderClaimTxid(swap) ?? swap.refundArkTxid
|
|
3193
3326
|
};
|
|
3194
3327
|
};
|
|
3328
|
+
var outcomeOfRecord = (record) => {
|
|
3329
|
+
const profileClaim = record.kind === "onchain_send" ? record.profile.claimTxid : record.kind === "lightning_receive" ? record.profile.claimArkTxid : void 0;
|
|
3330
|
+
const claimTxid = typeof profileClaim === "string" ? profileClaim : void 0;
|
|
3331
|
+
return {
|
|
3332
|
+
state: record.state,
|
|
3333
|
+
txid: record.kind === "lightning_receive" && record.state === "refunded" ? record.refundArkTxid : claimTxid ?? record.refundArkTxid
|
|
3334
|
+
};
|
|
3335
|
+
};
|
|
3195
3336
|
var errorMessage = (error) => error instanceof Error ? error.message : String(error);
|
|
3196
3337
|
var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
|
|
3197
3338
|
|
|
@@ -3256,6 +3397,56 @@ async function rfqSwapActivityInputs(deps) {
|
|
|
3256
3397
|
const records = await deps.repository.getAllRfqSwaps();
|
|
3257
3398
|
return Promise.all(records.map((record) => activityInputOf(record, deps.indexer)));
|
|
3258
3399
|
}
|
|
3400
|
+
async function rfqSwapActivityInputsPage(deps, state, afterId, limit) {
|
|
3401
|
+
assertRfqSwapPageLimit(limit);
|
|
3402
|
+
const page = deps.repository.getRfqSwapsPage;
|
|
3403
|
+
if (!page) throw new Error("repository does not support paged RFQ activity reads");
|
|
3404
|
+
const records = await page.call(deps.repository, state, afterId, limit);
|
|
3405
|
+
if (records.length > limit) throw new Error("getRfqSwapsPage exceeded its requested limit");
|
|
3406
|
+
let cursor = afterId ?? "";
|
|
3407
|
+
for (const record of records) {
|
|
3408
|
+
if (record.state !== state || record.rfqId <= cursor) {
|
|
3409
|
+
throw new Error("getRfqSwapsPage returned an unordered or mismatched page");
|
|
3410
|
+
}
|
|
3411
|
+
cursor = record.rfqId;
|
|
3412
|
+
}
|
|
3413
|
+
const inputs = await projectActivityInputs(records, deps.indexer);
|
|
3414
|
+
return {
|
|
3415
|
+
inputs,
|
|
3416
|
+
...records.length === limit && records.length > 0 ? { nextCursor: cursor } : {}
|
|
3417
|
+
};
|
|
3418
|
+
}
|
|
3419
|
+
async function rfqSwapActivityInputsSincePage(deps, state, since, after, limit) {
|
|
3420
|
+
assertRfqSwapPageLimit(limit);
|
|
3421
|
+
assertRfqSwapSince(since);
|
|
3422
|
+
const page = deps.repository.getRfqSwapsUpdatedPage;
|
|
3423
|
+
if (!page) throw new Error("repository does not support date-filtered RFQ history pages");
|
|
3424
|
+
const records = await page.call(deps.repository, state, since, after, limit);
|
|
3425
|
+
if (records.length > limit)
|
|
3426
|
+
throw new Error("getRfqSwapsUpdatedPage exceeded its requested limit");
|
|
3427
|
+
let cursor = after;
|
|
3428
|
+
for (const record of records) {
|
|
3429
|
+
if (record.state !== state || record.updatedAt < since || cursor && (record.updatedAt < cursor.updatedAt || record.updatedAt === cursor.updatedAt && record.rfqId <= cursor.rfqId)) {
|
|
3430
|
+
throw new Error("getRfqSwapsUpdatedPage returned an unordered or mismatched page");
|
|
3431
|
+
}
|
|
3432
|
+
cursor = { updatedAt: record.updatedAt, rfqId: record.rfqId };
|
|
3433
|
+
}
|
|
3434
|
+
return {
|
|
3435
|
+
inputs: await projectActivityInputs(records, deps.indexer),
|
|
3436
|
+
...records.length === limit && cursor ? { nextCursor: cursor } : {}
|
|
3437
|
+
};
|
|
3438
|
+
}
|
|
3439
|
+
async function projectActivityInputs(records, indexer) {
|
|
3440
|
+
const inputs = [];
|
|
3441
|
+
for (let i = 0; i < records.length; i += 16) {
|
|
3442
|
+
inputs.push(
|
|
3443
|
+
...await Promise.all(
|
|
3444
|
+
records.slice(i, i + 16).map((record) => activityInputOf(record, indexer))
|
|
3445
|
+
)
|
|
3446
|
+
);
|
|
3447
|
+
}
|
|
3448
|
+
return inputs;
|
|
3449
|
+
}
|
|
3259
3450
|
async function activityInputOf(record, indexer) {
|
|
3260
3451
|
const txids = /* @__PURE__ */ new Set();
|
|
3261
3452
|
if (record.fundingArkTxid) txids.add(record.fundingArkTxid);
|
|
@@ -3326,6 +3517,8 @@ export {
|
|
|
3326
3517
|
REFUND_MTP_LAG_SECONDS,
|
|
3327
3518
|
RFQ_REFUSAL_ERROR_CODES,
|
|
3328
3519
|
RFQ_RESOLVED_STATES,
|
|
3520
|
+
RFQ_SWAP_ACTIVE_STATES,
|
|
3521
|
+
RFQ_SWAP_MAX_PAGE_SIZE,
|
|
3329
3522
|
RFQ_SWAP_RETENTION_SECONDS,
|
|
3330
3523
|
RFQ_SWAP_TERMINAL_STATES,
|
|
3331
3524
|
RFQ_TERMINAL_STATES,
|
|
@@ -3430,6 +3623,8 @@ export {
|
|
|
3430
3623
|
rfqSecretsProfile,
|
|
3431
3624
|
rfqSignerOf,
|
|
3432
3625
|
rfqSwapActivityInputs,
|
|
3626
|
+
rfqSwapActivityInputsPage,
|
|
3627
|
+
rfqSwapActivityInputsSincePage,
|
|
3433
3628
|
rfqSwapOriginOf,
|
|
3434
3629
|
sealClaimPacket,
|
|
3435
3630
|
senderIdentityForSwapRecord,
|
|
@@ -29,6 +29,19 @@ __export(realm_exports, {
|
|
|
29
29
|
module.exports = __toCommonJS(realm_exports);
|
|
30
30
|
|
|
31
31
|
// src/repository.ts
|
|
32
|
+
var RFQ_SWAP_MAX_PAGE_SIZE = 500;
|
|
33
|
+
function assertRfqSwapPageLimit(limit) {
|
|
34
|
+
if (!Number.isInteger(limit) || limit < 1 || limit > RFQ_SWAP_MAX_PAGE_SIZE) {
|
|
35
|
+
throw new RangeError(
|
|
36
|
+
`RFQ swap page limit must be an integer from 1 to ${RFQ_SWAP_MAX_PAGE_SIZE}`
|
|
37
|
+
);
|
|
38
|
+
}
|
|
39
|
+
}
|
|
40
|
+
function assertRfqSwapSince(since) {
|
|
41
|
+
if (!Number.isSafeInteger(since) || since < 0) {
|
|
42
|
+
throw new RangeError("RFQ history since must be a non-negative Unix timestamp in seconds");
|
|
43
|
+
}
|
|
44
|
+
}
|
|
32
45
|
var marketsCacheKey = (network, registry) => `arkade-intents-markets-${network}-${registry}`;
|
|
33
46
|
|
|
34
47
|
// src/repositories/realm/repository.ts
|
|
@@ -86,6 +99,36 @@ var RealmAssetSwapRepository = class {
|
|
|
86
99
|
(o) => JSON.parse(o.data)
|
|
87
100
|
);
|
|
88
101
|
}
|
|
102
|
+
async getRfqSwapsPage(state, afterId, limit) {
|
|
103
|
+
assertRfqSwapPageLimit(limit);
|
|
104
|
+
const rows = this.realm.objects(RFQ_SWAPS).filtered("state == $0 AND rfqId > $1", state, afterId ?? "").sorted("rfqId");
|
|
105
|
+
const page = [];
|
|
106
|
+
for (const row of rows) {
|
|
107
|
+
page.push(JSON.parse(row.data));
|
|
108
|
+
if (page.length === limit) break;
|
|
109
|
+
}
|
|
110
|
+
return page;
|
|
111
|
+
}
|
|
112
|
+
async getRfqSwapsUpdatedPage(state, since, after, limit) {
|
|
113
|
+
assertRfqSwapPageLimit(limit);
|
|
114
|
+
assertRfqSwapSince(since);
|
|
115
|
+
const rows = after ? this.realm.objects(RFQ_SWAPS).filtered(
|
|
116
|
+
"state == $0 AND updatedAt >= $1 AND (updatedAt > $2 OR (updatedAt == $2 AND rfqId > $3))",
|
|
117
|
+
state,
|
|
118
|
+
since,
|
|
119
|
+
after.updatedAt,
|
|
120
|
+
after.rfqId
|
|
121
|
+
) : this.realm.objects(RFQ_SWAPS).filtered("state == $0 AND updatedAt >= $1", state, since);
|
|
122
|
+
const page = [];
|
|
123
|
+
for (const row of rows.sorted([
|
|
124
|
+
["updatedAt", false],
|
|
125
|
+
["rfqId", false]
|
|
126
|
+
])) {
|
|
127
|
+
page.push(JSON.parse(row.data));
|
|
128
|
+
if (page.length === limit) break;
|
|
129
|
+
}
|
|
130
|
+
return page;
|
|
131
|
+
}
|
|
89
132
|
async removeRfqSwap(rfqId) {
|
|
90
133
|
this.realm.write(() => {
|
|
91
134
|
this.realm.delete(
|