@pod-network/trade-sdk 0.4.0 → 0.5.0
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 +5 -0
- package/dist/client.d.ts +27 -1
- package/dist/client.d.ts.map +1 -1
- package/dist/client.js +39 -1
- package/dist/client.js.map +1 -1
- package/dist/codec/resolution.d.ts +4 -1
- package/dist/codec/resolution.d.ts.map +1 -1
- package/dist/codec/resolution.js +6 -3
- package/dist/codec/resolution.js.map +1 -1
- package/dist/datafeed.d.ts.map +1 -1
- package/dist/datafeed.js +15 -9
- package/dist/datafeed.js.map +1 -1
- package/dist/stores/resource.d.ts +14 -1
- package/dist/stores/resource.d.ts.map +1 -1
- package/dist/stores/resource.js +7 -1
- package/dist/stores/resource.js.map +1 -1
- package/dist/sync/candles.d.ts +62 -4
- package/dist/sync/candles.d.ts.map +1 -1
- package/dist/sync/candles.js +259 -42
- package/dist/sync/candles.js.map +1 -1
- package/dist/transport/rest.d.ts +8 -0
- package/dist/transport/rest.d.ts.map +1 -1
- package/dist/transport/rest.js +8 -1
- package/dist/transport/rest.js.map +1 -1
- package/dist/write/index.d.ts +28 -0
- package/dist/write/index.d.ts.map +1 -1
- package/dist/write/index.js +23 -1
- package/dist/write/index.js.map +1 -1
- package/package.json +1 -1
- package/src/client.ts +46 -2
- package/src/codec/resolution.ts +6 -3
- package/src/datafeed.ts +15 -9
- package/src/stores/resource.ts +14 -1
- package/src/sync/candles.ts +297 -45
- package/src/transport/rest.ts +15 -1
- package/src/write/index.ts +42 -1
package/src/sync/candles.ts
CHANGED
|
@@ -17,11 +17,13 @@ import { dec, usToMs, WAD } from "../codec/units.js";
|
|
|
17
17
|
import { RESOLUTION_PAGE_BUCKETS, RESOLUTION_SECONDS } from "../codec/resolution.js";
|
|
18
18
|
import { BaseResource, type ResourceHandle } from "../stores/resource.js";
|
|
19
19
|
import type { Subscription } from "../transport/ws.js";
|
|
20
|
+
import { PodHttpError, type PodRestClient } from "../transport/rest.js";
|
|
20
21
|
import type { SyncContext } from "./sources.js";
|
|
21
22
|
|
|
22
23
|
export interface SeriesResource<Item> {
|
|
23
24
|
get(): Item[] | undefined;
|
|
24
25
|
subscribe(listener: () => void): () => void;
|
|
26
|
+
/** First committed value, not "window loaded" — see `Resource.ready`. */
|
|
25
27
|
ready(): Promise<Item[]>;
|
|
26
28
|
readonly error?: Error;
|
|
27
29
|
setWindow(range: TimeRange): void;
|
|
@@ -40,6 +42,271 @@ const bmin = (a: bigint, b: bigint) => (a < b ? a : b);
|
|
|
40
42
|
const REPLAY_SAFE_SECS = 3_600;
|
|
41
43
|
const SEED_RESOLUTION: Resolution = "1h";
|
|
42
44
|
|
|
45
|
+
/** One canonical page window: an epoch-anchored span of `RESOLUTION_PAGE_BUCKETS`
|
|
46
|
+
* buckets, identified by its page index. */
|
|
47
|
+
export interface CandlePageWindow { page: number; fromMs: number; toMs: number }
|
|
48
|
+
|
|
49
|
+
/**
|
|
50
|
+
* One page's bars, plus how far the indexer had actually got. `watermarkMs` is
|
|
51
|
+
* `MAX_SAFE_INTEGER` when the page is known complete (a settled cache hit), so
|
|
52
|
+
* it never bounds a read it has nothing to say about.
|
|
53
|
+
*/
|
|
54
|
+
interface CandlePage { bars: Bar[]; watermarkMs: number }
|
|
55
|
+
|
|
56
|
+
const pageSpanMs = (resolution: Resolution) =>
|
|
57
|
+
RESOLUTION_PAGE_BUCKETS[resolution] * RESOLUTION_SECONDS[resolution] * 1000;
|
|
58
|
+
|
|
59
|
+
/**
|
|
60
|
+
* Page index of `ms` on a resolution's epoch-anchored grid — the single
|
|
61
|
+
* definition of that grid. Every candle read goes through it on purpose: the
|
|
62
|
+
* server's `immutable` responses and the REST client's URL-keyed in-flight
|
|
63
|
+
* dedupe both only pay off while every request lands on the same boundaries, so
|
|
64
|
+
* a second implementation of this arithmetic would silently turn cache hits
|
|
65
|
+
* into node traffic.
|
|
66
|
+
*/
|
|
67
|
+
export function candlePageAt(resolution: Resolution, ms: number): number {
|
|
68
|
+
return Math.floor(Math.max(0, ms) / pageSpanMs(resolution));
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
/**
|
|
72
|
+
* One page's canonical window — `undefined` when the page holds nothing but the
|
|
73
|
+
* forming bucket, because there is nothing closed to fetch. The window is
|
|
74
|
+
* clamped to the last closed bucket so it stays fully elapsed: those are the
|
|
75
|
+
* responses the server marks `immutable`, while a `to` in the future is
|
|
76
|
+
* `no-store` on every open.
|
|
77
|
+
*/
|
|
78
|
+
export function candlePageWindow(
|
|
79
|
+
resolution: Resolution,
|
|
80
|
+
page: number,
|
|
81
|
+
nowMs = Date.now(),
|
|
82
|
+
): CandlePageWindow | undefined {
|
|
83
|
+
const stepMs = RESOLUTION_SECONDS[resolution] * 1000;
|
|
84
|
+
const fromMs = page * pageSpanMs(resolution);
|
|
85
|
+
const toMs = Math.min(fromMs + pageSpanMs(resolution), Math.floor(nowMs / stepMs) * stepMs);
|
|
86
|
+
return toMs > fromMs ? { page, fromMs, toMs } : undefined;
|
|
87
|
+
}
|
|
88
|
+
|
|
89
|
+
/** The canonical windows covering `[fromMs, toMs)`, oldest first. */
|
|
90
|
+
export function candlePageWindows(
|
|
91
|
+
resolution: Resolution,
|
|
92
|
+
fromMs: number,
|
|
93
|
+
toMs: number,
|
|
94
|
+
nowMs = Date.now(),
|
|
95
|
+
): CandlePageWindow[] {
|
|
96
|
+
const windows: CandlePageWindow[] = [];
|
|
97
|
+
const last = candlePageAt(resolution, toMs - 1);
|
|
98
|
+
for (let page = candlePageAt(resolution, fromMs); page <= last; page++) {
|
|
99
|
+
const window = candlePageWindow(resolution, page, nowMs);
|
|
100
|
+
if (window) windows.push(window);
|
|
101
|
+
}
|
|
102
|
+
return windows;
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
/**
|
|
106
|
+
* The live series' bars inside `range`, waiting up to `timeoutMs` for one to
|
|
107
|
+
* turn up. The series folds the tick stream, so this is where the forming
|
|
108
|
+
* bucket comes from — REST withholds it.
|
|
109
|
+
*
|
|
110
|
+
* Deliberately not `ready()`: that resolves on the series' FIRST commit, and a
|
|
111
|
+
* fresh series commits an empty seed while its load is still in flight (see
|
|
112
|
+
* `fetchPages`, which surfaces loading state before any page lands). Awaiting
|
|
113
|
+
* it hands back `[]` and gives up before the bucket it was called for arrives.
|
|
114
|
+
*/
|
|
115
|
+
export function candleTailFrom(
|
|
116
|
+
series: SeriesResource<Bar>,
|
|
117
|
+
range: TimeRange,
|
|
118
|
+
timeoutMs: number,
|
|
119
|
+
): Promise<Bar[]> {
|
|
120
|
+
const toMs = range.to ?? Number.MAX_SAFE_INTEGER;
|
|
121
|
+
const inWindow = () => (series.get() ?? []).filter((b) => b.time >= range.from && b.time < toMs);
|
|
122
|
+
const found = inWindow();
|
|
123
|
+
if (found.length) return Promise.resolve(found);
|
|
124
|
+
return new Promise((resolve) => {
|
|
125
|
+
let release: (() => void) | undefined;
|
|
126
|
+
let timer: ReturnType<typeof setTimeout> | undefined;
|
|
127
|
+
let settled = false;
|
|
128
|
+
const settle = (bars: Bar[]) => {
|
|
129
|
+
if (settled) return;
|
|
130
|
+
settled = true;
|
|
131
|
+
clearTimeout(timer);
|
|
132
|
+
release?.();
|
|
133
|
+
resolve(bars);
|
|
134
|
+
};
|
|
135
|
+
timer = setTimeout(() => settle(inWindow()), timeoutMs);
|
|
136
|
+
release = series.subscribe(() => {
|
|
137
|
+
const bars = inWindow();
|
|
138
|
+
if (bars.length) settle(bars);
|
|
139
|
+
});
|
|
140
|
+
// `subscribe` starts the source, which can emit synchronously inside the
|
|
141
|
+
// call above — before `release` was assigned. Release here or the listener
|
|
142
|
+
// (and with it the series' tick fold) is never let go.
|
|
143
|
+
if (settled) release();
|
|
144
|
+
});
|
|
145
|
+
}
|
|
146
|
+
|
|
147
|
+
/**
|
|
148
|
+
* Decoded pages, per REST client — so per host, never shared between clients
|
|
149
|
+
* pointed at different environments. A page is only stored once it can never
|
|
150
|
+
* change again, which takes BOTH of: a full span (not the trailing page, which
|
|
151
|
+
* still grows as buckets close) and an indexer watermark past the window's end.
|
|
152
|
+
* Wall clock is not enough — the server gates its own `immutable` header on
|
|
153
|
+
* solution time, and a window that has elapsed by the clock while the indexer
|
|
154
|
+
* lags comes back SHORT of its newest buckets. Caching that would pin a hole
|
|
155
|
+
* for the process's lifetime, which is the failure this whole read exists to
|
|
156
|
+
* avoid.
|
|
157
|
+
*
|
|
158
|
+
* Without this, overlapping requests re-decode the same bars, and overlap is
|
|
159
|
+
* the norm: a chart's opening window reaches further back than it has been
|
|
160
|
+
* served, and every pan-left ends mid-page. Decoding costs six `BigInt` parses
|
|
161
|
+
* per bar (see `decodeCandle`) on the thread that draws the chart.
|
|
162
|
+
*/
|
|
163
|
+
const pageCaches = new WeakMap<PodRestClient, Map<string, Bar[]>>();
|
|
164
|
+
const PAGE_CACHE_MAX = 256;
|
|
165
|
+
|
|
166
|
+
/** One canonical page, served from this client's page cache when it is final. */
|
|
167
|
+
async function fetchCandlePage(
|
|
168
|
+
rest: PodRestClient,
|
|
169
|
+
id: MarketId,
|
|
170
|
+
resolution: Resolution,
|
|
171
|
+
window: CandlePageWindow,
|
|
172
|
+
): Promise<CandlePage> {
|
|
173
|
+
const wholePage = window.toMs - window.fromMs === pageSpanMs(resolution);
|
|
174
|
+
const key = `${id}:${resolution}:${window.page}`;
|
|
175
|
+
let cache = pageCaches.get(rest);
|
|
176
|
+
if (!cache) pageCaches.set(rest, (cache = new Map()));
|
|
177
|
+
// Cached entries were verified final when stored, so a hit needs no re-check.
|
|
178
|
+
const hit = wholePage ? cache.get(key) : undefined;
|
|
179
|
+
if (hit) return { bars: hit, watermarkMs: Number.MAX_SAFE_INTEGER };
|
|
180
|
+
for (let attempt = 1; ; attempt++) {
|
|
181
|
+
try {
|
|
182
|
+
const page = await rest.candles(id, {
|
|
183
|
+
resolution,
|
|
184
|
+
from: window.fromMs,
|
|
185
|
+
to: window.toMs,
|
|
186
|
+
limit: RESOLUTION_PAGE_BUCKETS[resolution],
|
|
187
|
+
});
|
|
188
|
+
// Two different questions, so two predicates. Cacheable? Only a whole
|
|
189
|
+
// page the indexer has passed can never change again.
|
|
190
|
+
const covered = page.solutionNow >= window.toMs;
|
|
191
|
+
if (covered && wholePage) {
|
|
192
|
+
// Oldest insertion out first; the bound is on memory, not a policy.
|
|
193
|
+
if (cache.size >= PAGE_CACHE_MAX) cache.delete(cache.keys().next().value!);
|
|
194
|
+
cache.set(key, page.bars);
|
|
195
|
+
}
|
|
196
|
+
// Worth retrying? Only a WHOLE page that came back short — the indexer is
|
|
197
|
+
// behind by more than a page and a moment will fix it. The trailing page
|
|
198
|
+
// is clamped by OUR clock, so its shortfall is the normal state of
|
|
199
|
+
// affairs, and retrying it spins three requests and seconds of backoff
|
|
200
|
+
// against a healthy node on nothing worse than clock skew.
|
|
201
|
+
if (covered || !wholePage || attempt >= PAGE_ATTEMPTS) {
|
|
202
|
+
return { bars: page.bars, watermarkMs: page.solutionNow };
|
|
203
|
+
}
|
|
204
|
+
} catch (err) {
|
|
205
|
+
if (attempt >= PAGE_ATTEMPTS || !worthRetrying(err)) throw err;
|
|
206
|
+
}
|
|
207
|
+
// Exponential with jitter: the node sheds load in bursts, and a read that
|
|
208
|
+
// retries on a fixed short delay just lands inside the same burst.
|
|
209
|
+
const backoff = PAGE_RETRY_MS * 2 ** (attempt - 1) * (1 + Math.random());
|
|
210
|
+
await new Promise((resolve) => setTimeout(resolve, backoff));
|
|
211
|
+
}
|
|
212
|
+
}
|
|
213
|
+
|
|
214
|
+
/** How many pages a history read has in flight at once. */
|
|
215
|
+
const HISTORY_CONCURRENCY = 8;
|
|
216
|
+
|
|
217
|
+
/**
|
|
218
|
+
* Attempts per page, and the backoff between them. One failure must not decide
|
|
219
|
+
* a whole read: `fetchCandleHistory` rejects the window on a failed page, and a
|
|
220
|
+
* chart shows that as a hard error it will not retry on its own. Cold windows
|
|
221
|
+
* on a busy node do fail once and then answer in half a second, which is
|
|
222
|
+
* exactly what a retry is for. A 4xx (other than 429) is the server saying the
|
|
223
|
+
* request itself is wrong — asking again cannot help.
|
|
224
|
+
*/
|
|
225
|
+
const PAGE_ATTEMPTS = 3;
|
|
226
|
+
const PAGE_RETRY_MS = 400;
|
|
227
|
+
|
|
228
|
+
const worthRetrying = (err: unknown) =>
|
|
229
|
+
!(err instanceof PodHttpError) || err.status === 429 || err.status >= 500;
|
|
230
|
+
|
|
231
|
+
/**
|
|
232
|
+
* Closed bars covering `[range.from, range.to)` — the one-shot read behind a
|
|
233
|
+
* chart's history request, with no resource, no subscription and no shared
|
|
234
|
+
* mutable state.
|
|
235
|
+
*
|
|
236
|
+
* A page that fails after its retries decides how much of the window is
|
|
237
|
+
* deliverable, and WHERE it failed is what matters:
|
|
238
|
+
*
|
|
239
|
+
* - at the old end, the answer is simply shorter — history stops at the gap,
|
|
240
|
+
* and the caller asks again for the older range when it needs it (a chart
|
|
241
|
+
* does exactly that on the next pan). Nothing is misrepresented, with one
|
|
242
|
+
* exception that must not slip through: if nothing at all survives, an empty
|
|
243
|
+
* answer would assert the window is empty, so that case rejects too.
|
|
244
|
+
* - anywhere inside, the read REJECTS. A chart treats the answer as the truth
|
|
245
|
+
* for the range it asked about and does not re-ask, so bars either side of a
|
|
246
|
+
* swallowed gap would draw a hole nobody can detect — the failure this whole
|
|
247
|
+
* read exists to prevent. Callers get an error they can retry.
|
|
248
|
+
*
|
|
249
|
+
* (The live series takes the opposite side of that trade — see `fetchPages`.)
|
|
250
|
+
*/
|
|
251
|
+
export async function fetchCandleHistory(
|
|
252
|
+
rest: PodRestClient,
|
|
253
|
+
id: MarketId,
|
|
254
|
+
resolution: Resolution,
|
|
255
|
+
range: TimeRange,
|
|
256
|
+
nowMs = Date.now(),
|
|
257
|
+
): Promise<Bar[]> {
|
|
258
|
+
const toMs = range.to ?? nowMs;
|
|
259
|
+
const windows = candlePageWindows(resolution, range.from, toMs, nowMs);
|
|
260
|
+
const pages: CandlePage[] = new Array(windows.length);
|
|
261
|
+
const failures: unknown[] = new Array(windows.length);
|
|
262
|
+
// Newest page first, `HISTORY_CONCURRENCY` at a time: a wide window is tens
|
|
263
|
+
// of pages (56 for a fortnight of 1m bars, thousands for a year), and firing
|
|
264
|
+
// them all at once queues the visible edge behind the oldest history on
|
|
265
|
+
// HTTP/1.1 and lands the whole fan-out on the node at once on HTTP/2.
|
|
266
|
+
let next = windows.length - 1;
|
|
267
|
+
const worker = async () => {
|
|
268
|
+
while (next >= 0) {
|
|
269
|
+
const i = next--;
|
|
270
|
+
try {
|
|
271
|
+
pages[i] = await fetchCandlePage(rest, id, resolution, windows[i]!);
|
|
272
|
+
} catch (err) {
|
|
273
|
+
failures[i] = err;
|
|
274
|
+
}
|
|
275
|
+
}
|
|
276
|
+
};
|
|
277
|
+
await Promise.all(Array.from({ length: Math.min(HISTORY_CONCURRENCY, windows.length) }, worker));
|
|
278
|
+
|
|
279
|
+
// An unfetched page reads as `undefined`; an empty page is an empty array, so
|
|
280
|
+
// "no bars here" and "never arrived" stay distinguishable.
|
|
281
|
+
const oldestOk = pages.findIndex((page) => page !== undefined);
|
|
282
|
+
if (windows.length && oldestOk === -1) throw failures.find((err) => err !== undefined);
|
|
283
|
+
for (let i = oldestOk; i < pages.length; i++) {
|
|
284
|
+
if (pages[i] === undefined) throw failures[i]; // a gap with bars on both sides
|
|
285
|
+
}
|
|
286
|
+
const kept = pages.slice(Math.max(0, oldestOk));
|
|
287
|
+
// The indexer's watermark bounds what any of these answers could cover:
|
|
288
|
+
// buckets past it are not history yet, they are simply unwritten. Claiming
|
|
289
|
+
// only up to there keeps a lagging indexer from looking like a complete
|
|
290
|
+
// window that happens to stop early.
|
|
291
|
+
const coveredToMs = kept.reduce((limit, page) => Math.min(limit, page.watermarkMs), toMs);
|
|
292
|
+
// Pages tile the window in ascending order and never overlap, so this is
|
|
293
|
+
// already sorted; the filter drops the partial buckets at either edge.
|
|
294
|
+
const bars = kept.flatMap((page) => page.bars).filter((b) => b.time >= range.from && b.time < coveredToMs);
|
|
295
|
+
|
|
296
|
+
// An EMPTY answer is not a small answer: it asserts "there are no bars in this
|
|
297
|
+
// window", and a chart takes that as settled and stops asking. Only the part
|
|
298
|
+
// of the window that was actually read can say that. So when nothing came
|
|
299
|
+
// back and the window was not covered — a failed page dropped off the old
|
|
300
|
+
// end, or the watermark short of the new end — surface the failure instead,
|
|
301
|
+
// which the caller retries. Otherwise a quiet stretch next to a shed page
|
|
302
|
+
// would hide that page's bars for as long as the chart lives.
|
|
303
|
+
if (!bars.length && (oldestOk > 0 || coveredToMs < toMs)) {
|
|
304
|
+
throw failures[oldestOk - 1]
|
|
305
|
+
?? new Error(`candle history for ${id} is not indexed past ${coveredToMs}`);
|
|
306
|
+
}
|
|
307
|
+
return bars;
|
|
308
|
+
}
|
|
309
|
+
|
|
43
310
|
export class CandleSeries implements SeriesResource<Bar> {
|
|
44
311
|
private readonly base: BaseResource<Bar[]>;
|
|
45
312
|
private handle: ResourceHandle<Bar[]> | undefined;
|
|
@@ -47,12 +314,9 @@ export class CandleSeries implements SeriesResource<Bar> {
|
|
|
47
314
|
private readonly pages = new Map<number, Bar[]>(); // pageIndex -> closed bars
|
|
48
315
|
private readonly live = new Map<number, Bar>(); // bucketStartMs -> forming bar
|
|
49
316
|
private readonly resSecs: number;
|
|
50
|
-
private readonly pageBuckets: number;
|
|
51
|
-
private readonly pageSpanSecs: number;
|
|
52
317
|
|
|
53
318
|
private window: TimeRange;
|
|
54
319
|
private minPage: number | undefined;
|
|
55
|
-
private maxPage: number | undefined;
|
|
56
320
|
private _loading = false;
|
|
57
321
|
private _hasMore = true;
|
|
58
322
|
private lastTickUs = 0;
|
|
@@ -68,10 +332,7 @@ export class CandleSeries implements SeriesResource<Bar> {
|
|
|
68
332
|
range?: TimeRange,
|
|
69
333
|
) {
|
|
70
334
|
this.resSecs = RESOLUTION_SECONDS[resolution];
|
|
71
|
-
this.
|
|
72
|
-
this.pageSpanSecs = this.resSecs * this.pageBuckets;
|
|
73
|
-
const span = this.pageSpanSecs * 1000;
|
|
74
|
-
this.window = range ?? { from: Date.now() - span };
|
|
335
|
+
this.window = range ?? { from: Date.now() - pageSpanMs(resolution) };
|
|
75
336
|
|
|
76
337
|
this.base = new BaseResource<Bar[]>((h) => {
|
|
77
338
|
this.handle = h;
|
|
@@ -105,6 +366,12 @@ export class CandleSeries implements SeriesResource<Bar> {
|
|
|
105
366
|
this.tickSub?.unsubscribe();
|
|
106
367
|
this.tickSub = undefined;
|
|
107
368
|
this.handle = undefined;
|
|
369
|
+
// Folded buckets do not survive the fold being stopped: on re-subscribe
|
|
370
|
+
// the first `rebuild()` would re-emit a partially-folded bucket from
|
|
371
|
+
// whenever the series last ran, and a reader asking for the forming
|
|
372
|
+
// edge would take it as the answer. Closed pages are immutable, so they
|
|
373
|
+
// stay — dropping them would only refetch what is already correct.
|
|
374
|
+
this.live.clear();
|
|
108
375
|
};
|
|
109
376
|
});
|
|
110
377
|
}
|
|
@@ -131,17 +398,12 @@ export class CandleSeries implements SeriesResource<Bar> {
|
|
|
131
398
|
|
|
132
399
|
// --- internals ---
|
|
133
400
|
|
|
134
|
-
private pageOf(secs: number): number {
|
|
135
|
-
return Math.floor(secs / this.pageSpanSecs);
|
|
136
|
-
}
|
|
137
|
-
|
|
138
401
|
private async loadWindow(range: TimeRange): Promise<void> {
|
|
139
|
-
const
|
|
140
|
-
const
|
|
141
|
-
const startPage = this.
|
|
142
|
-
const endPage = this.
|
|
143
|
-
const
|
|
144
|
-
const trailingPage = this.pageOf(nowSecs);
|
|
402
|
+
const nowMs = Date.now();
|
|
403
|
+
const toMs = range.to ?? nowMs;
|
|
404
|
+
const startPage = candlePageAt(this.resolution, range.from);
|
|
405
|
+
const endPage = candlePageAt(this.resolution, Math.max(range.from, toMs - 1));
|
|
406
|
+
const trailingPage = candlePageAt(this.resolution, nowMs);
|
|
145
407
|
|
|
146
408
|
const wanted: number[] = [];
|
|
147
409
|
for (let p = startPage; p <= endPage; p++) {
|
|
@@ -150,42 +412,32 @@ export class CandleSeries implements SeriesResource<Bar> {
|
|
|
150
412
|
await this.fetchPages(wanted);
|
|
151
413
|
}
|
|
152
414
|
|
|
415
|
+
/** The oldest page loaded — `loadOlder` walks down from it. */
|
|
416
|
+
private notePage(page: number): void {
|
|
417
|
+
this.minPage = Math.min(this.minPage ?? page, page);
|
|
418
|
+
}
|
|
419
|
+
|
|
153
420
|
private async fetchPages(pageIndices: number[]): Promise<void> {
|
|
154
421
|
if (!pageIndices.length) { this.rebuild(); return; }
|
|
155
422
|
this._loading = true;
|
|
156
423
|
this.rebuild(); // surface loading state
|
|
157
424
|
try {
|
|
158
|
-
|
|
159
|
-
// server returns only closed bars either way, so the content is
|
|
160
|
-
// identical — but a fully-elapsed window is served `immutable`
|
|
161
|
-
// (browser/CDN-cacheable; its URL rotates once per bucket close), while
|
|
162
|
-
// a `to` in the future would be `no-store` on every open. The forming
|
|
163
|
-
// bucket comes from the tick subscription (see prepareLiveEdge).
|
|
164
|
-
const lastClosedMs = Math.floor(Date.now() / 1000 / this.resSecs) * this.resSecs * 1000;
|
|
425
|
+
const nowMs = Date.now(); // one clock read, so every page agrees on it
|
|
165
426
|
await Promise.all(pageIndices.map(async (p) => {
|
|
166
|
-
const
|
|
167
|
-
|
|
168
|
-
if (toMs <= fromMs) {
|
|
169
|
-
// Page holds nothing but the forming bucket (it just started) —
|
|
170
|
-
// nothing closed to fetch yet; keep bookkeeping consistent.
|
|
171
|
-
this.pages.set(p, this.pages.get(p) ?? []);
|
|
172
|
-
this.minPage = this.minPage === undefined ? p : Math.min(this.minPage, p);
|
|
173
|
-
this.maxPage = this.maxPage === undefined ? p : Math.max(this.maxPage, p);
|
|
174
|
-
return;
|
|
175
|
-
}
|
|
427
|
+
const window = candlePageWindow(this.resolution, p, nowMs);
|
|
428
|
+
if (!window) { this.notePage(p); return; }
|
|
176
429
|
try {
|
|
177
|
-
const
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
limit: this.pageBuckets,
|
|
182
|
-
});
|
|
183
|
-
this.pages.set(p, page.bars);
|
|
184
|
-
this.minPage = this.minPage === undefined ? p : Math.min(this.minPage, p);
|
|
185
|
-
this.maxPage = this.maxPage === undefined ? p : Math.max(this.maxPage, p);
|
|
186
|
-
if (page.bars.length === 0 && this.minPage === p) this._hasMore = false;
|
|
430
|
+
const { bars } = await fetchCandlePage(this.ctx.rest, this.id, this.resolution, window);
|
|
431
|
+
this.pages.set(p, bars);
|
|
432
|
+
this.notePage(p);
|
|
433
|
+
if (bars.length === 0 && this.minPage === p) this._hasMore = false;
|
|
187
434
|
} catch {
|
|
188
|
-
|
|
435
|
+
// A live series tolerates a missing page where `fetchCandleHistory`
|
|
436
|
+
// rejects: it will ask again. But leave the page MISSING rather than
|
|
437
|
+
// storing it empty — a stored empty page is indistinguishable from
|
|
438
|
+
// "no bars in this span", so a transient failure would become a
|
|
439
|
+
// permanent hole, since `loadWindow` only fetches pages it does not
|
|
440
|
+
// already have.
|
|
189
441
|
}
|
|
190
442
|
}));
|
|
191
443
|
} finally {
|
package/src/transport/rest.ts
CHANGED
|
@@ -70,16 +70,25 @@ type FetchFn = typeof fetch;
|
|
|
70
70
|
export interface RestClientOptions {
|
|
71
71
|
restUrl: string;
|
|
72
72
|
fetch?: FetchFn;
|
|
73
|
+
/**
|
|
74
|
+
* Per-request timeout (ms, default 15s). A request that never settles is
|
|
75
|
+
* worse than one that fails: it holds its slot in `inflight`, so retries of
|
|
76
|
+
* the same URL join the hang instead of trying again. Cold candle windows on
|
|
77
|
+
* a busy node have taken tens of seconds and then answered in half a second.
|
|
78
|
+
*/
|
|
79
|
+
timeoutMs?: number;
|
|
73
80
|
}
|
|
74
81
|
|
|
75
82
|
export class PodRestClient {
|
|
76
83
|
private readonly base: string;
|
|
77
84
|
private readonly fetchFn: FetchFn;
|
|
85
|
+
private readonly timeoutMs: number;
|
|
78
86
|
private readonly inflight = new Map<string, Promise<unknown>>();
|
|
79
87
|
|
|
80
88
|
constructor(opts: RestClientOptions) {
|
|
81
89
|
this.base = opts.restUrl.replace(/\/$/, "");
|
|
82
90
|
this.fetchFn = opts.fetch ?? globalThis.fetch.bind(globalThis);
|
|
91
|
+
this.timeoutMs = opts.timeoutMs ?? 15_000;
|
|
83
92
|
}
|
|
84
93
|
|
|
85
94
|
private async get<T>(path: string, query?: Record<string, string | number | undefined>): Promise<T> {
|
|
@@ -105,7 +114,12 @@ export class PodRestClient {
|
|
|
105
114
|
}
|
|
106
115
|
|
|
107
116
|
private async doGet<T>(url: string): Promise<T> {
|
|
108
|
-
const res = await this.fetchFn(url, {
|
|
117
|
+
const res = await this.fetchFn(url, {
|
|
118
|
+
headers: { accept: "application/json" },
|
|
119
|
+
// `AbortSignal.timeout` everywhere current; omitted rather than polyfilled
|
|
120
|
+
// where it is missing, which only loses the timeout.
|
|
121
|
+
signal: AbortSignal.timeout?.(this.timeoutMs),
|
|
122
|
+
});
|
|
109
123
|
if (!res.ok) {
|
|
110
124
|
let body = "";
|
|
111
125
|
try { body = await res.text(); } catch { /* ignore */ }
|
package/src/write/index.ts
CHANGED
|
@@ -613,7 +613,7 @@ export async function mint(p: MintParams): Promise<TxReceipt> {
|
|
|
613
613
|
return receipt;
|
|
614
614
|
}
|
|
615
615
|
|
|
616
|
-
// --- waitlist deposit (canary — real USDC on the source chain)
|
|
616
|
+
// --- waitlist deposit + withdraw (canary — real USDC on the source chain) ----
|
|
617
617
|
//
|
|
618
618
|
// Canary environments fund accounts with a real USDC deposit on the source
|
|
619
619
|
// chain (Arbitrum One) instead of the faucet: approve the waitlist contract to
|
|
@@ -625,6 +625,7 @@ const ERC20_ABI = parseAbi(["function approve(address spender, uint256 value)"])
|
|
|
625
625
|
|
|
626
626
|
const WAITLIST_ABI = parseAbi([
|
|
627
627
|
"function deposit(address token, uint256 amount, address from, address to, address callContract, uint256 reserveBalance, bytes permit)",
|
|
628
|
+
"function withdraw(uint256 depositId, address token, uint256 amount, address from, address to, address callContract, uint256 reserveBalance)",
|
|
628
629
|
]);
|
|
629
630
|
|
|
630
631
|
/** An unsigned call on the source chain — spread into
|
|
@@ -677,6 +678,46 @@ export function buildWaitlistDeposit(p: WaitlistDepositParams): SourceChainCall
|
|
|
677
678
|
};
|
|
678
679
|
}
|
|
679
680
|
|
|
681
|
+
/** Arguments for {@link buildWaitlistWithdraw}. Every field is required — see the
|
|
682
|
+
* builder for why none of them may be defaulted. */
|
|
683
|
+
export interface WaitlistWithdrawParams {
|
|
684
|
+
/** The waitlist contract on the source chain — the one the deposit went to. */
|
|
685
|
+
waitlist: Address;
|
|
686
|
+
/** The contract's id for the deposit being taken back out. One call per
|
|
687
|
+
* deposit: the waitlist deliberately has no batch withdrawal. */
|
|
688
|
+
depositId: bigint;
|
|
689
|
+
token: Address;
|
|
690
|
+
amount: bigint;
|
|
691
|
+
/** The depositing address — only it may withdraw, so it must also be the
|
|
692
|
+
* sender of this call. */
|
|
693
|
+
from: Address;
|
|
694
|
+
to: Address;
|
|
695
|
+
callContract: Address;
|
|
696
|
+
reserveBalance: bigint;
|
|
697
|
+
}
|
|
698
|
+
|
|
699
|
+
/** Waitlist `withdraw(...)` — takes a confirmed deposit back out on the source
|
|
700
|
+
* chain, undoing a {@link buildWaitlistDeposit}.
|
|
701
|
+
*
|
|
702
|
+
* Unlike the deposit builder, this one defaults nothing, and must not start to.
|
|
703
|
+
* The waitlist keeps only a *hash* of the deposit's argument set and recomputes
|
|
704
|
+
* it here, so an argument that merely looks right — `to` filled in from `from`,
|
|
705
|
+
* the usual `callContract`, a tidied `reserveBalance` — hashes to something else
|
|
706
|
+
* and reverts, and the user pays gas for the failure. The caller reads all seven
|
|
707
|
+
* verbatim from the waitlist API's `/v1/waitlist/me` response and passes them
|
|
708
|
+
* straight through: no fallbacks, no normalising, no lowercasing. */
|
|
709
|
+
export function buildWaitlistWithdraw(p: WaitlistWithdrawParams): SourceChainCall {
|
|
710
|
+
return {
|
|
711
|
+
to: p.waitlist,
|
|
712
|
+
data: encodeFunctionData({
|
|
713
|
+
abi: WAITLIST_ABI,
|
|
714
|
+
functionName: "withdraw",
|
|
715
|
+
args: [p.depositId, p.token, p.amount, p.from, p.to, p.callContract, p.reserveBalance],
|
|
716
|
+
}),
|
|
717
|
+
value: 0n,
|
|
718
|
+
};
|
|
719
|
+
}
|
|
720
|
+
|
|
680
721
|
// --- withdrawals (ADR 0033) --------------------------------------------------
|
|
681
722
|
//
|
|
682
723
|
// `Clob.withdraw` settles on L1 in ONE transaction: the CLOB balance is debited
|