@aboutcircles/sdk-pathfinder 0.1.5 → 0.1.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.js CHANGED
@@ -1,3823 +1,2 @@
1
- // ../utils/dist/index.js
2
- class CirclesConverter {
3
- static ONE_64 = 1n << 64n;
4
- static GAMMA_64 = 18443079296116538654n;
5
- static BETA_64 = 18450409579521241655n;
6
- static SECONDS_PER_DAY = 86400n;
7
- static INFLATION_DAY_ZERO_UNIX = 1602720000n;
8
- static ATTO_FACTOR = 1000000000000000000n;
9
- static FACTOR_1E12 = 1000000000000n;
10
- static V1_ACCURACY = 100000000n;
11
- static V1_INFLATION_PCT_NUM = 107n;
12
- static V1_INFLATION_PCT_DEN = 100n;
13
- static PERIOD_SEC = 31556952n;
14
- static mul64(a, b) {
15
- return a * b >> 64n;
16
- }
17
- static mulU(factor64x64, value) {
18
- return factor64x64 * value >> 64n;
19
- }
20
- static pow64(base64x64, exp) {
21
- let base = base64x64;
22
- let exponent = exp;
23
- let result = this.ONE_64;
24
- while (exponent > 0n) {
25
- if ((exponent & 1n) === 1n) {
26
- result = this.mul64(result, base);
27
- }
28
- base = this.mul64(base, base);
29
- exponent >>= 1n;
30
- }
31
- return result;
32
- }
33
- static ONE_36 = 1000000000000000000000000000000000000000n;
34
- static GAMMA_36 = 999801332008598957430613406568191166n;
35
- static BETA_36 = 1000198707468214629156271489013303962n;
36
- static mul36(a, b) {
37
- return a * b / this.ONE_36;
38
- }
39
- static pow36(base36, exp) {
40
- let result = this.ONE_36;
41
- let base = base36;
42
- let e = exp;
43
- while (e > 0n) {
44
- const isOdd = (e & 1n) === 1n;
45
- if (isOdd) {
46
- result = this.mul36(result, base);
47
- }
48
- base = this.mul36(base, base);
49
- e >>= 1n;
50
- }
51
- return result;
52
- }
53
- static attoCirclesToCircles(atto) {
54
- if (atto === 0n)
55
- return 0;
56
- const whole = atto / this.ATTO_FACTOR;
57
- const frac = atto % this.ATTO_FACTOR;
58
- const MAX_SAFE_INT = BigInt(Number.MAX_SAFE_INTEGER);
59
- if (whole > MAX_SAFE_INT || whole < -MAX_SAFE_INT) {
60
- throw new RangeError("Atto value’s integer component exceeds JS double precision.");
61
- }
62
- return Number(whole) + Number(frac) / Number(this.ATTO_FACTOR);
63
- }
64
- static circlesToAttoCircles(circles) {
65
- return BigInt(Math.trunc(circles * Number(this.ATTO_FACTOR)));
66
- }
67
- static inflationaryToDemurrage(inflationary, day) {
68
- return this.mulU(this.pow64(this.GAMMA_64, day), inflationary);
69
- }
70
- static demurrageToInflationary(demurraged, day) {
71
- return this.mulU(this.pow64(this.BETA_64, day), demurraged);
72
- }
73
- static dayFromTimestamp(unixSeconds) {
74
- return (unixSeconds - this.INFLATION_DAY_ZERO_UNIX) / this.SECONDS_PER_DAY;
75
- }
76
- static attoCirclesToAttoStaticCircles(demurraged, nowUnixSeconds = BigInt(Math.floor(Date.now() / 1000))) {
77
- return this.demurrageToInflationary(demurraged, this.dayFromTimestamp(nowUnixSeconds));
78
- }
79
- static attoStaticCirclesToAttoCircles(staticCircles, nowUnixSeconds = BigInt(Math.floor(Date.now() / 1000))) {
80
- return this.inflationaryToDemurrage(staticCircles, this.dayFromTimestamp(nowUnixSeconds));
81
- }
82
- static inflationaryToDemurrageExact(inflationary, day) {
83
- const factor = this.pow36(this.GAMMA_36, day);
84
- return inflationary * factor / this.ONE_36;
85
- }
86
- static demurrageToInflationaryExact(demurraged, day) {
87
- const factor = this.pow36(this.BETA_36, day);
88
- return demurraged * factor / this.ONE_36;
89
- }
90
- static attoCirclesToAttoStaticCirclesExact(demurraged, nowUnixSeconds = BigInt(Math.floor(Date.now() / 1000))) {
91
- const day = this.dayFromTimestamp(nowUnixSeconds);
92
- return this.demurrageToInflationaryExact(demurraged, day);
93
- }
94
- static attoStaticCirclesToAttoCirclesExact(staticCircles, nowUnixSeconds = BigInt(Math.floor(Date.now() / 1000))) {
95
- const day = this.dayFromTimestamp(nowUnixSeconds);
96
- return this.inflationaryToDemurrageExact(staticCircles, day);
97
- }
98
- static truncateToInt64(wei) {
99
- const truncated = wei / this.FACTOR_1E12;
100
- const MAX_INT64 = 9223372036854775807n;
101
- return truncated > MAX_INT64 ? MAX_INT64 : truncated;
102
- }
103
- static blowUpToBigInt(sixDecimals) {
104
- return sixDecimals * this.FACTOR_1E12;
105
- }
106
- static truncateToSixDecimals(wei) {
107
- return this.blowUpToBigInt(this.truncateToInt64(wei));
108
- }
109
- static v1InflateFactor(periodIdx) {
110
- if (periodIdx === 0n)
111
- return this.V1_ACCURACY;
112
- return this.V1_ACCURACY * this.V1_INFLATION_PCT_NUM ** periodIdx / this.V1_INFLATION_PCT_DEN ** periodIdx;
113
- }
114
- static attoCrcToAttoCircles(v1Amount, blockTimestampUtc) {
115
- const secondsSinceEpoch = blockTimestampUtc - this.INFLATION_DAY_ZERO_UNIX;
116
- const periodIdx = secondsSinceEpoch / this.PERIOD_SEC;
117
- const secondsIntoPeriod = secondsSinceEpoch % this.PERIOD_SEC;
118
- const factorCur = this.v1InflateFactor(periodIdx);
119
- const factorNext = this.v1InflateFactor(periodIdx + 1n);
120
- return this.v1ToDemurrage(v1Amount, factorCur, factorNext, secondsIntoPeriod, this.PERIOD_SEC);
121
- }
122
- static attoCirclesToAttoCrc(demurraged, blockTimestampUtc) {
123
- const secondsSinceEpoch = blockTimestampUtc - this.INFLATION_DAY_ZERO_UNIX;
124
- const periodIdx = secondsSinceEpoch / this.PERIOD_SEC;
125
- const secondsIntoPeriod = secondsSinceEpoch % this.PERIOD_SEC;
126
- const factorCur = this.v1InflateFactor(periodIdx);
127
- const factorNext = this.v1InflateFactor(periodIdx + 1n);
128
- const rP = factorCur * (this.PERIOD_SEC - secondsIntoPeriod) + factorNext * secondsIntoPeriod;
129
- return demurraged * 3n * this.V1_ACCURACY * this.PERIOD_SEC / rP;
130
- }
131
- static v1ToDemurrage(v1Amount, factorCur, factorNext, secondsInto, periodSec) {
132
- const rP = factorCur * (periodSec - secondsInto) + factorNext * secondsInto;
133
- return v1Amount * 3n * this.V1_ACCURACY * periodSec / rP;
134
- }
135
- }
136
- var byteToHex = [];
137
- for (let i = 0;i < 256; i++) {
138
- byteToHex[i] = i.toString(16).padStart(2, "0");
139
- }
140
- function bytesToHex(bytes) {
141
- let hex = "0x";
142
- for (let i = 0;i < bytes.length; i++) {
143
- hex += byteToHex[bytes[i]];
144
- }
145
- return hex;
146
- }
147
- var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
148
- var _32n = /* @__PURE__ */ BigInt(32);
149
- function fromBig(n, le = false) {
150
- if (le)
151
- return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
152
- return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
153
- }
154
- function split(lst, le = false) {
155
- const len = lst.length;
156
- let Ah = new Uint32Array(len);
157
- let Al = new Uint32Array(len);
158
- for (let i = 0;i < len; i++) {
159
- const { h, l } = fromBig(lst[i], le);
160
- [Ah[i], Al[i]] = [h, l];
161
- }
162
- return [Ah, Al];
163
- }
164
- /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
165
- var _0n = BigInt(0);
166
- var _1n = BigInt(1);
167
- var _2n = BigInt(2);
168
- var _7n = BigInt(7);
169
- var _256n = BigInt(256);
170
- var _0x71n = BigInt(113);
171
- var SHA3_PI = [];
172
- var SHA3_ROTL = [];
173
- var _SHA3_IOTA = [];
174
- for (let round = 0, R = _1n, x = 1, y = 0;round < 24; round++) {
175
- [x, y] = [y, (2 * x + 3 * y) % 5];
176
- SHA3_PI.push(2 * (5 * y + x));
177
- SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
178
- let t = _0n;
179
- for (let j = 0;j < 7; j++) {
180
- R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
181
- if (R & _2n)
182
- t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
183
- }
184
- _SHA3_IOTA.push(t);
185
- }
186
- var IOTAS = split(_SHA3_IOTA, true);
187
- var SHA3_IOTA_H = IOTAS[0];
188
- var SHA3_IOTA_L = IOTAS[1];
189
- var empty = new Uint8Array(0);
190
- function equals(aa, bb) {
191
- if (aa === bb) {
192
- return true;
193
- }
194
- if (aa.byteLength !== bb.byteLength) {
195
- return false;
196
- }
197
- for (let ii = 0;ii < aa.byteLength; ii++) {
198
- if (aa[ii] !== bb[ii]) {
199
- return false;
200
- }
201
- }
202
- return true;
203
- }
204
- function coerce(o) {
205
- if (o instanceof Uint8Array && o.constructor.name === "Uint8Array") {
206
- return o;
207
- }
208
- if (o instanceof ArrayBuffer) {
209
- return new Uint8Array(o);
210
- }
211
- if (ArrayBuffer.isView(o)) {
212
- return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
213
- }
214
- throw new Error("Unknown type, must be binary type");
215
- }
216
- function base(ALPHABET, name) {
217
- if (ALPHABET.length >= 255) {
218
- throw new TypeError("Alphabet too long");
219
- }
220
- var BASE_MAP = new Uint8Array(256);
221
- for (var j = 0;j < BASE_MAP.length; j++) {
222
- BASE_MAP[j] = 255;
223
- }
224
- for (var i = 0;i < ALPHABET.length; i++) {
225
- var x = ALPHABET.charAt(i);
226
- var xc = x.charCodeAt(0);
227
- if (BASE_MAP[xc] !== 255) {
228
- throw new TypeError(x + " is ambiguous");
229
- }
230
- BASE_MAP[xc] = i;
231
- }
232
- var BASE = ALPHABET.length;
233
- var LEADER = ALPHABET.charAt(0);
234
- var FACTOR = Math.log(BASE) / Math.log(256);
235
- var iFACTOR = Math.log(256) / Math.log(BASE);
236
- function encode(source) {
237
- if (source instanceof Uint8Array)
238
- ;
239
- else if (ArrayBuffer.isView(source)) {
240
- source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
241
- } else if (Array.isArray(source)) {
242
- source = Uint8Array.from(source);
243
- }
244
- if (!(source instanceof Uint8Array)) {
245
- throw new TypeError("Expected Uint8Array");
246
- }
247
- if (source.length === 0) {
248
- return "";
249
- }
250
- var zeroes = 0;
251
- var length = 0;
252
- var pbegin = 0;
253
- var pend = source.length;
254
- while (pbegin !== pend && source[pbegin] === 0) {
255
- pbegin++;
256
- zeroes++;
257
- }
258
- var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
259
- var b58 = new Uint8Array(size);
260
- while (pbegin !== pend) {
261
- var carry = source[pbegin];
262
- var i2 = 0;
263
- for (var it1 = size - 1;(carry !== 0 || i2 < length) && it1 !== -1; it1--, i2++) {
264
- carry += 256 * b58[it1] >>> 0;
265
- b58[it1] = carry % BASE >>> 0;
266
- carry = carry / BASE >>> 0;
267
- }
268
- if (carry !== 0) {
269
- throw new Error("Non-zero carry");
270
- }
271
- length = i2;
272
- pbegin++;
273
- }
274
- var it2 = size - length;
275
- while (it2 !== size && b58[it2] === 0) {
276
- it2++;
277
- }
278
- var str = LEADER.repeat(zeroes);
279
- for (;it2 < size; ++it2) {
280
- str += ALPHABET.charAt(b58[it2]);
281
- }
282
- return str;
283
- }
284
- function decodeUnsafe(source) {
285
- if (typeof source !== "string") {
286
- throw new TypeError("Expected String");
287
- }
288
- if (source.length === 0) {
289
- return new Uint8Array;
290
- }
291
- var psz = 0;
292
- if (source[psz] === " ") {
293
- return;
294
- }
295
- var zeroes = 0;
296
- var length = 0;
297
- while (source[psz] === LEADER) {
298
- zeroes++;
299
- psz++;
300
- }
301
- var size = (source.length - psz) * FACTOR + 1 >>> 0;
302
- var b256 = new Uint8Array(size);
303
- while (source[psz]) {
304
- var carry = BASE_MAP[source.charCodeAt(psz)];
305
- if (carry === 255) {
306
- return;
307
- }
308
- var i2 = 0;
309
- for (var it3 = size - 1;(carry !== 0 || i2 < length) && it3 !== -1; it3--, i2++) {
310
- carry += BASE * b256[it3] >>> 0;
311
- b256[it3] = carry % 256 >>> 0;
312
- carry = carry / 256 >>> 0;
313
- }
314
- if (carry !== 0) {
315
- throw new Error("Non-zero carry");
316
- }
317
- length = i2;
318
- psz++;
319
- }
320
- if (source[psz] === " ") {
321
- return;
322
- }
323
- var it4 = size - length;
324
- while (it4 !== size && b256[it4] === 0) {
325
- it4++;
326
- }
327
- var vch = new Uint8Array(zeroes + (size - it4));
328
- var j2 = zeroes;
329
- while (it4 !== size) {
330
- vch[j2++] = b256[it4++];
331
- }
332
- return vch;
333
- }
334
- function decode(string) {
335
- var buffer = decodeUnsafe(string);
336
- if (buffer) {
337
- return buffer;
338
- }
339
- throw new Error(`Non-${name} character`);
340
- }
341
- return {
342
- encode,
343
- decodeUnsafe,
344
- decode
345
- };
346
- }
347
- var src = base;
348
- var _brrp__multiformats_scope_baseX = src;
349
- var base_x_default = _brrp__multiformats_scope_baseX;
350
-
351
- class Encoder {
352
- name;
353
- prefix;
354
- baseEncode;
355
- constructor(name, prefix, baseEncode) {
356
- this.name = name;
357
- this.prefix = prefix;
358
- this.baseEncode = baseEncode;
359
- }
360
- encode(bytes) {
361
- if (bytes instanceof Uint8Array) {
362
- return `${this.prefix}${this.baseEncode(bytes)}`;
363
- } else {
364
- throw Error("Unknown type, must be binary type");
365
- }
366
- }
367
- }
368
-
369
- class Decoder {
370
- name;
371
- prefix;
372
- baseDecode;
373
- prefixCodePoint;
374
- constructor(name, prefix, baseDecode) {
375
- this.name = name;
376
- this.prefix = prefix;
377
- const prefixCodePoint = prefix.codePointAt(0);
378
- if (prefixCodePoint === undefined) {
379
- throw new Error("Invalid prefix character");
380
- }
381
- this.prefixCodePoint = prefixCodePoint;
382
- this.baseDecode = baseDecode;
383
- }
384
- decode(text) {
385
- if (typeof text === "string") {
386
- if (text.codePointAt(0) !== this.prefixCodePoint) {
387
- throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
388
- }
389
- return this.baseDecode(text.slice(this.prefix.length));
390
- } else {
391
- throw Error("Can only multibase decode strings");
392
- }
393
- }
394
- or(decoder) {
395
- return or(this, decoder);
396
- }
397
- }
398
-
399
- class ComposedDecoder {
400
- decoders;
401
- constructor(decoders) {
402
- this.decoders = decoders;
403
- }
404
- or(decoder) {
405
- return or(this, decoder);
406
- }
407
- decode(input) {
408
- const prefix = input[0];
409
- const decoder = this.decoders[prefix];
410
- if (decoder != null) {
411
- return decoder.decode(input);
412
- } else {
413
- throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
414
- }
415
- }
416
- }
417
- function or(left, right) {
418
- return new ComposedDecoder({
419
- ...left.decoders ?? { [left.prefix]: left },
420
- ...right.decoders ?? { [right.prefix]: right }
421
- });
422
- }
423
-
424
- class Codec {
425
- name;
426
- prefix;
427
- baseEncode;
428
- baseDecode;
429
- encoder;
430
- decoder;
431
- constructor(name, prefix, baseEncode, baseDecode) {
432
- this.name = name;
433
- this.prefix = prefix;
434
- this.baseEncode = baseEncode;
435
- this.baseDecode = baseDecode;
436
- this.encoder = new Encoder(name, prefix, baseEncode);
437
- this.decoder = new Decoder(name, prefix, baseDecode);
438
- }
439
- encode(input) {
440
- return this.encoder.encode(input);
441
- }
442
- decode(input) {
443
- return this.decoder.decode(input);
444
- }
445
- }
446
- function from({ name, prefix, encode, decode }) {
447
- return new Codec(name, prefix, encode, decode);
448
- }
449
- function baseX({ name, prefix, alphabet }) {
450
- const { encode, decode } = base_x_default(alphabet, name);
451
- return from({
452
- prefix,
453
- name,
454
- encode,
455
- decode: (text) => coerce(decode(text))
456
- });
457
- }
458
- function decode(string, alphabetIdx, bitsPerChar, name) {
459
- let end = string.length;
460
- while (string[end - 1] === "=") {
461
- --end;
462
- }
463
- const out = new Uint8Array(end * bitsPerChar / 8 | 0);
464
- let bits = 0;
465
- let buffer = 0;
466
- let written = 0;
467
- for (let i = 0;i < end; ++i) {
468
- const value = alphabetIdx[string[i]];
469
- if (value === undefined) {
470
- throw new SyntaxError(`Non-${name} character`);
471
- }
472
- buffer = buffer << bitsPerChar | value;
473
- bits += bitsPerChar;
474
- if (bits >= 8) {
475
- bits -= 8;
476
- out[written++] = 255 & buffer >> bits;
477
- }
478
- }
479
- if (bits >= bitsPerChar || (255 & buffer << 8 - bits) !== 0) {
480
- throw new SyntaxError("Unexpected end of data");
481
- }
482
- return out;
483
- }
484
- function encode(data, alphabet, bitsPerChar) {
485
- const pad = alphabet[alphabet.length - 1] === "=";
486
- const mask = (1 << bitsPerChar) - 1;
487
- let out = "";
488
- let bits = 0;
489
- let buffer = 0;
490
- for (let i = 0;i < data.length; ++i) {
491
- buffer = buffer << 8 | data[i];
492
- bits += 8;
493
- while (bits > bitsPerChar) {
494
- bits -= bitsPerChar;
495
- out += alphabet[mask & buffer >> bits];
496
- }
497
- }
498
- if (bits !== 0) {
499
- out += alphabet[mask & buffer << bitsPerChar - bits];
500
- }
501
- if (pad) {
502
- while ((out.length * bitsPerChar & 7) !== 0) {
503
- out += "=";
504
- }
505
- }
506
- return out;
507
- }
508
- function createAlphabetIdx(alphabet) {
509
- const alphabetIdx = {};
510
- for (let i = 0;i < alphabet.length; ++i) {
511
- alphabetIdx[alphabet[i]] = i;
512
- }
513
- return alphabetIdx;
514
- }
515
- function rfc4648({ name, prefix, bitsPerChar, alphabet }) {
516
- const alphabetIdx = createAlphabetIdx(alphabet);
517
- return from({
518
- prefix,
519
- name,
520
- encode(input) {
521
- return encode(input, alphabet, bitsPerChar);
522
- },
523
- decode(input) {
524
- return decode(input, alphabetIdx, bitsPerChar, name);
525
- }
526
- });
527
- }
528
- var base32 = rfc4648({
529
- prefix: "b",
530
- name: "base32",
531
- alphabet: "abcdefghijklmnopqrstuvwxyz234567",
532
- bitsPerChar: 5
533
- });
534
- var base32upper = rfc4648({
535
- prefix: "B",
536
- name: "base32upper",
537
- alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
538
- bitsPerChar: 5
539
- });
540
- var base32pad = rfc4648({
541
- prefix: "c",
542
- name: "base32pad",
543
- alphabet: "abcdefghijklmnopqrstuvwxyz234567=",
544
- bitsPerChar: 5
545
- });
546
- var base32padupper = rfc4648({
547
- prefix: "C",
548
- name: "base32padupper",
549
- alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=",
550
- bitsPerChar: 5
551
- });
552
- var base32hex = rfc4648({
553
- prefix: "v",
554
- name: "base32hex",
555
- alphabet: "0123456789abcdefghijklmnopqrstuv",
556
- bitsPerChar: 5
557
- });
558
- var base32hexupper = rfc4648({
559
- prefix: "V",
560
- name: "base32hexupper",
561
- alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV",
562
- bitsPerChar: 5
563
- });
564
- var base32hexpad = rfc4648({
565
- prefix: "t",
566
- name: "base32hexpad",
567
- alphabet: "0123456789abcdefghijklmnopqrstuv=",
568
- bitsPerChar: 5
569
- });
570
- var base32hexpadupper = rfc4648({
571
- prefix: "T",
572
- name: "base32hexpadupper",
573
- alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV=",
574
- bitsPerChar: 5
575
- });
576
- var base32z = rfc4648({
577
- prefix: "h",
578
- name: "base32z",
579
- alphabet: "ybndrfg8ejkmcpqxot1uwisza345h769",
580
- bitsPerChar: 5
581
- });
582
- var base36 = baseX({
583
- prefix: "k",
584
- name: "base36",
585
- alphabet: "0123456789abcdefghijklmnopqrstuvwxyz"
586
- });
587
- var base36upper = baseX({
588
- prefix: "K",
589
- name: "base36upper",
590
- alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
591
- });
592
- var base58btc = baseX({
593
- name: "base58btc",
594
- prefix: "z",
595
- alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
596
- });
597
- var base58flickr = baseX({
598
- name: "base58flickr",
599
- prefix: "Z",
600
- alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
601
- });
602
- var encode_1 = encode2;
603
- var MSB = 128;
604
- var REST = 127;
605
- var MSBALL = ~REST;
606
- var INT = Math.pow(2, 31);
607
- function encode2(num, out, offset) {
608
- out = out || [];
609
- offset = offset || 0;
610
- var oldOffset = offset;
611
- while (num >= INT) {
612
- out[offset++] = num & 255 | MSB;
613
- num /= 128;
614
- }
615
- while (num & MSBALL) {
616
- out[offset++] = num & 255 | MSB;
617
- num >>>= 7;
618
- }
619
- out[offset] = num | 0;
620
- encode2.bytes = offset - oldOffset + 1;
621
- return out;
622
- }
623
- var decode2 = read;
624
- var MSB$1 = 128;
625
- var REST$1 = 127;
626
- function read(buf, offset) {
627
- var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
628
- do {
629
- if (counter >= l) {
630
- read.bytes = 0;
631
- throw new RangeError("Could not decode varint");
632
- }
633
- b = buf[counter++];
634
- res += shift < 28 ? (b & REST$1) << shift : (b & REST$1) * Math.pow(2, shift);
635
- shift += 7;
636
- } while (b >= MSB$1);
637
- read.bytes = counter - offset;
638
- return res;
639
- }
640
- var N1 = Math.pow(2, 7);
641
- var N2 = Math.pow(2, 14);
642
- var N3 = Math.pow(2, 21);
643
- var N4 = Math.pow(2, 28);
644
- var N5 = Math.pow(2, 35);
645
- var N6 = Math.pow(2, 42);
646
- var N7 = Math.pow(2, 49);
647
- var N8 = Math.pow(2, 56);
648
- var N9 = Math.pow(2, 63);
649
- var length = function(value) {
650
- return value < N1 ? 1 : value < N2 ? 2 : value < N3 ? 3 : value < N4 ? 4 : value < N5 ? 5 : value < N6 ? 6 : value < N7 ? 7 : value < N8 ? 8 : value < N9 ? 9 : 10;
651
- };
652
- var varint = {
653
- encode: encode_1,
654
- decode: decode2,
655
- encodingLength: length
656
- };
657
- var _brrp_varint = varint;
658
- var varint_default = _brrp_varint;
659
- function decode3(data, offset = 0) {
660
- const code = varint_default.decode(data, offset);
661
- return [code, varint_default.decode.bytes];
662
- }
663
- function encodeTo(int, target, offset = 0) {
664
- varint_default.encode(int, target, offset);
665
- return target;
666
- }
667
- function encodingLength(int) {
668
- return varint_default.encodingLength(int);
669
- }
670
- function create(code, digest) {
671
- const size = digest.byteLength;
672
- const sizeOffset = encodingLength(code);
673
- const digestOffset = sizeOffset + encodingLength(size);
674
- const bytes = new Uint8Array(digestOffset + size);
675
- encodeTo(code, bytes, 0);
676
- encodeTo(size, bytes, sizeOffset);
677
- bytes.set(digest, digestOffset);
678
- return new Digest(code, size, digest, bytes);
679
- }
680
- function decode4(multihash) {
681
- const bytes = coerce(multihash);
682
- const [code, sizeOffset] = decode3(bytes);
683
- const [size, digestOffset] = decode3(bytes.subarray(sizeOffset));
684
- const digest = bytes.subarray(sizeOffset + digestOffset);
685
- if (digest.byteLength !== size) {
686
- throw new Error("Incorrect length");
687
- }
688
- return new Digest(code, size, digest, bytes);
689
- }
690
- function equals2(a, b) {
691
- if (a === b) {
692
- return true;
693
- } else {
694
- const data = b;
695
- return a.code === data.code && a.size === data.size && data.bytes instanceof Uint8Array && equals(a.bytes, data.bytes);
696
- }
697
- }
698
-
699
- class Digest {
700
- code;
701
- size;
702
- digest;
703
- bytes;
704
- constructor(code, size, digest, bytes) {
705
- this.code = code;
706
- this.size = size;
707
- this.digest = digest;
708
- this.bytes = bytes;
709
- }
710
- }
711
- function format(link, base2) {
712
- const { bytes, version } = link;
713
- switch (version) {
714
- case 0:
715
- return toStringV0(bytes, baseCache(link), base2 ?? base58btc.encoder);
716
- default:
717
- return toStringV1(bytes, baseCache(link), base2 ?? base32.encoder);
718
- }
719
- }
720
- var cache = new WeakMap;
721
- function baseCache(cid) {
722
- const baseCache2 = cache.get(cid);
723
- if (baseCache2 == null) {
724
- const baseCache3 = new Map;
725
- cache.set(cid, baseCache3);
726
- return baseCache3;
727
- }
728
- return baseCache2;
729
- }
730
-
731
- class CID {
732
- code;
733
- version;
734
- multihash;
735
- bytes;
736
- "/";
737
- constructor(version, code, multihash, bytes) {
738
- this.code = code;
739
- this.version = version;
740
- this.multihash = multihash;
741
- this.bytes = bytes;
742
- this["/"] = bytes;
743
- }
744
- get asCID() {
745
- return this;
746
- }
747
- get byteOffset() {
748
- return this.bytes.byteOffset;
749
- }
750
- get byteLength() {
751
- return this.bytes.byteLength;
752
- }
753
- toV0() {
754
- switch (this.version) {
755
- case 0: {
756
- return this;
757
- }
758
- case 1: {
759
- const { code, multihash } = this;
760
- if (code !== DAG_PB_CODE) {
761
- throw new Error("Cannot convert a non dag-pb CID to CIDv0");
762
- }
763
- if (multihash.code !== SHA_256_CODE) {
764
- throw new Error("Cannot convert non sha2-256 multihash CID to CIDv0");
765
- }
766
- return CID.createV0(multihash);
767
- }
768
- default: {
769
- throw Error(`Can not convert CID version ${this.version} to version 0. This is a bug please report`);
770
- }
771
- }
772
- }
773
- toV1() {
774
- switch (this.version) {
775
- case 0: {
776
- const { code, digest } = this.multihash;
777
- const multihash = create(code, digest);
778
- return CID.createV1(this.code, multihash);
779
- }
780
- case 1: {
781
- return this;
782
- }
783
- default: {
784
- throw Error(`Can not convert CID version ${this.version} to version 1. This is a bug please report`);
785
- }
786
- }
787
- }
788
- equals(other) {
789
- return CID.equals(this, other);
790
- }
791
- static equals(self, other) {
792
- const unknown = other;
793
- return unknown != null && self.code === unknown.code && self.version === unknown.version && equals2(self.multihash, unknown.multihash);
794
- }
795
- toString(base2) {
796
- return format(this, base2);
797
- }
798
- toJSON() {
799
- return { "/": format(this) };
800
- }
801
- link() {
802
- return this;
803
- }
804
- [Symbol.toStringTag] = "CID";
805
- [Symbol.for("nodejs.util.inspect.custom")]() {
806
- return `CID(${this.toString()})`;
807
- }
808
- static asCID(input) {
809
- if (input == null) {
810
- return null;
811
- }
812
- const value = input;
813
- if (value instanceof CID) {
814
- return value;
815
- } else if (value["/"] != null && value["/"] === value.bytes || value.asCID === value) {
816
- const { version, code, multihash, bytes } = value;
817
- return new CID(version, code, multihash, bytes ?? encodeCID(version, code, multihash.bytes));
818
- } else if (value[cidSymbol] === true) {
819
- const { version, multihash, code } = value;
820
- const digest = decode4(multihash);
821
- return CID.create(version, code, digest);
822
- } else {
823
- return null;
824
- }
825
- }
826
- static create(version, code, digest) {
827
- if (typeof code !== "number") {
828
- throw new Error("String codecs are no longer supported");
829
- }
830
- if (!(digest.bytes instanceof Uint8Array)) {
831
- throw new Error("Invalid digest");
832
- }
833
- switch (version) {
834
- case 0: {
835
- if (code !== DAG_PB_CODE) {
836
- throw new Error(`Version 0 CID must use dag-pb (code: ${DAG_PB_CODE}) block encoding`);
837
- } else {
838
- return new CID(version, code, digest, digest.bytes);
839
- }
840
- }
841
- case 1: {
842
- const bytes = encodeCID(version, code, digest.bytes);
843
- return new CID(version, code, digest, bytes);
844
- }
845
- default: {
846
- throw new Error("Invalid version");
847
- }
848
- }
849
- }
850
- static createV0(digest) {
851
- return CID.create(0, DAG_PB_CODE, digest);
852
- }
853
- static createV1(code, digest) {
854
- return CID.create(1, code, digest);
855
- }
856
- static decode(bytes) {
857
- const [cid, remainder] = CID.decodeFirst(bytes);
858
- if (remainder.length !== 0) {
859
- throw new Error("Incorrect length");
860
- }
861
- return cid;
862
- }
863
- static decodeFirst(bytes) {
864
- const specs = CID.inspectBytes(bytes);
865
- const prefixSize = specs.size - specs.multihashSize;
866
- const multihashBytes = coerce(bytes.subarray(prefixSize, prefixSize + specs.multihashSize));
867
- if (multihashBytes.byteLength !== specs.multihashSize) {
868
- throw new Error("Incorrect length");
869
- }
870
- const digestBytes = multihashBytes.subarray(specs.multihashSize - specs.digestSize);
871
- const digest = new Digest(specs.multihashCode, specs.digestSize, digestBytes, multihashBytes);
872
- const cid = specs.version === 0 ? CID.createV0(digest) : CID.createV1(specs.codec, digest);
873
- return [cid, bytes.subarray(specs.size)];
874
- }
875
- static inspectBytes(initialBytes) {
876
- let offset = 0;
877
- const next = () => {
878
- const [i, length2] = decode3(initialBytes.subarray(offset));
879
- offset += length2;
880
- return i;
881
- };
882
- let version = next();
883
- let codec = DAG_PB_CODE;
884
- if (version === 18) {
885
- version = 0;
886
- offset = 0;
887
- } else {
888
- codec = next();
889
- }
890
- if (version !== 0 && version !== 1) {
891
- throw new RangeError(`Invalid CID version ${version}`);
892
- }
893
- const prefixSize = offset;
894
- const multihashCode = next();
895
- const digestSize = next();
896
- const size = offset + digestSize;
897
- const multihashSize = size - prefixSize;
898
- return { version, codec, multihashCode, digestSize, multihashSize, size };
899
- }
900
- static parse(source, base2) {
901
- const [prefix, bytes] = parseCIDtoBytes(source, base2);
902
- const cid = CID.decode(bytes);
903
- if (cid.version === 0 && source[0] !== "Q") {
904
- throw Error("Version 0 CID string must not include multibase prefix");
905
- }
906
- baseCache(cid).set(prefix, source);
907
- return cid;
908
- }
909
- }
910
- function parseCIDtoBytes(source, base2) {
911
- switch (source[0]) {
912
- case "Q": {
913
- const decoder = base2 ?? base58btc;
914
- return [
915
- base58btc.prefix,
916
- decoder.decode(`${base58btc.prefix}${source}`)
917
- ];
918
- }
919
- case base58btc.prefix: {
920
- const decoder = base2 ?? base58btc;
921
- return [base58btc.prefix, decoder.decode(source)];
922
- }
923
- case base32.prefix: {
924
- const decoder = base2 ?? base32;
925
- return [base32.prefix, decoder.decode(source)];
926
- }
927
- case base36.prefix: {
928
- const decoder = base2 ?? base36;
929
- return [base36.prefix, decoder.decode(source)];
930
- }
931
- default: {
932
- if (base2 == null) {
933
- throw Error("To parse non base32, base36 or base58btc encoded CID multibase decoder must be provided");
934
- }
935
- return [source[0], base2.decode(source)];
936
- }
937
- }
938
- }
939
- function toStringV0(bytes, cache2, base2) {
940
- const { prefix } = base2;
941
- if (prefix !== base58btc.prefix) {
942
- throw Error(`Cannot string encode V0 in ${base2.name} encoding`);
943
- }
944
- const cid = cache2.get(prefix);
945
- if (cid == null) {
946
- const cid2 = base2.encode(bytes).slice(1);
947
- cache2.set(prefix, cid2);
948
- return cid2;
949
- } else {
950
- return cid;
951
- }
952
- }
953
- function toStringV1(bytes, cache2, base2) {
954
- const { prefix } = base2;
955
- const cid = cache2.get(prefix);
956
- if (cid == null) {
957
- const cid2 = base2.encode(bytes);
958
- cache2.set(prefix, cid2);
959
- return cid2;
960
- } else {
961
- return cid;
962
- }
963
- }
964
- var DAG_PB_CODE = 112;
965
- var SHA_256_CODE = 18;
966
- function encodeCID(version, code, multihash) {
967
- const codeOffset = encodingLength(version);
968
- const hashOffset = codeOffset + encodingLength(code);
969
- const bytes = new Uint8Array(hashOffset + multihash.byteLength);
970
- encodeTo(version, bytes, 0);
971
- encodeTo(code, bytes, codeOffset);
972
- bytes.set(multihash, hashOffset);
973
- return bytes;
974
- }
975
- var cidSymbol = Symbol.for("@ipld/js-cid/CID");
976
-
977
- // src/packing.ts
978
- function packCoordinates(coords) {
979
- const bytes = new Uint8Array(coords.length * 2);
980
- coords.forEach((c, i) => {
981
- const hi = c >> 8;
982
- const lo = c & 255;
983
- const offset = 2 * i;
984
- bytes[offset] = hi;
985
- bytes[offset + 1] = lo;
986
- });
987
- return bytesToHex(bytes);
988
- }
989
- function transformToFlowVertices(transfers, from2, to) {
990
- const set = new Set([from2.toLowerCase(), to.toLowerCase()]);
991
- transfers.forEach((t) => {
992
- set.add(t.from.toLowerCase());
993
- set.add(t.to.toLowerCase());
994
- set.add(t.tokenOwner.toLowerCase());
995
- });
996
- const sorted = [...set].sort((a, b) => {
997
- const lhs = BigInt(a);
998
- const rhs = BigInt(b);
999
- const isLess = lhs < rhs;
1000
- const isGreater = lhs > rhs;
1001
- return isLess ? -1 : isGreater ? 1 : 0;
1002
- });
1003
- const idx = {};
1004
- sorted.forEach((addr, i) => {
1005
- idx[addr] = i;
1006
- });
1007
- return { sorted, idx };
1008
- }
1009
-
1010
- // src/flowMatrix.ts
1011
- function createFlowMatrix(from2, to, value, transfers) {
1012
- const sender = from2.toLowerCase();
1013
- const receiver = to.toLowerCase();
1014
- const { sorted: flowVertices, idx } = transformToFlowVertices(transfers, sender, receiver);
1015
- const flowEdges = transfers.map((t) => {
1016
- const isTerminal = t.to.toLowerCase() === receiver;
1017
- return {
1018
- streamSinkId: isTerminal ? 1 : 0,
1019
- amount: t.value
1020
- };
1021
- });
1022
- const hasTerminalEdge = flowEdges.some((e) => e.streamSinkId === 1);
1023
- if (!hasTerminalEdge) {
1024
- const lastEdgeIndex = transfers.map((t) => t.to.toLowerCase()).lastIndexOf(receiver);
1025
- const fallbackIndex = lastEdgeIndex === -1 ? flowEdges.length - 1 : lastEdgeIndex;
1026
- flowEdges[fallbackIndex].streamSinkId = 1;
1027
- }
1028
- const termEdgeIds = flowEdges.map((e, i) => e.streamSinkId === 1 ? i : -1).filter((i) => i !== -1);
1029
- const streams = [
1030
- {
1031
- sourceCoordinate: idx[sender],
1032
- flowEdgeIds: termEdgeIds,
1033
- data: new Uint8Array(0)
1034
- }
1035
- ];
1036
- const coords = [];
1037
- transfers.forEach((t) => {
1038
- coords.push(idx[t.tokenOwner.toLowerCase()]);
1039
- coords.push(idx[t.from.toLowerCase()]);
1040
- coords.push(idx[t.to.toLowerCase()]);
1041
- });
1042
- const packedCoordinates = packCoordinates(coords);
1043
- const expected = BigInt(value);
1044
- const terminalSum = flowEdges.filter((e) => e.streamSinkId === 1).reduce((sum, e) => sum + BigInt(e.amount.toString()), BigInt(0));
1045
- const isBalanced = terminalSum === expected;
1046
- if (!isBalanced) {
1047
- throw new Error(`Terminal sum ${terminalSum} does not equal expected ${expected}`);
1048
- }
1049
- return {
1050
- flowVertices,
1051
- flowEdges,
1052
- streams,
1053
- packedCoordinates,
1054
- sourceCoordinate: idx[sender]
1055
- };
1056
- }
1057
- // ../rpc/dist/index.js
1058
- var hexToBigInt = (hex) => BigInt(hex);
1059
- var hexToNumber = (hex) => parseInt(hex, 16);
1060
- var hexToUint8Array = (hex) => {
1061
- if (hex.startsWith("0x")) {
1062
- hex = hex.slice(2);
1063
- }
1064
- if (hex.length % 2 !== 0) {
1065
- throw new Error("Invalid hex string");
1066
- }
1067
- const array = new Uint8Array(hex.length / 2);
1068
- for (let i = 0;i < hex.length; i += 2) {
1069
- array[i / 2] = parseInt(hex.substr(i, 2), 16);
1070
- }
1071
- return array;
1072
- };
1073
- function parseValue(key, value) {
1074
- if (typeof value === "string" && value.startsWith("0x")) {
1075
- const hex = value.slice(2);
1076
- if (hex.length === 40) {
1077
- return value;
1078
- }
1079
- if (hex.length === 64) {
1080
- if (key.toLowerCase().includes("digest") || key.toLowerCase().includes("data") || key.toLowerCase().includes("bytes")) {
1081
- return hexToUint8Array(value);
1082
- }
1083
- try {
1084
- return hexToBigInt(value);
1085
- } catch {
1086
- return value;
1087
- }
1088
- }
1089
- try {
1090
- const num = hexToNumber(value);
1091
- if (num < Number.MAX_SAFE_INTEGER) {
1092
- return num;
1093
- }
1094
- return hexToBigInt(value);
1095
- } catch {
1096
- return value;
1097
- }
1098
- }
1099
- if (value === "true")
1100
- return true;
1101
- if (value === "false")
1102
- return false;
1103
- return value;
1104
- }
1105
- function parseRpcEvent(rpcEvent) {
1106
- const { event, values } = rpcEvent;
1107
- const circlesEvent = {
1108
- $event: event,
1109
- blockNumber: values.blockNumber ? hexToNumber(values.blockNumber) : 0,
1110
- timestamp: values.timestamp ? hexToNumber(values.timestamp) : undefined,
1111
- transactionIndex: values.transactionIndex ? hexToNumber(values.transactionIndex) : 0,
1112
- logIndex: values.logIndex ? hexToNumber(values.logIndex) : 0,
1113
- transactionHash: values.transactionHash
1114
- };
1115
- for (const [key, value] of Object.entries(values)) {
1116
- if (["blockNumber", "timestamp", "transactionIndex", "logIndex", "transactionHash"].includes(key)) {
1117
- continue;
1118
- }
1119
- circlesEvent[key] = parseValue(key, value);
1120
- }
1121
- return circlesEvent;
1122
- }
1123
- function parseRpcSubscriptionMessage(message) {
1124
- return message.map(parseRpcEvent);
1125
- }
1126
-
1127
- class Observable {
1128
- _subscribers = [];
1129
- subscribe(subscriber) {
1130
- this._subscribers.push(subscriber);
1131
- return () => {
1132
- const index = this._subscribers.indexOf(subscriber);
1133
- if (index > -1) {
1134
- this._subscribers.splice(index, 1);
1135
- }
1136
- };
1137
- }
1138
- constructor() {
1139
- this._subscribers = [];
1140
- }
1141
- emit(value) {
1142
- this._subscribers.forEach((sub) => sub(value));
1143
- }
1144
- static create() {
1145
- const observable = new Observable;
1146
- return {
1147
- property: observable,
1148
- emit: (e) => observable.emit(e)
1149
- };
1150
- }
1151
- }
1152
-
1153
- class CirclesConverter2 {
1154
- static ONE_64 = 1n << 64n;
1155
- static GAMMA_64 = 18443079296116538654n;
1156
- static BETA_64 = 18450409579521241655n;
1157
- static SECONDS_PER_DAY = 86400n;
1158
- static INFLATION_DAY_ZERO_UNIX = 1602720000n;
1159
- static ATTO_FACTOR = 1000000000000000000n;
1160
- static FACTOR_1E12 = 1000000000000n;
1161
- static V1_ACCURACY = 100000000n;
1162
- static V1_INFLATION_PCT_NUM = 107n;
1163
- static V1_INFLATION_PCT_DEN = 100n;
1164
- static PERIOD_SEC = 31556952n;
1165
- static mul64(a, b) {
1166
- return a * b >> 64n;
1167
- }
1168
- static mulU(factor64x64, value) {
1169
- return factor64x64 * value >> 64n;
1170
- }
1171
- static pow64(base64x64, exp) {
1172
- let base2 = base64x64;
1173
- let exponent = exp;
1174
- let result = this.ONE_64;
1175
- while (exponent > 0n) {
1176
- if ((exponent & 1n) === 1n) {
1177
- result = this.mul64(result, base2);
1178
- }
1179
- base2 = this.mul64(base2, base2);
1180
- exponent >>= 1n;
1181
- }
1182
- return result;
1183
- }
1184
- static ONE_36 = 1000000000000000000000000000000000000000n;
1185
- static GAMMA_36 = 999801332008598957430613406568191166n;
1186
- static BETA_36 = 1000198707468214629156271489013303962n;
1187
- static mul36(a, b) {
1188
- return a * b / this.ONE_36;
1189
- }
1190
- static pow36(base362, exp) {
1191
- let result = this.ONE_36;
1192
- let base2 = base362;
1193
- let e = exp;
1194
- while (e > 0n) {
1195
- const isOdd = (e & 1n) === 1n;
1196
- if (isOdd) {
1197
- result = this.mul36(result, base2);
1198
- }
1199
- base2 = this.mul36(base2, base2);
1200
- e >>= 1n;
1201
- }
1202
- return result;
1203
- }
1204
- static attoCirclesToCircles(atto) {
1205
- if (atto === 0n)
1206
- return 0;
1207
- const whole = atto / this.ATTO_FACTOR;
1208
- const frac = atto % this.ATTO_FACTOR;
1209
- const MAX_SAFE_INT = BigInt(Number.MAX_SAFE_INTEGER);
1210
- if (whole > MAX_SAFE_INT || whole < -MAX_SAFE_INT) {
1211
- throw new RangeError("Atto value’s integer component exceeds JS double precision.");
1212
- }
1213
- return Number(whole) + Number(frac) / Number(this.ATTO_FACTOR);
1214
- }
1215
- static circlesToAttoCircles(circles) {
1216
- return BigInt(Math.trunc(circles * Number(this.ATTO_FACTOR)));
1217
- }
1218
- static inflationaryToDemurrage(inflationary, day) {
1219
- return this.mulU(this.pow64(this.GAMMA_64, day), inflationary);
1220
- }
1221
- static demurrageToInflationary(demurraged, day) {
1222
- return this.mulU(this.pow64(this.BETA_64, day), demurraged);
1223
- }
1224
- static dayFromTimestamp(unixSeconds) {
1225
- return (unixSeconds - this.INFLATION_DAY_ZERO_UNIX) / this.SECONDS_PER_DAY;
1226
- }
1227
- static attoCirclesToAttoStaticCircles(demurraged, nowUnixSeconds = BigInt(Math.floor(Date.now() / 1000))) {
1228
- return this.demurrageToInflationary(demurraged, this.dayFromTimestamp(nowUnixSeconds));
1229
- }
1230
- static attoStaticCirclesToAttoCircles(staticCircles, nowUnixSeconds = BigInt(Math.floor(Date.now() / 1000))) {
1231
- return this.inflationaryToDemurrage(staticCircles, this.dayFromTimestamp(nowUnixSeconds));
1232
- }
1233
- static inflationaryToDemurrageExact(inflationary, day) {
1234
- const factor = this.pow36(this.GAMMA_36, day);
1235
- return inflationary * factor / this.ONE_36;
1236
- }
1237
- static demurrageToInflationaryExact(demurraged, day) {
1238
- const factor = this.pow36(this.BETA_36, day);
1239
- return demurraged * factor / this.ONE_36;
1240
- }
1241
- static attoCirclesToAttoStaticCirclesExact(demurraged, nowUnixSeconds = BigInt(Math.floor(Date.now() / 1000))) {
1242
- const day = this.dayFromTimestamp(nowUnixSeconds);
1243
- return this.demurrageToInflationaryExact(demurraged, day);
1244
- }
1245
- static attoStaticCirclesToAttoCirclesExact(staticCircles, nowUnixSeconds = BigInt(Math.floor(Date.now() / 1000))) {
1246
- const day = this.dayFromTimestamp(nowUnixSeconds);
1247
- return this.inflationaryToDemurrageExact(staticCircles, day);
1248
- }
1249
- static truncateToInt64(wei) {
1250
- const truncated = wei / this.FACTOR_1E12;
1251
- const MAX_INT64 = 9223372036854775807n;
1252
- return truncated > MAX_INT64 ? MAX_INT64 : truncated;
1253
- }
1254
- static blowUpToBigInt(sixDecimals) {
1255
- return sixDecimals * this.FACTOR_1E12;
1256
- }
1257
- static truncateToSixDecimals(wei) {
1258
- return this.blowUpToBigInt(this.truncateToInt64(wei));
1259
- }
1260
- static v1InflateFactor(periodIdx) {
1261
- if (periodIdx === 0n)
1262
- return this.V1_ACCURACY;
1263
- return this.V1_ACCURACY * this.V1_INFLATION_PCT_NUM ** periodIdx / this.V1_INFLATION_PCT_DEN ** periodIdx;
1264
- }
1265
- static attoCrcToAttoCircles(v1Amount, blockTimestampUtc) {
1266
- const secondsSinceEpoch = blockTimestampUtc - this.INFLATION_DAY_ZERO_UNIX;
1267
- const periodIdx = secondsSinceEpoch / this.PERIOD_SEC;
1268
- const secondsIntoPeriod = secondsSinceEpoch % this.PERIOD_SEC;
1269
- const factorCur = this.v1InflateFactor(periodIdx);
1270
- const factorNext = this.v1InflateFactor(periodIdx + 1n);
1271
- return this.v1ToDemurrage(v1Amount, factorCur, factorNext, secondsIntoPeriod, this.PERIOD_SEC);
1272
- }
1273
- static attoCirclesToAttoCrc(demurraged, blockTimestampUtc) {
1274
- const secondsSinceEpoch = blockTimestampUtc - this.INFLATION_DAY_ZERO_UNIX;
1275
- const periodIdx = secondsSinceEpoch / this.PERIOD_SEC;
1276
- const secondsIntoPeriod = secondsSinceEpoch % this.PERIOD_SEC;
1277
- const factorCur = this.v1InflateFactor(periodIdx);
1278
- const factorNext = this.v1InflateFactor(periodIdx + 1n);
1279
- const rP = factorCur * (this.PERIOD_SEC - secondsIntoPeriod) + factorNext * secondsIntoPeriod;
1280
- return demurraged * 3n * this.V1_ACCURACY * this.PERIOD_SEC / rP;
1281
- }
1282
- static v1ToDemurrage(v1Amount, factorCur, factorNext, secondsInto, periodSec) {
1283
- const rP = factorCur * (periodSec - secondsInto) + factorNext * secondsInto;
1284
- return v1Amount * 3n * this.V1_ACCURACY * periodSec / rP;
1285
- }
1286
- }
1287
- var byteToHex2 = [];
1288
- for (let i = 0;i < 256; i++) {
1289
- byteToHex2[i] = i.toString(16).padStart(2, "0");
1290
- }
1291
- function bytesToHex2(bytes) {
1292
- let hex = "0x";
1293
- for (let i = 0;i < bytes.length; i++) {
1294
- hex += byteToHex2[bytes[i]];
1295
- }
1296
- return hex;
1297
- }
1298
- var U32_MASK642 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
1299
- var _32n2 = /* @__PURE__ */ BigInt(32);
1300
- function fromBig2(n, le = false) {
1301
- if (le)
1302
- return { h: Number(n & U32_MASK642), l: Number(n >> _32n2 & U32_MASK642) };
1303
- return { h: Number(n >> _32n2 & U32_MASK642) | 0, l: Number(n & U32_MASK642) | 0 };
1304
- }
1305
- function split2(lst, le = false) {
1306
- const len = lst.length;
1307
- let Ah = new Uint32Array(len);
1308
- let Al = new Uint32Array(len);
1309
- for (let i = 0;i < len; i++) {
1310
- const { h, l } = fromBig2(lst[i], le);
1311
- [Ah[i], Al[i]] = [h, l];
1312
- }
1313
- return [Ah, Al];
1314
- }
1315
- var rotlSH = (h, l, s) => h << s | l >>> 32 - s;
1316
- var rotlSL = (h, l, s) => l << s | h >>> 32 - s;
1317
- var rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
1318
- var rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
1319
- /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
1320
- function isBytes(a) {
1321
- return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
1322
- }
1323
- function anumber(n) {
1324
- if (!Number.isSafeInteger(n) || n < 0)
1325
- throw new Error("positive integer expected, got " + n);
1326
- }
1327
- function abytes(b, ...lengths) {
1328
- if (!isBytes(b))
1329
- throw new Error("Uint8Array expected");
1330
- if (lengths.length > 0 && !lengths.includes(b.length))
1331
- throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
1332
- }
1333
- function aexists(instance, checkFinished = true) {
1334
- if (instance.destroyed)
1335
- throw new Error("Hash instance has been destroyed");
1336
- if (checkFinished && instance.finished)
1337
- throw new Error("Hash#digest() has already been called");
1338
- }
1339
- function aoutput(out, instance) {
1340
- abytes(out);
1341
- const min = instance.outputLen;
1342
- if (out.length < min) {
1343
- throw new Error("digestInto() expects output buffer of length at least " + min);
1344
- }
1345
- }
1346
- function u32(arr) {
1347
- return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
1348
- }
1349
- function clean(...arrays) {
1350
- for (let i = 0;i < arrays.length; i++) {
1351
- arrays[i].fill(0);
1352
- }
1353
- }
1354
- var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
1355
- function byteSwap(word) {
1356
- return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
1357
- }
1358
- function byteSwap32(arr) {
1359
- for (let i = 0;i < arr.length; i++) {
1360
- arr[i] = byteSwap(arr[i]);
1361
- }
1362
- return arr;
1363
- }
1364
- var swap32IfBE = isLE ? (u) => u : byteSwap32;
1365
- function utf8ToBytes(str) {
1366
- if (typeof str !== "string")
1367
- throw new Error("string expected");
1368
- return new Uint8Array(new TextEncoder().encode(str));
1369
- }
1370
- function toBytes(data) {
1371
- if (typeof data === "string")
1372
- data = utf8ToBytes(data);
1373
- abytes(data);
1374
- return data;
1375
- }
1376
-
1377
- class Hash {
1378
- }
1379
- function createHasher(hashCons) {
1380
- const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
1381
- const tmp = hashCons();
1382
- hashC.outputLen = tmp.outputLen;
1383
- hashC.blockLen = tmp.blockLen;
1384
- hashC.create = () => hashCons();
1385
- return hashC;
1386
- }
1387
- var _0n2 = BigInt(0);
1388
- var _1n2 = BigInt(1);
1389
- var _2n2 = BigInt(2);
1390
- var _7n2 = BigInt(7);
1391
- var _256n2 = BigInt(256);
1392
- var _0x71n2 = BigInt(113);
1393
- var SHA3_PI2 = [];
1394
- var SHA3_ROTL2 = [];
1395
- var _SHA3_IOTA2 = [];
1396
- for (let round = 0, R = _1n2, x = 1, y = 0;round < 24; round++) {
1397
- [x, y] = [y, (2 * x + 3 * y) % 5];
1398
- SHA3_PI2.push(2 * (5 * y + x));
1399
- SHA3_ROTL2.push((round + 1) * (round + 2) / 2 % 64);
1400
- let t = _0n2;
1401
- for (let j = 0;j < 7; j++) {
1402
- R = (R << _1n2 ^ (R >> _7n2) * _0x71n2) % _256n2;
1403
- if (R & _2n2)
1404
- t ^= _1n2 << (_1n2 << /* @__PURE__ */ BigInt(j)) - _1n2;
1405
- }
1406
- _SHA3_IOTA2.push(t);
1407
- }
1408
- var IOTAS2 = split2(_SHA3_IOTA2, true);
1409
- var SHA3_IOTA_H2 = IOTAS2[0];
1410
- var SHA3_IOTA_L2 = IOTAS2[1];
1411
- var rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
1412
- var rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
1413
- function keccakP(s, rounds = 24) {
1414
- const B = new Uint32Array(5 * 2);
1415
- for (let round = 24 - rounds;round < 24; round++) {
1416
- for (let x = 0;x < 10; x++)
1417
- B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
1418
- for (let x = 0;x < 10; x += 2) {
1419
- const idx1 = (x + 8) % 10;
1420
- const idx0 = (x + 2) % 10;
1421
- const B0 = B[idx0];
1422
- const B1 = B[idx0 + 1];
1423
- const Th = rotlH(B0, B1, 1) ^ B[idx1];
1424
- const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
1425
- for (let y = 0;y < 50; y += 10) {
1426
- s[x + y] ^= Th;
1427
- s[x + y + 1] ^= Tl;
1428
- }
1429
- }
1430
- let curH = s[2];
1431
- let curL = s[3];
1432
- for (let t = 0;t < 24; t++) {
1433
- const shift = SHA3_ROTL2[t];
1434
- const Th = rotlH(curH, curL, shift);
1435
- const Tl = rotlL(curH, curL, shift);
1436
- const PI = SHA3_PI2[t];
1437
- curH = s[PI];
1438
- curL = s[PI + 1];
1439
- s[PI] = Th;
1440
- s[PI + 1] = Tl;
1441
- }
1442
- for (let y = 0;y < 50; y += 10) {
1443
- for (let x = 0;x < 10; x++)
1444
- B[x] = s[y + x];
1445
- for (let x = 0;x < 10; x++)
1446
- s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
1447
- }
1448
- s[0] ^= SHA3_IOTA_H2[round];
1449
- s[1] ^= SHA3_IOTA_L2[round];
1450
- }
1451
- clean(B);
1452
- }
1453
-
1454
- class Keccak extends Hash {
1455
- constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
1456
- super();
1457
- this.pos = 0;
1458
- this.posOut = 0;
1459
- this.finished = false;
1460
- this.destroyed = false;
1461
- this.enableXOF = false;
1462
- this.blockLen = blockLen;
1463
- this.suffix = suffix;
1464
- this.outputLen = outputLen;
1465
- this.enableXOF = enableXOF;
1466
- this.rounds = rounds;
1467
- anumber(outputLen);
1468
- if (!(0 < blockLen && blockLen < 200))
1469
- throw new Error("only keccak-f1600 function is supported");
1470
- this.state = new Uint8Array(200);
1471
- this.state32 = u32(this.state);
1472
- }
1473
- clone() {
1474
- return this._cloneInto();
1475
- }
1476
- keccak() {
1477
- swap32IfBE(this.state32);
1478
- keccakP(this.state32, this.rounds);
1479
- swap32IfBE(this.state32);
1480
- this.posOut = 0;
1481
- this.pos = 0;
1482
- }
1483
- update(data) {
1484
- aexists(this);
1485
- data = toBytes(data);
1486
- abytes(data);
1487
- const { blockLen, state } = this;
1488
- const len = data.length;
1489
- for (let pos = 0;pos < len; ) {
1490
- const take = Math.min(blockLen - this.pos, len - pos);
1491
- for (let i = 0;i < take; i++)
1492
- state[this.pos++] ^= data[pos++];
1493
- if (this.pos === blockLen)
1494
- this.keccak();
1495
- }
1496
- return this;
1497
- }
1498
- finish() {
1499
- if (this.finished)
1500
- return;
1501
- this.finished = true;
1502
- const { state, suffix, pos, blockLen } = this;
1503
- state[pos] ^= suffix;
1504
- if ((suffix & 128) !== 0 && pos === blockLen - 1)
1505
- this.keccak();
1506
- state[blockLen - 1] ^= 128;
1507
- this.keccak();
1508
- }
1509
- writeInto(out) {
1510
- aexists(this, false);
1511
- abytes(out);
1512
- this.finish();
1513
- const bufferOut = this.state;
1514
- const { blockLen } = this;
1515
- for (let pos = 0, len = out.length;pos < len; ) {
1516
- if (this.posOut >= blockLen)
1517
- this.keccak();
1518
- const take = Math.min(blockLen - this.posOut, len - pos);
1519
- out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
1520
- this.posOut += take;
1521
- pos += take;
1522
- }
1523
- return out;
1524
- }
1525
- xofInto(out) {
1526
- if (!this.enableXOF)
1527
- throw new Error("XOF is not possible for this instance");
1528
- return this.writeInto(out);
1529
- }
1530
- xof(bytes) {
1531
- anumber(bytes);
1532
- return this.xofInto(new Uint8Array(bytes));
1533
- }
1534
- digestInto(out) {
1535
- aoutput(out, this);
1536
- if (this.finished)
1537
- throw new Error("digest() was already called");
1538
- this.writeInto(out);
1539
- this.destroy();
1540
- return out;
1541
- }
1542
- digest() {
1543
- return this.digestInto(new Uint8Array(this.outputLen));
1544
- }
1545
- destroy() {
1546
- this.destroyed = true;
1547
- clean(this.state);
1548
- }
1549
- _cloneInto(to) {
1550
- const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
1551
- to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
1552
- to.state32.set(this.state32);
1553
- to.pos = this.pos;
1554
- to.posOut = this.posOut;
1555
- to.finished = this.finished;
1556
- to.rounds = rounds;
1557
- to.suffix = suffix;
1558
- to.outputLen = outputLen;
1559
- to.enableXOF = enableXOF;
1560
- to.destroyed = this.destroyed;
1561
- return to;
1562
- }
1563
- }
1564
- var gen = (suffix, blockLen, outputLen) => createHasher(() => new Keccak(blockLen, suffix, outputLen));
1565
- var keccak_256 = /* @__PURE__ */ (() => gen(1, 136, 256 / 8))();
1566
- function checksumAddress(address) {
1567
- const addr = address.toLowerCase().replace("0x", "");
1568
- const hash = bytesToHex2(keccak_256(new TextEncoder().encode(addr))).slice(2);
1569
- let result = "0x";
1570
- for (let i = 0;i < addr.length; i++) {
1571
- result += parseInt(hash[i], 16) >= 8 ? addr[i].toUpperCase() : addr[i];
1572
- }
1573
- return result;
1574
- }
1575
- var empty2 = new Uint8Array(0);
1576
- function equals3(aa, bb) {
1577
- if (aa === bb) {
1578
- return true;
1579
- }
1580
- if (aa.byteLength !== bb.byteLength) {
1581
- return false;
1582
- }
1583
- for (let ii = 0;ii < aa.byteLength; ii++) {
1584
- if (aa[ii] !== bb[ii]) {
1585
- return false;
1586
- }
1587
- }
1588
- return true;
1589
- }
1590
- function coerce2(o) {
1591
- if (o instanceof Uint8Array && o.constructor.name === "Uint8Array") {
1592
- return o;
1593
- }
1594
- if (o instanceof ArrayBuffer) {
1595
- return new Uint8Array(o);
1596
- }
1597
- if (ArrayBuffer.isView(o)) {
1598
- return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
1599
- }
1600
- throw new Error("Unknown type, must be binary type");
1601
- }
1602
- function base2(ALPHABET, name) {
1603
- if (ALPHABET.length >= 255) {
1604
- throw new TypeError("Alphabet too long");
1605
- }
1606
- var BASE_MAP = new Uint8Array(256);
1607
- for (var j = 0;j < BASE_MAP.length; j++) {
1608
- BASE_MAP[j] = 255;
1609
- }
1610
- for (var i = 0;i < ALPHABET.length; i++) {
1611
- var x = ALPHABET.charAt(i);
1612
- var xc = x.charCodeAt(0);
1613
- if (BASE_MAP[xc] !== 255) {
1614
- throw new TypeError(x + " is ambiguous");
1615
- }
1616
- BASE_MAP[xc] = i;
1617
- }
1618
- var BASE = ALPHABET.length;
1619
- var LEADER = ALPHABET.charAt(0);
1620
- var FACTOR = Math.log(BASE) / Math.log(256);
1621
- var iFACTOR = Math.log(256) / Math.log(BASE);
1622
- function encode3(source) {
1623
- if (source instanceof Uint8Array)
1624
- ;
1625
- else if (ArrayBuffer.isView(source)) {
1626
- source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
1627
- } else if (Array.isArray(source)) {
1628
- source = Uint8Array.from(source);
1629
- }
1630
- if (!(source instanceof Uint8Array)) {
1631
- throw new TypeError("Expected Uint8Array");
1632
- }
1633
- if (source.length === 0) {
1634
- return "";
1635
- }
1636
- var zeroes = 0;
1637
- var length2 = 0;
1638
- var pbegin = 0;
1639
- var pend = source.length;
1640
- while (pbegin !== pend && source[pbegin] === 0) {
1641
- pbegin++;
1642
- zeroes++;
1643
- }
1644
- var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
1645
- var b58 = new Uint8Array(size);
1646
- while (pbegin !== pend) {
1647
- var carry = source[pbegin];
1648
- var i2 = 0;
1649
- for (var it1 = size - 1;(carry !== 0 || i2 < length2) && it1 !== -1; it1--, i2++) {
1650
- carry += 256 * b58[it1] >>> 0;
1651
- b58[it1] = carry % BASE >>> 0;
1652
- carry = carry / BASE >>> 0;
1653
- }
1654
- if (carry !== 0) {
1655
- throw new Error("Non-zero carry");
1656
- }
1657
- length2 = i2;
1658
- pbegin++;
1659
- }
1660
- var it2 = size - length2;
1661
- while (it2 !== size && b58[it2] === 0) {
1662
- it2++;
1663
- }
1664
- var str = LEADER.repeat(zeroes);
1665
- for (;it2 < size; ++it2) {
1666
- str += ALPHABET.charAt(b58[it2]);
1667
- }
1668
- return str;
1669
- }
1670
- function decodeUnsafe(source) {
1671
- if (typeof source !== "string") {
1672
- throw new TypeError("Expected String");
1673
- }
1674
- if (source.length === 0) {
1675
- return new Uint8Array;
1676
- }
1677
- var psz = 0;
1678
- if (source[psz] === " ") {
1679
- return;
1680
- }
1681
- var zeroes = 0;
1682
- var length2 = 0;
1683
- while (source[psz] === LEADER) {
1684
- zeroes++;
1685
- psz++;
1686
- }
1687
- var size = (source.length - psz) * FACTOR + 1 >>> 0;
1688
- var b256 = new Uint8Array(size);
1689
- while (source[psz]) {
1690
- var carry = BASE_MAP[source.charCodeAt(psz)];
1691
- if (carry === 255) {
1692
- return;
1693
- }
1694
- var i2 = 0;
1695
- for (var it3 = size - 1;(carry !== 0 || i2 < length2) && it3 !== -1; it3--, i2++) {
1696
- carry += BASE * b256[it3] >>> 0;
1697
- b256[it3] = carry % 256 >>> 0;
1698
- carry = carry / 256 >>> 0;
1699
- }
1700
- if (carry !== 0) {
1701
- throw new Error("Non-zero carry");
1702
- }
1703
- length2 = i2;
1704
- psz++;
1705
- }
1706
- if (source[psz] === " ") {
1707
- return;
1708
- }
1709
- var it4 = size - length2;
1710
- while (it4 !== size && b256[it4] === 0) {
1711
- it4++;
1712
- }
1713
- var vch = new Uint8Array(zeroes + (size - it4));
1714
- var j2 = zeroes;
1715
- while (it4 !== size) {
1716
- vch[j2++] = b256[it4++];
1717
- }
1718
- return vch;
1719
- }
1720
- function decode5(string) {
1721
- var buffer = decodeUnsafe(string);
1722
- if (buffer) {
1723
- return buffer;
1724
- }
1725
- throw new Error(`Non-${name} character`);
1726
- }
1727
- return {
1728
- encode: encode3,
1729
- decodeUnsafe,
1730
- decode: decode5
1731
- };
1732
- }
1733
- var src2 = base2;
1734
- var _brrp__multiformats_scope_baseX2 = src2;
1735
- var base_x_default2 = _brrp__multiformats_scope_baseX2;
1736
-
1737
- class Encoder2 {
1738
- name;
1739
- prefix;
1740
- baseEncode;
1741
- constructor(name, prefix, baseEncode) {
1742
- this.name = name;
1743
- this.prefix = prefix;
1744
- this.baseEncode = baseEncode;
1745
- }
1746
- encode(bytes) {
1747
- if (bytes instanceof Uint8Array) {
1748
- return `${this.prefix}${this.baseEncode(bytes)}`;
1749
- } else {
1750
- throw Error("Unknown type, must be binary type");
1751
- }
1752
- }
1753
- }
1754
-
1755
- class Decoder2 {
1756
- name;
1757
- prefix;
1758
- baseDecode;
1759
- prefixCodePoint;
1760
- constructor(name, prefix, baseDecode) {
1761
- this.name = name;
1762
- this.prefix = prefix;
1763
- const prefixCodePoint = prefix.codePointAt(0);
1764
- if (prefixCodePoint === undefined) {
1765
- throw new Error("Invalid prefix character");
1766
- }
1767
- this.prefixCodePoint = prefixCodePoint;
1768
- this.baseDecode = baseDecode;
1769
- }
1770
- decode(text) {
1771
- if (typeof text === "string") {
1772
- if (text.codePointAt(0) !== this.prefixCodePoint) {
1773
- throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
1774
- }
1775
- return this.baseDecode(text.slice(this.prefix.length));
1776
- } else {
1777
- throw Error("Can only multibase decode strings");
1778
- }
1779
- }
1780
- or(decoder) {
1781
- return or2(this, decoder);
1782
- }
1783
- }
1784
-
1785
- class ComposedDecoder2 {
1786
- decoders;
1787
- constructor(decoders) {
1788
- this.decoders = decoders;
1789
- }
1790
- or(decoder) {
1791
- return or2(this, decoder);
1792
- }
1793
- decode(input) {
1794
- const prefix = input[0];
1795
- const decoder = this.decoders[prefix];
1796
- if (decoder != null) {
1797
- return decoder.decode(input);
1798
- } else {
1799
- throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
1800
- }
1801
- }
1802
- }
1803
- function or2(left, right) {
1804
- return new ComposedDecoder2({
1805
- ...left.decoders ?? { [left.prefix]: left },
1806
- ...right.decoders ?? { [right.prefix]: right }
1807
- });
1808
- }
1809
-
1810
- class Codec2 {
1811
- name;
1812
- prefix;
1813
- baseEncode;
1814
- baseDecode;
1815
- encoder;
1816
- decoder;
1817
- constructor(name, prefix, baseEncode, baseDecode) {
1818
- this.name = name;
1819
- this.prefix = prefix;
1820
- this.baseEncode = baseEncode;
1821
- this.baseDecode = baseDecode;
1822
- this.encoder = new Encoder2(name, prefix, baseEncode);
1823
- this.decoder = new Decoder2(name, prefix, baseDecode);
1824
- }
1825
- encode(input) {
1826
- return this.encoder.encode(input);
1827
- }
1828
- decode(input) {
1829
- return this.decoder.decode(input);
1830
- }
1831
- }
1832
- function from2({ name, prefix, encode: encode3, decode: decode5 }) {
1833
- return new Codec2(name, prefix, encode3, decode5);
1834
- }
1835
- function baseX2({ name, prefix, alphabet }) {
1836
- const { encode: encode3, decode: decode5 } = base_x_default2(alphabet, name);
1837
- return from2({
1838
- prefix,
1839
- name,
1840
- encode: encode3,
1841
- decode: (text) => coerce2(decode5(text))
1842
- });
1843
- }
1844
- function decode5(string, alphabetIdx, bitsPerChar, name) {
1845
- let end = string.length;
1846
- while (string[end - 1] === "=") {
1847
- --end;
1848
- }
1849
- const out = new Uint8Array(end * bitsPerChar / 8 | 0);
1850
- let bits = 0;
1851
- let buffer = 0;
1852
- let written = 0;
1853
- for (let i = 0;i < end; ++i) {
1854
- const value = alphabetIdx[string[i]];
1855
- if (value === undefined) {
1856
- throw new SyntaxError(`Non-${name} character`);
1857
- }
1858
- buffer = buffer << bitsPerChar | value;
1859
- bits += bitsPerChar;
1860
- if (bits >= 8) {
1861
- bits -= 8;
1862
- out[written++] = 255 & buffer >> bits;
1863
- }
1864
- }
1865
- if (bits >= bitsPerChar || (255 & buffer << 8 - bits) !== 0) {
1866
- throw new SyntaxError("Unexpected end of data");
1867
- }
1868
- return out;
1869
- }
1870
- function encode3(data, alphabet, bitsPerChar) {
1871
- const pad = alphabet[alphabet.length - 1] === "=";
1872
- const mask = (1 << bitsPerChar) - 1;
1873
- let out = "";
1874
- let bits = 0;
1875
- let buffer = 0;
1876
- for (let i = 0;i < data.length; ++i) {
1877
- buffer = buffer << 8 | data[i];
1878
- bits += 8;
1879
- while (bits > bitsPerChar) {
1880
- bits -= bitsPerChar;
1881
- out += alphabet[mask & buffer >> bits];
1882
- }
1883
- }
1884
- if (bits !== 0) {
1885
- out += alphabet[mask & buffer << bitsPerChar - bits];
1886
- }
1887
- if (pad) {
1888
- while ((out.length * bitsPerChar & 7) !== 0) {
1889
- out += "=";
1890
- }
1891
- }
1892
- return out;
1893
- }
1894
- function createAlphabetIdx2(alphabet) {
1895
- const alphabetIdx = {};
1896
- for (let i = 0;i < alphabet.length; ++i) {
1897
- alphabetIdx[alphabet[i]] = i;
1898
- }
1899
- return alphabetIdx;
1900
- }
1901
- function rfc46482({ name, prefix, bitsPerChar, alphabet }) {
1902
- const alphabetIdx = createAlphabetIdx2(alphabet);
1903
- return from2({
1904
- prefix,
1905
- name,
1906
- encode(input) {
1907
- return encode3(input, alphabet, bitsPerChar);
1908
- },
1909
- decode(input) {
1910
- return decode5(input, alphabetIdx, bitsPerChar, name);
1911
- }
1912
- });
1913
- }
1914
- var base322 = rfc46482({
1915
- prefix: "b",
1916
- name: "base32",
1917
- alphabet: "abcdefghijklmnopqrstuvwxyz234567",
1918
- bitsPerChar: 5
1919
- });
1920
- var base32upper2 = rfc46482({
1921
- prefix: "B",
1922
- name: "base32upper",
1923
- alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
1924
- bitsPerChar: 5
1925
- });
1926
- var base32pad2 = rfc46482({
1927
- prefix: "c",
1928
- name: "base32pad",
1929
- alphabet: "abcdefghijklmnopqrstuvwxyz234567=",
1930
- bitsPerChar: 5
1931
- });
1932
- var base32padupper2 = rfc46482({
1933
- prefix: "C",
1934
- name: "base32padupper",
1935
- alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=",
1936
- bitsPerChar: 5
1937
- });
1938
- var base32hex2 = rfc46482({
1939
- prefix: "v",
1940
- name: "base32hex",
1941
- alphabet: "0123456789abcdefghijklmnopqrstuv",
1942
- bitsPerChar: 5
1943
- });
1944
- var base32hexupper2 = rfc46482({
1945
- prefix: "V",
1946
- name: "base32hexupper",
1947
- alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV",
1948
- bitsPerChar: 5
1949
- });
1950
- var base32hexpad2 = rfc46482({
1951
- prefix: "t",
1952
- name: "base32hexpad",
1953
- alphabet: "0123456789abcdefghijklmnopqrstuv=",
1954
- bitsPerChar: 5
1955
- });
1956
- var base32hexpadupper2 = rfc46482({
1957
- prefix: "T",
1958
- name: "base32hexpadupper",
1959
- alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV=",
1960
- bitsPerChar: 5
1961
- });
1962
- var base32z2 = rfc46482({
1963
- prefix: "h",
1964
- name: "base32z",
1965
- alphabet: "ybndrfg8ejkmcpqxot1uwisza345h769",
1966
- bitsPerChar: 5
1967
- });
1968
- var base362 = baseX2({
1969
- prefix: "k",
1970
- name: "base36",
1971
- alphabet: "0123456789abcdefghijklmnopqrstuvwxyz"
1972
- });
1973
- var base36upper2 = baseX2({
1974
- prefix: "K",
1975
- name: "base36upper",
1976
- alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1977
- });
1978
- var base58btc2 = baseX2({
1979
- name: "base58btc",
1980
- prefix: "z",
1981
- alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
1982
- });
1983
- var base58flickr2 = baseX2({
1984
- name: "base58flickr",
1985
- prefix: "Z",
1986
- alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
1987
- });
1988
- var encode_12 = encode22;
1989
- var MSB2 = 128;
1990
- var REST2 = 127;
1991
- var MSBALL2 = ~REST2;
1992
- var INT2 = Math.pow(2, 31);
1993
- function encode22(num, out, offset) {
1994
- out = out || [];
1995
- offset = offset || 0;
1996
- var oldOffset = offset;
1997
- while (num >= INT2) {
1998
- out[offset++] = num & 255 | MSB2;
1999
- num /= 128;
2000
- }
2001
- while (num & MSBALL2) {
2002
- out[offset++] = num & 255 | MSB2;
2003
- num >>>= 7;
2004
- }
2005
- out[offset] = num | 0;
2006
- encode22.bytes = offset - oldOffset + 1;
2007
- return out;
2008
- }
2009
- var decode22 = read2;
2010
- var MSB$12 = 128;
2011
- var REST$12 = 127;
2012
- function read2(buf, offset) {
2013
- var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
2014
- do {
2015
- if (counter >= l) {
2016
- read2.bytes = 0;
2017
- throw new RangeError("Could not decode varint");
2018
- }
2019
- b = buf[counter++];
2020
- res += shift < 28 ? (b & REST$12) << shift : (b & REST$12) * Math.pow(2, shift);
2021
- shift += 7;
2022
- } while (b >= MSB$12);
2023
- read2.bytes = counter - offset;
2024
- return res;
2025
- }
2026
- var N12 = Math.pow(2, 7);
2027
- var N22 = Math.pow(2, 14);
2028
- var N32 = Math.pow(2, 21);
2029
- var N42 = Math.pow(2, 28);
2030
- var N52 = Math.pow(2, 35);
2031
- var N62 = Math.pow(2, 42);
2032
- var N72 = Math.pow(2, 49);
2033
- var N82 = Math.pow(2, 56);
2034
- var N92 = Math.pow(2, 63);
2035
- var length2 = function(value) {
2036
- return value < N12 ? 1 : value < N22 ? 2 : value < N32 ? 3 : value < N42 ? 4 : value < N52 ? 5 : value < N62 ? 6 : value < N72 ? 7 : value < N82 ? 8 : value < N92 ? 9 : 10;
2037
- };
2038
- var varint2 = {
2039
- encode: encode_12,
2040
- decode: decode22,
2041
- encodingLength: length2
2042
- };
2043
- var _brrp_varint2 = varint2;
2044
- var varint_default2 = _brrp_varint2;
2045
- function decode32(data, offset = 0) {
2046
- const code = varint_default2.decode(data, offset);
2047
- return [code, varint_default2.decode.bytes];
2048
- }
2049
- function encodeTo2(int, target, offset = 0) {
2050
- varint_default2.encode(int, target, offset);
2051
- return target;
2052
- }
2053
- function encodingLength2(int) {
2054
- return varint_default2.encodingLength(int);
2055
- }
2056
- function create2(code, digest) {
2057
- const size = digest.byteLength;
2058
- const sizeOffset = encodingLength2(code);
2059
- const digestOffset = sizeOffset + encodingLength2(size);
2060
- const bytes = new Uint8Array(digestOffset + size);
2061
- encodeTo2(code, bytes, 0);
2062
- encodeTo2(size, bytes, sizeOffset);
2063
- bytes.set(digest, digestOffset);
2064
- return new Digest2(code, size, digest, bytes);
2065
- }
2066
- function decode42(multihash) {
2067
- const bytes = coerce2(multihash);
2068
- const [code, sizeOffset] = decode32(bytes);
2069
- const [size, digestOffset] = decode32(bytes.subarray(sizeOffset));
2070
- const digest = bytes.subarray(sizeOffset + digestOffset);
2071
- if (digest.byteLength !== size) {
2072
- throw new Error("Incorrect length");
2073
- }
2074
- return new Digest2(code, size, digest, bytes);
2075
- }
2076
- function equals22(a, b) {
2077
- if (a === b) {
2078
- return true;
2079
- } else {
2080
- const data = b;
2081
- return a.code === data.code && a.size === data.size && data.bytes instanceof Uint8Array && equals3(a.bytes, data.bytes);
2082
- }
2083
- }
2084
-
2085
- class Digest2 {
2086
- code;
2087
- size;
2088
- digest;
2089
- bytes;
2090
- constructor(code, size, digest, bytes) {
2091
- this.code = code;
2092
- this.size = size;
2093
- this.digest = digest;
2094
- this.bytes = bytes;
2095
- }
2096
- }
2097
- function format2(link, base22) {
2098
- const { bytes, version } = link;
2099
- switch (version) {
2100
- case 0:
2101
- return toStringV02(bytes, baseCache2(link), base22 ?? base58btc2.encoder);
2102
- default:
2103
- return toStringV12(bytes, baseCache2(link), base22 ?? base322.encoder);
2104
- }
2105
- }
2106
- var cache2 = new WeakMap;
2107
- function baseCache2(cid) {
2108
- const baseCache22 = cache2.get(cid);
2109
- if (baseCache22 == null) {
2110
- const baseCache3 = new Map;
2111
- cache2.set(cid, baseCache3);
2112
- return baseCache3;
2113
- }
2114
- return baseCache22;
2115
- }
2116
-
2117
- class CID2 {
2118
- code;
2119
- version;
2120
- multihash;
2121
- bytes;
2122
- "/";
2123
- constructor(version, code, multihash, bytes) {
2124
- this.code = code;
2125
- this.version = version;
2126
- this.multihash = multihash;
2127
- this.bytes = bytes;
2128
- this["/"] = bytes;
2129
- }
2130
- get asCID() {
2131
- return this;
2132
- }
2133
- get byteOffset() {
2134
- return this.bytes.byteOffset;
2135
- }
2136
- get byteLength() {
2137
- return this.bytes.byteLength;
2138
- }
2139
- toV0() {
2140
- switch (this.version) {
2141
- case 0: {
2142
- return this;
2143
- }
2144
- case 1: {
2145
- const { code, multihash } = this;
2146
- if (code !== DAG_PB_CODE2) {
2147
- throw new Error("Cannot convert a non dag-pb CID to CIDv0");
2148
- }
2149
- if (multihash.code !== SHA_256_CODE2) {
2150
- throw new Error("Cannot convert non sha2-256 multihash CID to CIDv0");
2151
- }
2152
- return CID2.createV0(multihash);
2153
- }
2154
- default: {
2155
- throw Error(`Can not convert CID version ${this.version} to version 0. This is a bug please report`);
2156
- }
2157
- }
2158
- }
2159
- toV1() {
2160
- switch (this.version) {
2161
- case 0: {
2162
- const { code, digest } = this.multihash;
2163
- const multihash = create2(code, digest);
2164
- return CID2.createV1(this.code, multihash);
2165
- }
2166
- case 1: {
2167
- return this;
2168
- }
2169
- default: {
2170
- throw Error(`Can not convert CID version ${this.version} to version 1. This is a bug please report`);
2171
- }
2172
- }
2173
- }
2174
- equals(other) {
2175
- return CID2.equals(this, other);
2176
- }
2177
- static equals(self, other) {
2178
- const unknown = other;
2179
- return unknown != null && self.code === unknown.code && self.version === unknown.version && equals22(self.multihash, unknown.multihash);
2180
- }
2181
- toString(base22) {
2182
- return format2(this, base22);
2183
- }
2184
- toJSON() {
2185
- return { "/": format2(this) };
2186
- }
2187
- link() {
2188
- return this;
2189
- }
2190
- [Symbol.toStringTag] = "CID";
2191
- [Symbol.for("nodejs.util.inspect.custom")]() {
2192
- return `CID(${this.toString()})`;
2193
- }
2194
- static asCID(input) {
2195
- if (input == null) {
2196
- return null;
2197
- }
2198
- const value = input;
2199
- if (value instanceof CID2) {
2200
- return value;
2201
- } else if (value["/"] != null && value["/"] === value.bytes || value.asCID === value) {
2202
- const { version, code, multihash, bytes } = value;
2203
- return new CID2(version, code, multihash, bytes ?? encodeCID2(version, code, multihash.bytes));
2204
- } else if (value[cidSymbol2] === true) {
2205
- const { version, multihash, code } = value;
2206
- const digest = decode42(multihash);
2207
- return CID2.create(version, code, digest);
2208
- } else {
2209
- return null;
2210
- }
2211
- }
2212
- static create(version, code, digest) {
2213
- if (typeof code !== "number") {
2214
- throw new Error("String codecs are no longer supported");
2215
- }
2216
- if (!(digest.bytes instanceof Uint8Array)) {
2217
- throw new Error("Invalid digest");
2218
- }
2219
- switch (version) {
2220
- case 0: {
2221
- if (code !== DAG_PB_CODE2) {
2222
- throw new Error(`Version 0 CID must use dag-pb (code: ${DAG_PB_CODE2}) block encoding`);
2223
- } else {
2224
- return new CID2(version, code, digest, digest.bytes);
2225
- }
2226
- }
2227
- case 1: {
2228
- const bytes = encodeCID2(version, code, digest.bytes);
2229
- return new CID2(version, code, digest, bytes);
2230
- }
2231
- default: {
2232
- throw new Error("Invalid version");
2233
- }
2234
- }
2235
- }
2236
- static createV0(digest) {
2237
- return CID2.create(0, DAG_PB_CODE2, digest);
2238
- }
2239
- static createV1(code, digest) {
2240
- return CID2.create(1, code, digest);
2241
- }
2242
- static decode(bytes) {
2243
- const [cid, remainder] = CID2.decodeFirst(bytes);
2244
- if (remainder.length !== 0) {
2245
- throw new Error("Incorrect length");
2246
- }
2247
- return cid;
2248
- }
2249
- static decodeFirst(bytes) {
2250
- const specs = CID2.inspectBytes(bytes);
2251
- const prefixSize = specs.size - specs.multihashSize;
2252
- const multihashBytes = coerce2(bytes.subarray(prefixSize, prefixSize + specs.multihashSize));
2253
- if (multihashBytes.byteLength !== specs.multihashSize) {
2254
- throw new Error("Incorrect length");
2255
- }
2256
- const digestBytes = multihashBytes.subarray(specs.multihashSize - specs.digestSize);
2257
- const digest = new Digest2(specs.multihashCode, specs.digestSize, digestBytes, multihashBytes);
2258
- const cid = specs.version === 0 ? CID2.createV0(digest) : CID2.createV1(specs.codec, digest);
2259
- return [cid, bytes.subarray(specs.size)];
2260
- }
2261
- static inspectBytes(initialBytes) {
2262
- let offset = 0;
2263
- const next = () => {
2264
- const [i, length22] = decode32(initialBytes.subarray(offset));
2265
- offset += length22;
2266
- return i;
2267
- };
2268
- let version = next();
2269
- let codec = DAG_PB_CODE2;
2270
- if (version === 18) {
2271
- version = 0;
2272
- offset = 0;
2273
- } else {
2274
- codec = next();
2275
- }
2276
- if (version !== 0 && version !== 1) {
2277
- throw new RangeError(`Invalid CID version ${version}`);
2278
- }
2279
- const prefixSize = offset;
2280
- const multihashCode = next();
2281
- const digestSize = next();
2282
- const size = offset + digestSize;
2283
- const multihashSize = size - prefixSize;
2284
- return { version, codec, multihashCode, digestSize, multihashSize, size };
2285
- }
2286
- static parse(source, base22) {
2287
- const [prefix, bytes] = parseCIDtoBytes2(source, base22);
2288
- const cid = CID2.decode(bytes);
2289
- if (cid.version === 0 && source[0] !== "Q") {
2290
- throw Error("Version 0 CID string must not include multibase prefix");
2291
- }
2292
- baseCache2(cid).set(prefix, source);
2293
- return cid;
2294
- }
2295
- }
2296
- function parseCIDtoBytes2(source, base22) {
2297
- switch (source[0]) {
2298
- case "Q": {
2299
- const decoder = base22 ?? base58btc2;
2300
- return [
2301
- base58btc2.prefix,
2302
- decoder.decode(`${base58btc2.prefix}${source}`)
2303
- ];
2304
- }
2305
- case base58btc2.prefix: {
2306
- const decoder = base22 ?? base58btc2;
2307
- return [base58btc2.prefix, decoder.decode(source)];
2308
- }
2309
- case base322.prefix: {
2310
- const decoder = base22 ?? base322;
2311
- return [base322.prefix, decoder.decode(source)];
2312
- }
2313
- case base362.prefix: {
2314
- const decoder = base22 ?? base362;
2315
- return [base362.prefix, decoder.decode(source)];
2316
- }
2317
- default: {
2318
- if (base22 == null) {
2319
- throw Error("To parse non base32, base36 or base58btc encoded CID multibase decoder must be provided");
2320
- }
2321
- return [source[0], base22.decode(source)];
2322
- }
2323
- }
2324
- }
2325
- function toStringV02(bytes, cache22, base22) {
2326
- const { prefix } = base22;
2327
- if (prefix !== base58btc2.prefix) {
2328
- throw Error(`Cannot string encode V0 in ${base22.name} encoding`);
2329
- }
2330
- const cid = cache22.get(prefix);
2331
- if (cid == null) {
2332
- const cid2 = base22.encode(bytes).slice(1);
2333
- cache22.set(prefix, cid2);
2334
- return cid2;
2335
- } else {
2336
- return cid;
2337
- }
2338
- }
2339
- function toStringV12(bytes, cache22, base22) {
2340
- const { prefix } = base22;
2341
- const cid = cache22.get(prefix);
2342
- if (cid == null) {
2343
- const cid2 = base22.encode(bytes);
2344
- cache22.set(prefix, cid2);
2345
- return cid2;
2346
- } else {
2347
- return cid;
2348
- }
2349
- }
2350
- var DAG_PB_CODE2 = 112;
2351
- var SHA_256_CODE2 = 18;
2352
- function encodeCID2(version, code, multihash) {
2353
- const codeOffset = encodingLength2(version);
2354
- const hashOffset = codeOffset + encodingLength2(code);
2355
- const bytes = new Uint8Array(hashOffset + multihash.byteLength);
2356
- encodeTo2(version, bytes, 0);
2357
- encodeTo2(code, bytes, codeOffset);
2358
- bytes.set(multihash, hashOffset);
2359
- return bytes;
2360
- }
2361
- var cidSymbol2 = Symbol.for("@ipld/js-cid/CID");
2362
-
2363
- class CirclesError extends Error {
2364
- name;
2365
- code;
2366
- source;
2367
- cause;
2368
- context;
2369
- constructor(name, message, options) {
2370
- super(message);
2371
- this.name = name;
2372
- this.code = options?.code;
2373
- this.source = options?.source ?? "UNKNOWN";
2374
- this.cause = options?.cause;
2375
- this.context = options?.context;
2376
- if (Error.captureStackTrace) {
2377
- Error.captureStackTrace(this, this.constructor);
2378
- }
2379
- }
2380
- toJSON() {
2381
- return {
2382
- name: this.name,
2383
- message: this.message,
2384
- code: this.code,
2385
- source: this.source,
2386
- context: this.context,
2387
- cause: this.cause instanceof Error ? {
2388
- name: this.cause.name,
2389
- message: this.cause.message
2390
- } : this.cause,
2391
- stack: this.stack
2392
- };
2393
- }
2394
- toString() {
2395
- let result = `[${this.source}] ${this.name}: ${this.message}`;
2396
- if (this.code) {
2397
- result += ` (Code: ${this.code})`;
2398
- }
2399
- if (this.context) {
2400
- result += `
2401
- Context: ${JSON.stringify(this.context, null, 2)}`;
2402
- }
2403
- return result;
2404
- }
2405
- }
2406
-
2407
- class RpcError extends CirclesError {
2408
- constructor(message, options) {
2409
- super("RpcError", message, { ...options, source: options?.source ?? "RPC_REQUEST" });
2410
- }
2411
- static connectionFailed(url, cause) {
2412
- return new RpcError("Failed to connect to RPC endpoint", {
2413
- code: "RPC_CONNECTION_FAILED",
2414
- source: "RPC_CONNECTION",
2415
- cause,
2416
- context: { url }
2417
- });
2418
- }
2419
- static timeout(method, timeout) {
2420
- return new RpcError("RPC request timed out", {
2421
- code: "RPC_TIMEOUT",
2422
- source: "RPC_TIMEOUT",
2423
- context: { method, timeout }
2424
- });
2425
- }
2426
- static invalidResponse(method, response) {
2427
- return new RpcError("Invalid RPC response", {
2428
- code: "RPC_INVALID_RESPONSE",
2429
- source: "RPC_RESPONSE",
2430
- context: { method, response }
2431
- });
2432
- }
2433
- static fromJsonRpcError(error) {
2434
- return new RpcError(error.message, {
2435
- code: error.code,
2436
- source: "RPC_RESPONSE",
2437
- context: { data: error.data }
2438
- });
2439
- }
2440
- static websocketError(message, cause) {
2441
- return new RpcError(message, {
2442
- code: "RPC_WEBSOCKET_ERROR",
2443
- source: "RPC_WEBSOCKET",
2444
- cause
2445
- });
2446
- }
2447
- }
2448
-
2449
- class RpcClient {
2450
- rpcUrl;
2451
- requestId = 0;
2452
- websocket = null;
2453
- websocketConnected = false;
2454
- pendingResponses = {};
2455
- subscriptionListeners = {};
2456
- reconnectAttempt = 0;
2457
- initialBackoff = 2000;
2458
- maxBackoff = 120000;
2459
- constructor(rpcUrl) {
2460
- this.rpcUrl = rpcUrl;
2461
- }
2462
- async call(method, params) {
2463
- this.requestId++;
2464
- const request = {
2465
- jsonrpc: "2.0",
2466
- id: this.requestId,
2467
- method,
2468
- params
2469
- };
2470
- try {
2471
- const response = await fetch(this.rpcUrl, {
2472
- method: "POST",
2473
- headers: {
2474
- "Content-Type": "application/json"
2475
- },
2476
- body: JSON.stringify(request)
2477
- });
2478
- if (!response.ok) {
2479
- throw RpcError.connectionFailed(this.rpcUrl, new Error(`HTTP ${response.status}: ${response.statusText}`));
2480
- }
2481
- const jsonResponse = await response.json();
2482
- if (jsonResponse.error) {
2483
- throw RpcError.fromJsonRpcError(jsonResponse.error);
2484
- }
2485
- if (jsonResponse.result === undefined) {
2486
- throw RpcError.invalidResponse(method, jsonResponse);
2487
- }
2488
- return jsonResponse.result;
2489
- } catch (error) {
2490
- if (error instanceof RpcError) {
2491
- throw error;
2492
- }
2493
- throw RpcError.connectionFailed(this.rpcUrl, error);
2494
- }
2495
- }
2496
- setRpcUrl(rpcUrl) {
2497
- this.rpcUrl = rpcUrl;
2498
- }
2499
- getRpcUrl() {
2500
- return this.rpcUrl;
2501
- }
2502
- connect() {
2503
- return new Promise((resolve) => {
2504
- let wsUrl = this.rpcUrl.replace("http", "ws");
2505
- if (wsUrl.endsWith("/")) {
2506
- wsUrl += "ws";
2507
- } else {
2508
- wsUrl += "/ws";
2509
- }
2510
- this.websocket = new WebSocket(wsUrl);
2511
- this.websocket.onopen = () => {
2512
- console.log("WebSocket connected");
2513
- this.websocketConnected = true;
2514
- this.reconnectAttempt = 0;
2515
- resolve();
2516
- };
2517
- this.websocket.onmessage = (event) => {
2518
- const message = JSON.parse(event.data);
2519
- const { id, method, params } = message;
2520
- if (id !== undefined && this.pendingResponses[id]) {
2521
- this.pendingResponses[id].resolve(message);
2522
- delete this.pendingResponses[id];
2523
- }
2524
- if (method === "eth_subscription" && params) {
2525
- const { subscription, result } = params;
2526
- if (this.subscriptionListeners[subscription]) {
2527
- this.subscriptionListeners[subscription].forEach((listener) => listener(result));
2528
- }
2529
- }
2530
- };
2531
- this.websocket.onclose = () => {
2532
- console.warn("WebSocket closed");
2533
- this.websocketConnected = false;
2534
- };
2535
- this.websocket.onerror = (error) => {
2536
- console.error("WebSocket error:", error);
2537
- this.websocketConnected = false;
2538
- this.scheduleReconnect();
2539
- };
2540
- });
2541
- }
2542
- scheduleReconnect() {
2543
- const delay = Math.min(this.initialBackoff * Math.pow(2, this.reconnectAttempt), this.maxBackoff);
2544
- const jitter = delay * (Math.random() * 0.5);
2545
- const timeout = delay + jitter;
2546
- console.log(`Reconnecting in ${Math.round(timeout)}ms (attempt #${this.reconnectAttempt + 1})`);
2547
- this.reconnectAttempt++;
2548
- setTimeout(() => {
2549
- this.reconnect();
2550
- }, timeout);
2551
- }
2552
- async reconnect() {
2553
- if (this.websocketConnected)
2554
- return;
2555
- try {
2556
- await this.connect();
2557
- console.log("Reconnection successful");
2558
- } catch (err) {
2559
- console.error("Reconnection attempt failed:", err);
2560
- this.scheduleReconnect();
2561
- }
2562
- }
2563
- sendMessage(method, params, timeout = 5000) {
2564
- if (!this.websocket || this.websocket.readyState !== WebSocket.OPEN) {
2565
- return Promise.reject(RpcError.connectionFailed(this.rpcUrl));
2566
- }
2567
- const id = this.requestId++;
2568
- const message = { jsonrpc: "2.0", method, params, id };
2569
- return new Promise((resolve, reject) => {
2570
- this.pendingResponses[id] = { resolve, reject };
2571
- this.websocket.send(JSON.stringify(message));
2572
- setTimeout(() => {
2573
- if (this.pendingResponses[id]) {
2574
- this.pendingResponses[id].reject(RpcError.timeout(method, timeout));
2575
- delete this.pendingResponses[id];
2576
- }
2577
- }, timeout);
2578
- });
2579
- }
2580
- async subscribe(address) {
2581
- const normalizedAddress = address?.toLowerCase();
2582
- if (!this.websocketConnected) {
2583
- await this.connect();
2584
- }
2585
- const observable = Observable.create();
2586
- const subscriptionArgs = JSON.stringify(normalizedAddress ? { address: normalizedAddress } : {});
2587
- const response = await this.sendMessage("eth_subscribe", ["circles", subscriptionArgs]);
2588
- const subscriptionId = response.result;
2589
- if (!this.subscriptionListeners[subscriptionId]) {
2590
- this.subscriptionListeners[subscriptionId] = [];
2591
- }
2592
- this.subscriptionListeners[subscriptionId].push((events) => {
2593
- parseRpcSubscriptionMessage(events).forEach((event) => observable.emit(event));
2594
- });
2595
- return observable.property;
2596
- }
2597
- }
2598
- function normalizeAddress(address) {
2599
- return address.toLowerCase();
2600
- }
2601
- function checksumAddress2(address) {
2602
- return checksumAddress(address);
2603
- }
2604
- function isAddress(value) {
2605
- if (typeof value !== "string")
2606
- return false;
2607
- const cleaned = value.replace("0x", "");
2608
- return cleaned.length === 40 && /^[0-9a-fA-F]{40}$/.test(cleaned);
2609
- }
2610
- function checksumAddresses(value) {
2611
- if (value === null || value === undefined) {
2612
- return value;
2613
- }
2614
- if (isAddress(value)) {
2615
- return checksumAddress2(value);
2616
- }
2617
- if (Array.isArray(value)) {
2618
- return value.map((item) => checksumAddresses(item));
2619
- }
2620
- if (typeof value === "object" && value !== null) {
2621
- const result = {};
2622
- for (const key in value) {
2623
- if (Object.prototype.hasOwnProperty.call(value, key)) {
2624
- result[key] = checksumAddresses(value[key]);
2625
- }
2626
- }
2627
- return result;
2628
- }
2629
- return value;
2630
- }
2631
- function normalizeFindPathParams(params) {
2632
- return {
2633
- Source: normalizeAddress(params.from),
2634
- Sink: normalizeAddress(params.to),
2635
- TargetFlow: params.targetFlow.toString(),
2636
- WithWrap: params.useWrappedBalances,
2637
- FromTokens: params.fromTokens?.map(normalizeAddress),
2638
- ToTokens: params.toTokens?.map(normalizeAddress),
2639
- ExcludedFromTokens: params.excludeFromTokens?.map(normalizeAddress),
2640
- ExcludedToTokens: params.excludeToTokens?.map(normalizeAddress),
2641
- SimulatedBalances: params.simulatedBalances?.map((balance) => ({
2642
- Holder: normalizeAddress(balance.holder),
2643
- Token: normalizeAddress(balance.token),
2644
- Amount: balance.amount.toString(),
2645
- IsWrapped: balance.isWrapped,
2646
- IsStatic: balance.isStatic
2647
- })),
2648
- SimulatedTrusts: params.simulatedTrusts?.map((trust) => ({
2649
- Truster: normalizeAddress(trust.truster),
2650
- Trustee: normalizeAddress(trust.trustee)
2651
- })),
2652
- MaxTransfers: params.maxTransfers
2653
- };
2654
- }
2655
- function parseStringsToBigInt(obj) {
2656
- const result = {};
2657
- for (const key in obj) {
2658
- const value = obj[key];
2659
- if (value === null || value === undefined) {
2660
- result[key] = value;
2661
- } else if (typeof value === "string" && /^\d+$/.test(value)) {
2662
- result[key] = BigInt(value);
2663
- } else if (typeof value === "object" && !Array.isArray(value)) {
2664
- result[key] = parseStringsToBigInt(value);
2665
- } else if (Array.isArray(value)) {
2666
- result[key] = value.map((item) => typeof item === "object" && item !== null ? parseStringsToBigInt(item) : item);
2667
- } else {
2668
- result[key] = value;
2669
- }
2670
- }
2671
- return result;
2672
- }
2673
-
2674
- class PathfinderMethods {
2675
- client;
2676
- constructor(client) {
2677
- this.client = client;
2678
- }
2679
- async findPath(params) {
2680
- const normalizedParams = normalizeFindPathParams(params);
2681
- const result = await this.client.call("circlesV2_findPath", [normalizedParams]);
2682
- const parsed = parseStringsToBigInt(result);
2683
- return checksumAddresses(parsed);
2684
- }
2685
- async findMaxFlow(params) {
2686
- const targetFlow = 9999999999999999999999999999999999999n;
2687
- const path = await this.findPath({
2688
- ...params,
2689
- targetFlow
2690
- });
2691
- return BigInt(path.maxFlow);
2692
- }
2693
- }
2694
-
2695
- class QueryMethods {
2696
- client;
2697
- constructor(client) {
2698
- this.client = client;
2699
- }
2700
- async query(params) {
2701
- const result = await this.client.call("circles_query", [params]);
2702
- return checksumAddresses(result);
2703
- }
2704
- async tables() {
2705
- return this.client.call("circles_tables", []);
2706
- }
2707
- async events(fromBlock, toBlock, eventTypes = null, address = null, includeTransactionData = false) {
2708
- const result = await this.client.call("circles_events", [fromBlock, toBlock, eventTypes, address, includeTransactionData]);
2709
- return checksumAddresses(result);
2710
- }
2711
- }
2712
- var EVENT_CURSOR_COLUMNS = [
2713
- { name: "blockNumber", sortOrder: "DESC" },
2714
- { name: "transactionIndex", sortOrder: "DESC" },
2715
- { name: "logIndex", sortOrder: "DESC" }
2716
- ];
2717
-
2718
- class PagedQuery {
2719
- params;
2720
- client;
2721
- rowTransformer;
2722
- cursorColumns;
2723
- orderColumns;
2724
- get currentPage() {
2725
- return this._currentPage;
2726
- }
2727
- _currentPage;
2728
- constructor(client, params, rowTransformer) {
2729
- this.client = client;
2730
- this.params = params;
2731
- this.rowTransformer = rowTransformer || params.rowTransformer;
2732
- this.orderColumns = params.orderColumns;
2733
- this.cursorColumns = params.cursorColumns || this.buildEventCursorColumns();
2734
- }
2735
- buildEventCursorColumns() {
2736
- const columns = EVENT_CURSOR_COLUMNS.map((col) => ({
2737
- ...col,
2738
- sortOrder: this.params.sortOrder
2739
- }));
2740
- if (this.params.table === "TransferBatch") {
2741
- columns.push({ name: "batchIndex", sortOrder: this.params.sortOrder });
2742
- }
2743
- return columns;
2744
- }
2745
- transformCursorValue(value, transformer) {
2746
- if (transformer)
2747
- return transformer(value);
2748
- if (typeof value === "bigint")
2749
- return value.toString();
2750
- return value;
2751
- }
2752
- createEqualityPredicate(column, value) {
2753
- return {
2754
- Type: "FilterPredicate",
2755
- FilterType: "Equals",
2756
- Column: column.name,
2757
- Value: this.transformCursorValue(value, column.toValue)
2758
- };
2759
- }
2760
- createComparisonPredicate(column, value) {
2761
- const filterType = column.sortOrder === "ASC" ? "GreaterThan" : "LessThan";
2762
- return {
2763
- Type: "FilterPredicate",
2764
- FilterType: filterType,
2765
- Column: column.name,
2766
- Value: this.transformCursorValue(value, column.toValue)
2767
- };
2768
- }
2769
- buildCursorFilter(cursor) {
2770
- if (!cursor)
2771
- return [];
2772
- const orPredicates = [];
2773
- for (let level = 0;level < this.cursorColumns.length; level++) {
2774
- const currentColumn = this.cursorColumns[level];
2775
- const cursorValue = cursor[currentColumn.name];
2776
- if (cursorValue === undefined)
2777
- continue;
2778
- if (level === 0) {
2779
- orPredicates.push(this.createComparisonPredicate(currentColumn, cursorValue));
2780
- } else {
2781
- const andPredicates = [];
2782
- for (let prevLevel = 0;prevLevel < level; prevLevel++) {
2783
- const prevColumn = this.cursorColumns[prevLevel];
2784
- const prevValue = cursor[prevColumn.name];
2785
- if (prevValue !== undefined) {
2786
- andPredicates.push(this.createEqualityPredicate(prevColumn, prevValue));
2787
- }
2788
- }
2789
- andPredicates.push(this.createComparisonPredicate(currentColumn, cursorValue));
2790
- orPredicates.push({
2791
- Type: "Conjunction",
2792
- ConjunctionType: "And",
2793
- Predicates: andPredicates
2794
- });
2795
- }
2796
- }
2797
- if (orPredicates.length === 0)
2798
- return [];
2799
- return [{
2800
- Type: "Conjunction",
2801
- ConjunctionType: "Or",
2802
- Predicates: orPredicates
2803
- }];
2804
- }
2805
- buildOrderBy() {
2806
- if (this.orderColumns && this.orderColumns.length > 0) {
2807
- return this.orderColumns;
2808
- }
2809
- return this.cursorColumns.map((col) => ({
2810
- Column: col.name,
2811
- SortOrder: col.sortOrder
2812
- }));
2813
- }
2814
- combineFilters(baseFilters, cursorFilter) {
2815
- if (!baseFilters?.length && !cursorFilter?.length)
2816
- return [];
2817
- if (!baseFilters?.length)
2818
- return cursorFilter || [];
2819
- if (!cursorFilter?.length)
2820
- return baseFilters;
2821
- return [{
2822
- Type: "Conjunction",
2823
- ConjunctionType: "And",
2824
- Predicates: [...baseFilters, ...cursorFilter]
2825
- }];
2826
- }
2827
- rowsToObjects(response) {
2828
- const { columns, rows } = response;
2829
- return rows.map((row) => {
2830
- const rowObj = {};
2831
- columns.forEach((col, index) => {
2832
- rowObj[col] = row[index];
2833
- });
2834
- return this.rowTransformer ? this.rowTransformer(rowObj) : rowObj;
2835
- });
2836
- }
2837
- rowToCursor(row) {
2838
- const cursor = {};
2839
- for (const column of this.cursorColumns) {
2840
- cursor[column.name] = row[column.name];
2841
- }
2842
- return cursor;
2843
- }
2844
- getCursors(results) {
2845
- if (results.length === 0)
2846
- return {};
2847
- return {
2848
- first: this.rowToCursor(results[0]),
2849
- last: this.rowToCursor(results[results.length - 1])
2850
- };
2851
- }
2852
- async queryNextPage() {
2853
- const cursorFilter = this.buildCursorFilter(this._currentPage?.lastCursor);
2854
- const combinedFilter = this.combineFilters(this.params.filter, cursorFilter);
2855
- const queryParams = {
2856
- Namespace: this.params.namespace,
2857
- Table: this.params.table,
2858
- Columns: this.params.columns,
2859
- Filter: combinedFilter,
2860
- Order: this.buildOrderBy(),
2861
- Limit: this.params.limit
2862
- };
2863
- const response = await this.client.call("circles_query", [queryParams]);
2864
- const results = this.rowsToObjects(response);
2865
- const cursors = this.getCursors(results);
2866
- this._currentPage = {
2867
- limit: this.params.limit,
2868
- size: results.length,
2869
- firstCursor: cursors.first,
2870
- lastCursor: cursors.last,
2871
- sortOrder: this.params.sortOrder,
2872
- hasMore: results.length === this.params.limit,
2873
- results
2874
- };
2875
- return results.length > 0;
2876
- }
2877
- reset() {
2878
- this._currentPage = undefined;
2879
- }
2880
- }
2881
-
2882
- class TrustMethods {
2883
- client;
2884
- constructor(client) {
2885
- this.client = client;
2886
- }
2887
- transformQueryResponse(response) {
2888
- const { columns, rows } = response;
2889
- return rows.map((row) => {
2890
- const obj = {};
2891
- columns.forEach((col, index) => {
2892
- obj[col] = row[index];
2893
- });
2894
- return obj;
2895
- });
2896
- }
2897
- async getCommonTrust(address1, address2) {
2898
- const result = await this.client.call("circles_getCommonTrust", [
2899
- normalizeAddress(address1),
2900
- normalizeAddress(address2)
2901
- ]);
2902
- return checksumAddresses(result);
2903
- }
2904
- getTrustRelations(avatar, limit = 100, sortOrder = "DESC") {
2905
- const normalized = normalizeAddress(avatar);
2906
- const filter = [
2907
- {
2908
- Type: "Conjunction",
2909
- ConjunctionType: "And",
2910
- Predicates: [
2911
- {
2912
- Type: "FilterPredicate",
2913
- FilterType: "Equals",
2914
- Column: "version",
2915
- Value: 2
2916
- },
2917
- {
2918
- Type: "Conjunction",
2919
- ConjunctionType: "Or",
2920
- Predicates: [
2921
- {
2922
- Type: "FilterPredicate",
2923
- FilterType: "Equals",
2924
- Column: "trustee",
2925
- Value: normalized
2926
- },
2927
- {
2928
- Type: "FilterPredicate",
2929
- FilterType: "Equals",
2930
- Column: "truster",
2931
- Value: normalized
2932
- }
2933
- ]
2934
- }
2935
- ]
2936
- }
2937
- ];
2938
- return new PagedQuery(this.client, {
2939
- namespace: "V_Crc",
2940
- table: "TrustRelations",
2941
- sortOrder,
2942
- columns: [
2943
- "blockNumber",
2944
- "timestamp",
2945
- "transactionIndex",
2946
- "logIndex",
2947
- "transactionHash",
2948
- "version",
2949
- "trustee",
2950
- "truster",
2951
- "expiryTime"
2952
- ],
2953
- filter,
2954
- limit
2955
- }, (row) => checksumAddresses(row));
2956
- }
2957
- async getAggregatedTrustRelations(avatar) {
2958
- const normalized = normalizeAddress(avatar);
2959
- const query = this.getTrustRelations(normalized, 1000);
2960
- const trustListRows = [];
2961
- while (await query.queryNextPage()) {
2962
- trustListRows.push(...query.currentPage.results);
2963
- if (!query.currentPage.hasMore)
2964
- break;
2965
- }
2966
- const trustBucket = {};
2967
- trustListRows.forEach((row) => {
2968
- const trusterNorm = normalizeAddress(row.truster);
2969
- const trusteeNorm = normalizeAddress(row.trustee);
2970
- const counterpart = trusterNorm !== normalized ? row.truster : row.trustee;
2971
- if (!trustBucket[counterpart]) {
2972
- trustBucket[counterpart] = [];
2973
- }
2974
- trustBucket[counterpart].push(row);
2975
- });
2976
- const result = Object.entries(trustBucket).filter(([address]) => normalizeAddress(address) !== normalized).map(([address, rows]) => {
2977
- const maxTimestamp = Math.max(...rows.map((o) => o.timestamp));
2978
- let relation;
2979
- if (rows.length === 2) {
2980
- relation = "mutuallyTrusts";
2981
- } else if (normalizeAddress(rows[0]?.trustee) === normalized) {
2982
- relation = "trustedBy";
2983
- } else if (normalizeAddress(rows[0]?.truster) === normalized) {
2984
- relation = "trusts";
2985
- } else {
2986
- throw new Error(`Unexpected trust list row. Couldn't determine trust relation.`);
2987
- }
2988
- return {
2989
- subjectAvatar: normalized,
2990
- relation,
2991
- objectAvatar: address,
2992
- timestamp: maxTimestamp
2993
- };
2994
- });
2995
- return checksumAddresses(result);
2996
- }
2997
- async getTrustedBy(avatar) {
2998
- const normalized = normalizeAddress(avatar);
2999
- const relations = await this.getAggregatedTrustRelations(normalized);
3000
- const filtered = relations.filter((r) => r.relation === "trustedBy");
3001
- return checksumAddresses(filtered);
3002
- }
3003
- async getTrusts(avatar) {
3004
- const normalized = normalizeAddress(avatar);
3005
- const relations = await this.getAggregatedTrustRelations(normalized);
3006
- const filtered = relations.filter((r) => r.relation === "trusts");
3007
- return checksumAddresses(filtered);
3008
- }
3009
- async getMutualTrusts(avatar) {
3010
- const normalized = normalizeAddress(avatar);
3011
- const relations = await this.getAggregatedTrustRelations(normalized);
3012
- const filtered = relations.filter((r) => r.relation === "mutuallyTrusts");
3013
- return checksumAddresses(filtered);
3014
- }
3015
- }
3016
-
3017
- class BalanceMethods {
3018
- client;
3019
- constructor(client) {
3020
- this.client = client;
3021
- }
3022
- async getTotalBalance(address, asTimeCircles = true) {
3023
- const result = await this.client.call("circlesV2_getTotalBalance", [
3024
- normalizeAddress(address),
3025
- asTimeCircles
3026
- ]);
3027
- return CirclesConverter2.circlesToAttoCircles(result);
3028
- }
3029
- async getTokenBalances(address) {
3030
- const result = await this.client.call("circles_getTokenBalances", [
3031
- normalizeAddress(address)
3032
- ]);
3033
- const parsed = result.map((item) => parseStringsToBigInt(item));
3034
- return checksumAddresses(parsed);
3035
- }
3036
- }
3037
-
3038
- class AvatarMethods {
3039
- client;
3040
- constructor(client) {
3041
- this.client = client;
3042
- }
3043
- async getAvatarInfo(address) {
3044
- const results = await this.getAvatarInfoBatch([address]);
3045
- return results.length > 0 ? results[0] : undefined;
3046
- }
3047
- async getAvatarInfoBatch(addresses) {
3048
- if (addresses.length === 0) {
3049
- return [];
3050
- }
3051
- const normalizedAddresses = addresses.map((addr) => normalizeAddress(addr));
3052
- const result = await this.client.call("circles_getAvatarInfoBatch", [normalizedAddresses]);
3053
- return checksumAddresses(result);
3054
- }
3055
- async getNetworkSnapshot() {
3056
- const result = await this.client.call("circles_getNetworkSnapshot", []);
3057
- return checksumAddresses(result);
3058
- }
3059
- }
3060
-
3061
- class ProfileMethods {
3062
- client;
3063
- constructor(client) {
3064
- this.client = client;
3065
- }
3066
- async getProfileByCid(cid) {
3067
- return this.client.call("circles_getProfileByCid", [cid]);
3068
- }
3069
- async getProfileByCidBatch(cids) {
3070
- return this.client.call("circles_getProfileByCidBatch", [cids]);
3071
- }
3072
- async getProfileByAddress(address) {
3073
- return this.client.call("circles_getProfileByAddress", [
3074
- normalizeAddress(address)
3075
- ]);
3076
- }
3077
- async getProfileByAddressBatch(addresses) {
3078
- return this.client.call("circles_getProfileByAddressBatch", [addresses.map((addr) => addr === null ? null : normalizeAddress(addr))]);
3079
- }
3080
- async searchProfiles(query, limit = 10, offset = 0, avatarTypes) {
3081
- return this.client.call("circles_searchProfiles", [
3082
- query.toLowerCase(),
3083
- limit,
3084
- offset,
3085
- avatarTypes
3086
- ]);
3087
- }
3088
- async searchByAddressOrName(query, limit = 10, offset = 0, avatarTypes) {
3089
- const results = [];
3090
- const isAddress2 = /^0x[a-fA-F0-9]{40}$/.test(query);
3091
- if (isAddress2) {
3092
- try {
3093
- const profile = await this.getProfileByAddress(query);
3094
- if (profile) {
3095
- const searchResult = {
3096
- ...profile,
3097
- address: query
3098
- };
3099
- if (!avatarTypes || !searchResult.avatarType || avatarTypes.includes(searchResult.avatarType)) {
3100
- results.push(searchResult);
3101
- }
3102
- }
3103
- } catch (error) {
3104
- console.warn("Failed to get profile by address:", error);
3105
- }
3106
- }
3107
- try {
3108
- const textResults = await this.searchProfiles(query, limit, offset, avatarTypes);
3109
- if (isAddress2 && results.length > 0) {
3110
- const addressLower = query.toLowerCase();
3111
- const filteredResults = textResults.filter((p) => p.address?.toLowerCase() !== addressLower);
3112
- results.push(...filteredResults);
3113
- } else {
3114
- results.push(...textResults);
3115
- }
3116
- } catch (error) {
3117
- console.warn("Failed to search profiles by text:", error);
3118
- }
3119
- return results.slice(0, limit);
3120
- }
3121
- }
3122
-
3123
- class TokenMethods {
3124
- client;
3125
- constructor(client) {
3126
- this.client = client;
3127
- }
3128
- async getTokenInfo(address) {
3129
- const results = await this.getTokenInfoBatch([address]);
3130
- return results.length > 0 ? results[0] : undefined;
3131
- }
3132
- async getTokenInfoBatch(addresses) {
3133
- if (addresses.length === 0) {
3134
- return [];
3135
- }
3136
- const normalizedAddresses = addresses.map((addr) => normalizeAddress(addr));
3137
- const result = await this.client.call("circles_getTokenInfoBatch", [normalizedAddresses]);
3138
- const parsed = result.map((item) => parseStringsToBigInt(item));
3139
- return checksumAddresses(parsed);
3140
- }
3141
- getTokenHolders(tokenAddress, limit = 100, sortOrder = "DESC") {
3142
- const normalizedTokenAddress = normalizeAddress(tokenAddress);
3143
- return new PagedQuery(this.client, {
3144
- namespace: "V_CrcV2",
3145
- table: "BalancesByAccountAndToken",
3146
- columns: ["account", "tokenAddress", "demurragedTotalBalance"],
3147
- filter: [{
3148
- Type: "FilterPredicate",
3149
- FilterType: "Equals",
3150
- Column: "tokenAddress",
3151
- Value: normalizedTokenAddress
3152
- }],
3153
- cursorColumns: [
3154
- { name: "demurragedTotalBalance", sortOrder },
3155
- { name: "account", sortOrder: "ASC" }
3156
- ],
3157
- orderColumns: [
3158
- { Column: "demurragedTotalBalance", SortOrder: sortOrder },
3159
- { Column: "account", SortOrder: "ASC" }
3160
- ],
3161
- limit,
3162
- sortOrder
3163
- }, (row) => ({
3164
- account: row.account,
3165
- tokenAddress: row.tokenAddress,
3166
- demurragedTotalBalance: row.demurragedTotalBalance
3167
- }));
3168
- }
3169
- }
3170
-
3171
- class InvitationMethods {
3172
- client;
3173
- constructor(client) {
3174
- this.client = client;
3175
- }
3176
- transformQueryResponse(response) {
3177
- const { columns, rows } = response;
3178
- return rows.map((row) => {
3179
- const obj = {};
3180
- columns.forEach((col, index) => {
3181
- obj[col] = row[index];
3182
- });
3183
- return obj;
3184
- });
3185
- }
3186
- async getInvitedBy(address) {
3187
- const normalized = normalizeAddress(address);
3188
- const results = await this.client.call("circles_query", [
3189
- {
3190
- Namespace: "CrcV2",
3191
- Table: "RegisterHuman",
3192
- Columns: ["inviter"],
3193
- Filter: [
3194
- {
3195
- Type: "FilterPredicate",
3196
- FilterType: "Equals",
3197
- Column: "avatar",
3198
- Value: normalized
3199
- }
3200
- ],
3201
- Order: [
3202
- {
3203
- Column: "blockNumber",
3204
- SortOrder: "DESC"
3205
- }
3206
- ],
3207
- Limit: 1
3208
- }
3209
- ]);
3210
- if (results.length > 0) {
3211
- return checksumAddresses(results[0].inviter);
3212
- }
3213
- return;
3214
- }
3215
- async getInvitations(address) {
3216
- const normalized = normalizeAddress(address);
3217
- const MIN_TOKENS_REQUIRED = 96;
3218
- const avatarInfoResults = await this.client.call("circles_getAvatarInfoBatch", [[normalized]]);
3219
- const avatarInfo = avatarInfoResults.length > 0 ? avatarInfoResults[0] : undefined;
3220
- if (avatarInfo?.version === 2) {
3221
- return [];
3222
- }
3223
- const response = await this.client.call("circles_query", [
3224
- {
3225
- Namespace: "V_Crc",
3226
- Table: "TrustRelations",
3227
- Columns: ["truster", "trustee"],
3228
- Filter: [
3229
- {
3230
- Type: "Conjunction",
3231
- ConjunctionType: "And",
3232
- Predicates: [
3233
- {
3234
- Type: "FilterPredicate",
3235
- FilterType: "Equals",
3236
- Column: "version",
3237
- Value: 2
3238
- },
3239
- {
3240
- Type: "FilterPredicate",
3241
- FilterType: "Equals",
3242
- Column: "trustee",
3243
- Value: normalized
3244
- }
3245
- ]
3246
- }
3247
- ],
3248
- Order: []
3249
- }
3250
- ]);
3251
- const trustRelations = this.transformQueryResponse(response);
3252
- const v2Trusters = trustRelations.map((r) => r.truster);
3253
- if (v2Trusters.length === 0) {
3254
- return [];
3255
- }
3256
- const trusterInfos = await this.client.call("circles_getAvatarInfoBatch", [v2Trusters]);
3257
- const humanInviters = [];
3258
- for (const trusterInfo of trusterInfos) {
3259
- if (!trusterInfo?.isHuman) {
3260
- continue;
3261
- }
3262
- const balances = await this.client.call("circles_getTokenBalances", [trusterInfo.avatar]);
3263
- const inviterOwnToken = balances.find((b) => normalizeAddress(b.tokenAddress) === normalizeAddress(trusterInfo.avatar));
3264
- if (inviterOwnToken && inviterOwnToken.circles >= MIN_TOKENS_REQUIRED) {
3265
- humanInviters.push(trusterInfo);
3266
- }
3267
- }
3268
- return checksumAddresses(humanInviters);
3269
- }
3270
- async getInvitationsFrom(address, accepted = false) {
3271
- const normalized = normalizeAddress(address);
3272
- if (accepted) {
3273
- const response = await this.client.call("circles_query", [
3274
- {
3275
- Namespace: "CrcV2",
3276
- Table: "RegisterHuman",
3277
- Columns: ["avatar"],
3278
- Filter: [
3279
- {
3280
- Type: "FilterPredicate",
3281
- FilterType: "Equals",
3282
- Column: "inviter",
3283
- Value: normalized
3284
- }
3285
- ],
3286
- Order: [
3287
- {
3288
- Column: "blockNumber",
3289
- SortOrder: "DESC"
3290
- }
3291
- ]
3292
- }
3293
- ]);
3294
- const results = this.transformQueryResponse(response);
3295
- const avatars = results.map((r) => r.avatar);
3296
- return checksumAddresses(avatars);
3297
- } else {
3298
- const response = await this.client.call("circles_query", [
3299
- {
3300
- Namespace: "V_Crc",
3301
- Table: "TrustRelations",
3302
- Columns: ["trustee", "truster"],
3303
- Filter: [
3304
- {
3305
- Type: "Conjunction",
3306
- ConjunctionType: "And",
3307
- Predicates: [
3308
- {
3309
- Type: "FilterPredicate",
3310
- FilterType: "Equals",
3311
- Column: "version",
3312
- Value: 2
3313
- },
3314
- {
3315
- Type: "FilterPredicate",
3316
- FilterType: "Equals",
3317
- Column: "truster",
3318
- Value: normalized
3319
- }
3320
- ]
3321
- }
3322
- ],
3323
- Order: []
3324
- }
3325
- ]);
3326
- const trustRelations = this.transformQueryResponse(response);
3327
- const v2Trusted = trustRelations.map((r) => r.trustee);
3328
- if (v2Trusted.length === 0) {
3329
- return [];
3330
- }
3331
- const trustedAvatarsInfo = await this.client.call("circles_getAvatarInfoBatch", [v2Trusted]);
3332
- const registeredAvatarsSet = new Set(trustedAvatarsInfo.filter((a) => a !== null).map((a) => normalizeAddress(a.avatar)));
3333
- const pending = v2Trusted.filter((addr) => !registeredAvatarsSet.has(normalizeAddress(addr)));
3334
- return checksumAddresses(pending);
3335
- }
3336
- }
3337
- }
3338
- function calculateCircleAmounts(value, timestamp) {
3339
- const attoCircles = BigInt(value);
3340
- const circles = CirclesConverter2.attoCirclesToCircles(attoCircles);
3341
- const attoCrc = CirclesConverter2.attoCirclesToAttoCrc(attoCircles, BigInt(timestamp));
3342
- const crc = CirclesConverter2.attoCirclesToCircles(attoCrc);
3343
- const staticAttoCircles = CirclesConverter2.attoCirclesToAttoStaticCircles(attoCircles, BigInt(timestamp));
3344
- const staticCircles = CirclesConverter2.attoCirclesToCircles(staticAttoCircles);
3345
- return {
3346
- attoCircles,
3347
- circles,
3348
- staticAttoCircles,
3349
- staticCircles,
3350
- attoCrc,
3351
- crc
3352
- };
3353
- }
3354
-
3355
- class TransactionMethods {
3356
- client;
3357
- constructor(client) {
3358
- this.client = client;
3359
- }
3360
- getTransactionHistory(avatar, limit = 50, sortOrder = "DESC") {
3361
- const normalized = normalizeAddress(avatar);
3362
- const filter = [
3363
- {
3364
- Type: "Conjunction",
3365
- ConjunctionType: "And",
3366
- Predicates: [
3367
- {
3368
- Type: "FilterPredicate",
3369
- FilterType: "Equals",
3370
- Column: "version",
3371
- Value: 2
3372
- },
3373
- {
3374
- Type: "Conjunction",
3375
- ConjunctionType: "Or",
3376
- Predicates: [
3377
- {
3378
- Type: "FilterPredicate",
3379
- FilterType: "Equals",
3380
- Column: "from",
3381
- Value: normalized
3382
- },
3383
- {
3384
- Type: "FilterPredicate",
3385
- FilterType: "Equals",
3386
- Column: "to",
3387
- Value: normalized
3388
- }
3389
- ]
3390
- }
3391
- ]
3392
- }
3393
- ];
3394
- return new PagedQuery(this.client, {
3395
- namespace: "V_Crc",
3396
- table: "TransferSummary",
3397
- sortOrder,
3398
- columns: [],
3399
- filter,
3400
- limit
3401
- }, (row) => {
3402
- const amounts = calculateCircleAmounts(row.value, row.timestamp);
3403
- const result = {
3404
- ...row,
3405
- ...amounts
3406
- };
3407
- return checksumAddresses(result);
3408
- });
3409
- }
3410
- }
3411
-
3412
- class GroupMethods {
3413
- client;
3414
- constructor(client) {
3415
- this.client = client;
3416
- }
3417
- async findGroups(limit = 50, params) {
3418
- const query = this.getGroups(limit, params, "DESC");
3419
- const results = [];
3420
- while (await query.queryNextPage()) {
3421
- results.push(...query.currentPage.results);
3422
- if (results.length >= limit) {
3423
- break;
3424
- }
3425
- if (!query.currentPage.hasMore) {
3426
- break;
3427
- }
3428
- }
3429
- return results.slice(0, limit);
3430
- }
3431
- getGroupMemberships(avatar, limit = 50, sortOrder = "DESC") {
3432
- const normalized = normalizeAddress(avatar);
3433
- return new PagedQuery(this.client, {
3434
- namespace: "V_CrcV2",
3435
- table: "GroupMemberships",
3436
- sortOrder,
3437
- columns: [
3438
- "blockNumber",
3439
- "timestamp",
3440
- "transactionIndex",
3441
- "logIndex",
3442
- "transactionHash",
3443
- "group",
3444
- "member",
3445
- "expiryTime"
3446
- ],
3447
- filter: [
3448
- {
3449
- Type: "FilterPredicate",
3450
- FilterType: "Equals",
3451
- Column: "member",
3452
- Value: normalized
3453
- }
3454
- ],
3455
- limit
3456
- }, (row) => checksumAddresses(row));
3457
- }
3458
- getGroupHolders(groupAddress, limit = 100) {
3459
- const normalized = normalizeAddress(groupAddress);
3460
- return new PagedQuery(this.client, {
3461
- namespace: "V_CrcV2",
3462
- table: "GroupTokenHoldersBalance",
3463
- sortOrder: "DESC",
3464
- columns: ["group", "holder", "totalBalance", "demurragedTotalBalance", "fractionOwnership"],
3465
- cursorColumns: [
3466
- {
3467
- name: "holder",
3468
- sortOrder: "ASC"
3469
- }
3470
- ],
3471
- orderColumns: [
3472
- { Column: "totalBalance", SortOrder: "DESC" },
3473
- { Column: "holder", SortOrder: "ASC" }
3474
- ],
3475
- filter: [
3476
- {
3477
- Type: "FilterPredicate",
3478
- FilterType: "Equals",
3479
- Column: "group",
3480
- Value: normalized
3481
- }
3482
- ],
3483
- limit,
3484
- rowTransformer: (row) => {
3485
- const transformed = {
3486
- ...row,
3487
- totalBalance: BigInt(row.totalBalance),
3488
- demurragedTotalBalance: BigInt(row.demurragedTotalBalance)
3489
- };
3490
- return checksumAddresses(transformed);
3491
- }
3492
- });
3493
- }
3494
- getGroupMembers(groupAddress, limit = 100, sortOrder = "DESC") {
3495
- const normalized = normalizeAddress(groupAddress);
3496
- return new PagedQuery(this.client, {
3497
- namespace: "V_CrcV2",
3498
- table: "GroupMemberships",
3499
- sortOrder,
3500
- columns: [
3501
- "blockNumber",
3502
- "timestamp",
3503
- "transactionIndex",
3504
- "logIndex",
3505
- "transactionHash",
3506
- "group",
3507
- "member",
3508
- "expiryTime"
3509
- ],
3510
- filter: [
3511
- {
3512
- Type: "FilterPredicate",
3513
- FilterType: "Equals",
3514
- Column: "group",
3515
- Value: normalized
3516
- }
3517
- ],
3518
- limit
3519
- }, (row) => checksumAddresses(row));
3520
- }
3521
- getGroups(limit = 50, params, sortOrder = "DESC") {
3522
- const filter = [];
3523
- if (params) {
3524
- if (params.nameStartsWith) {
3525
- filter.push({
3526
- Type: "FilterPredicate",
3527
- FilterType: "Like",
3528
- Column: "name",
3529
- Value: params.nameStartsWith + "%"
3530
- });
3531
- }
3532
- if (params.symbolStartsWith) {
3533
- filter.push({
3534
- Type: "FilterPredicate",
3535
- FilterType: "Like",
3536
- Column: "symbol",
3537
- Value: params.symbolStartsWith + "%"
3538
- });
3539
- }
3540
- if (params.groupAddressIn && params.groupAddressIn.length > 0) {
3541
- const addressPredicates = params.groupAddressIn.map((addr) => ({
3542
- Type: "FilterPredicate",
3543
- FilterType: "Equals",
3544
- Column: "group",
3545
- Value: normalizeAddress(addr)
3546
- }));
3547
- if (addressPredicates.length === 1) {
3548
- filter.push(addressPredicates[0]);
3549
- } else {
3550
- filter.push({
3551
- Type: "Conjunction",
3552
- ConjunctionType: "Or",
3553
- Predicates: addressPredicates
3554
- });
3555
- }
3556
- }
3557
- if (params.groupTypeIn && params.groupTypeIn.length > 0) {
3558
- const typePredicates = params.groupTypeIn.map((type) => ({
3559
- Type: "FilterPredicate",
3560
- FilterType: "Equals",
3561
- Column: "type",
3562
- Value: type
3563
- }));
3564
- if (typePredicates.length === 1) {
3565
- filter.push(typePredicates[0]);
3566
- } else {
3567
- filter.push({
3568
- Type: "Conjunction",
3569
- ConjunctionType: "Or",
3570
- Predicates: typePredicates
3571
- });
3572
- }
3573
- }
3574
- if (params.ownerIn && params.ownerIn.length > 0) {
3575
- const ownerPredicates = params.ownerIn.map((addr) => ({
3576
- Type: "FilterPredicate",
3577
- FilterType: "Equals",
3578
- Column: "owner",
3579
- Value: normalizeAddress(addr)
3580
- }));
3581
- if (ownerPredicates.length === 1) {
3582
- filter.push(ownerPredicates[0]);
3583
- } else {
3584
- filter.push({
3585
- Type: "Conjunction",
3586
- ConjunctionType: "Or",
3587
- Predicates: ownerPredicates
3588
- });
3589
- }
3590
- }
3591
- if (params.mintHandlerEquals) {
3592
- filter.push({
3593
- Type: "FilterPredicate",
3594
- FilterType: "Equals",
3595
- Column: "mintHandler",
3596
- Value: normalizeAddress(params.mintHandlerEquals)
3597
- });
3598
- }
3599
- if (params.treasuryEquals) {
3600
- filter.push({
3601
- Type: "FilterPredicate",
3602
- FilterType: "Equals",
3603
- Column: "treasury",
3604
- Value: normalizeAddress(params.treasuryEquals)
3605
- });
3606
- }
3607
- }
3608
- const finalFilter = filter.length > 1 ? [
3609
- {
3610
- Type: "Conjunction",
3611
- ConjunctionType: "And",
3612
- Predicates: filter
3613
- }
3614
- ] : filter;
3615
- return new PagedQuery(this.client, {
3616
- namespace: "V_CrcV2",
3617
- table: "Groups",
3618
- sortOrder,
3619
- columns: [
3620
- "blockNumber",
3621
- "timestamp",
3622
- "transactionIndex",
3623
- "logIndex",
3624
- "transactionHash",
3625
- "group",
3626
- "type",
3627
- "owner",
3628
- "mintPolicy",
3629
- "mintHandler",
3630
- "treasury",
3631
- "service",
3632
- "feeCollection",
3633
- "memberCount",
3634
- "name",
3635
- "symbol",
3636
- "cidV0Digest",
3637
- "erc20WrapperDemurraged",
3638
- "erc20WrapperStatic"
3639
- ],
3640
- filter: finalFilter,
3641
- limit
3642
- }, (row) => checksumAddresses(row));
3643
- }
3644
- }
3645
-
3646
- class CirclesRpc {
3647
- client;
3648
- pathfinder;
3649
- query;
3650
- trust;
3651
- balance;
3652
- avatar;
3653
- profile;
3654
- token;
3655
- invitation;
3656
- transaction;
3657
- group;
3658
- constructor(rpcUrl = "https://rpc.circlesubi.network/") {
3659
- this.client = new RpcClient(rpcUrl);
3660
- this.pathfinder = new PathfinderMethods(this.client);
3661
- this.query = new QueryMethods(this.client);
3662
- this.trust = new TrustMethods(this.client);
3663
- this.balance = new BalanceMethods(this.client);
3664
- this.avatar = new AvatarMethods(this.client);
3665
- this.profile = new ProfileMethods(this.client);
3666
- this.token = new TokenMethods(this.client);
3667
- this.invitation = new InvitationMethods(this.client);
3668
- this.transaction = new TransactionMethods(this.client);
3669
- this.group = new GroupMethods(this.client);
3670
- }
3671
- setRpcUrl(rpcUrl) {
3672
- this.client.setRpcUrl(rpcUrl);
3673
- }
3674
- getRpcUrl() {
3675
- return this.client.getRpcUrl();
3676
- }
3677
- }
3678
-
3679
- // src/path.ts
3680
- async function getTokenInfoMapFromPath(currentAvatar, rpcUrl, transferPath) {
3681
- const tokenInfoMap = new Map;
3682
- const uniqueAddresses = new Set;
3683
- transferPath.transfers.forEach((t) => {
3684
- if (currentAvatar.toLowerCase() === t.from.toLowerCase())
3685
- uniqueAddresses.add(t.tokenOwner.toLowerCase());
3686
- });
3687
- const rpc = new CirclesRpc(rpcUrl);
3688
- const batch = await rpc.token.getTokenInfoBatch(Array.from(uniqueAddresses));
3689
- batch.forEach((info) => {
3690
- if (info.isWrapped && !info.isInflationary) {
3691
- info.tokenType = "CrcV2_ERC20WrapperDeployed_Demurraged";
3692
- }
3693
- tokenInfoMap.set(info.tokenAddress.toLowerCase(), info);
3694
- });
3695
- return tokenInfoMap;
3696
- }
3697
- function getWrappedTokensFromPath(transferPath, tokenInfoMap) {
3698
- const wrappedTokensInPath = {};
3699
- transferPath.transfers.forEach((t) => {
3700
- const info = tokenInfoMap.get(t.tokenOwner.toLowerCase());
3701
- const isWrapper = info && info.tokenType.startsWith("CrcV2_ERC20WrapperDeployed");
3702
- if (isWrapper) {
3703
- if (!wrappedTokensInPath[t.tokenOwner]) {
3704
- wrappedTokensInPath[t.tokenOwner] = [BigInt(0), info.tokenType];
3705
- }
3706
- wrappedTokensInPath[t.tokenOwner][0] += BigInt(t.value);
3707
- }
3708
- });
3709
- return wrappedTokensInPath;
3710
- }
3711
- function getExpectedUnwrappedTokenTotals(wrappedTotals, tokenInfoMap) {
3712
- const unwrapped = {};
3713
- Object.entries(wrappedTotals).forEach(([wrapperAddr, [total, type]]) => {
3714
- const info = tokenInfoMap.get(wrapperAddr.toLowerCase());
3715
- if (!info)
3716
- return;
3717
- if (type === "CrcV2_ERC20WrapperDeployed_Demurraged") {
3718
- unwrapped[wrapperAddr] = [total, info.tokenOwner];
3719
- }
3720
- if (type === "CrcV2_ERC20WrapperDeployed_Inflationary") {
3721
- unwrapped[wrapperAddr] = [CirclesConverter.attoStaticCirclesToAttoCircles(total), info.tokenOwner];
3722
- }
3723
- });
3724
- return unwrapped;
3725
- }
3726
- function replaceWrappedTokensWithAvatars(path, tokenInfoMap) {
3727
- const rewritten = path.transfers.map((edge) => {
3728
- const tokenInfo = tokenInfoMap.get(edge.tokenOwner.toLowerCase());
3729
- if (tokenInfo && tokenInfo.tokenType.startsWith("CrcV2_ERC20WrapperDeployed")) {
3730
- return { ...edge, tokenOwner: tokenInfo.tokenOwner };
3731
- }
3732
- return edge;
3733
- });
3734
- return { ...path, transfers: rewritten };
3735
- }
3736
- function replaceWrappedTokens(path, unwrapped) {
3737
- const wrapperToAvatar = {};
3738
- Object.entries(unwrapped).forEach(([wrapperAddr, [, avatarAddr]]) => {
3739
- wrapperToAvatar[wrapperAddr.toLowerCase()] = avatarAddr;
3740
- });
3741
- const rewritten = path.transfers.map((edge) => {
3742
- const tokenOwnerLower = edge.tokenOwner.toLowerCase();
3743
- const tokenOwner = wrapperToAvatar[tokenOwnerLower] || edge.tokenOwner;
3744
- return { ...edge, tokenOwner };
3745
- });
3746
- return { ...path, transfers: rewritten };
3747
- }
3748
- function shrinkPathValues(path, sink, retainBps = BigInt(999999999999)) {
3749
- const incomingToSink = new Map;
3750
- const scaled = [];
3751
- const DENOM = BigInt(1000000000000);
3752
- path.transfers.forEach((edge) => {
3753
- const scaledValue = BigInt(edge.value) * retainBps / DENOM;
3754
- const isZero = scaledValue === BigInt(0);
3755
- if (isZero) {
3756
- return;
3757
- }
3758
- scaled.push({ ...edge, value: scaledValue });
3759
- incomingToSink.set(edge.to, (incomingToSink.get(edge.to) ?? BigInt(0)) + scaledValue);
3760
- });
3761
- const maxFlow = sink ? incomingToSink.get(sink.toLowerCase()) ?? BigInt(0) : BigInt(0);
3762
- return {
3763
- maxFlow,
3764
- transfers: scaled
3765
- };
3766
- }
3767
- function assertNoNettedFlowMismatch(path, overrideSource, overrideSink) {
3768
- const net = computeNettedFlow(path);
3769
- const { source, sink } = getSourceAndSink(path, overrideSource, overrideSink);
3770
- const endpointsCoincide = source === sink;
3771
- net.forEach((balance, addr) => {
3772
- if (endpointsCoincide) {
3773
- if (balance !== BigInt(0)) {
3774
- throw new Error(`Vertex ${addr} is unbalanced: ${balance}`);
3775
- }
3776
- return;
3777
- }
3778
- const isSource = addr === source;
3779
- const isSink = addr === sink;
3780
- if (isSource && balance >= BigInt(0)) {
3781
- throw new Error(`Source ${addr} should be net negative, got ${balance}`);
3782
- }
3783
- if (isSink && balance <= BigInt(0)) {
3784
- throw new Error(`Sink ${addr} should be net positive, got ${balance}`);
3785
- }
3786
- const isIntermediate = !isSource && !isSink;
3787
- if (isIntermediate && balance !== BigInt(0)) {
3788
- throw new Error(`Vertex ${addr} is unbalanced: ${balance}`);
3789
- }
3790
- });
3791
- }
3792
- function getSourceAndSink(path, overrideSource, overrideSink) {
3793
- const senders = new Set(path.transfers.map((t) => t.from.toLowerCase()));
3794
- const receivers = new Set(path.transfers.map((t) => t.to.toLowerCase()));
3795
- const source = [...senders].find((a) => !receivers.has(a));
3796
- const sink = [...receivers].find((a) => !senders.has(a));
3797
- if (!(source ?? overrideSource) || !(sink ?? overrideSink)) {
3798
- throw new Error("Could not determine unique source / sink");
3799
- }
3800
- return { source: source ?? overrideSource, sink: sink ?? overrideSink };
3801
- }
3802
- function computeNettedFlow(path) {
3803
- const net = new Map;
3804
- path.transfers.forEach(({ from: from3, to, value }) => {
3805
- const amount = BigInt(value);
3806
- net.set(from3.toLowerCase(), (net.get(from3.toLowerCase()) ?? BigInt(0)) - amount);
3807
- net.set(to.toLowerCase(), (net.get(to.toLowerCase()) ?? BigInt(0)) + amount);
3808
- });
3809
- return net;
3810
- }
3811
- export {
3812
- transformToFlowVertices,
3813
- shrinkPathValues,
3814
- replaceWrappedTokensWithAvatars,
3815
- replaceWrappedTokens,
3816
- packCoordinates,
3817
- getWrappedTokensFromPath,
3818
- getTokenInfoMapFromPath,
3819
- getExpectedUnwrappedTokenTotals,
3820
- createFlowMatrix,
3821
- computeNettedFlow,
3822
- assertNoNettedFlowMismatch
3823
- };
1
+ var K=[];for(let z=0;z<256;z++)K[z]=z.toString(16).padStart(2,"0");function y(z){let B="0x";for(let R=0;R<z.length;R++)B+=K[z[R]];return B}function u(z){let B=new Uint8Array(z.length*2);return z.forEach((R,O)=>{let _=R>>8,F=R&255,H=2*O;B[H]=_,B[H+1]=F}),y(B)}function f(z,B,R){let O=new Set([B.toLowerCase(),R.toLowerCase()]);z.forEach((H)=>{O.add(H.from.toLowerCase()),O.add(H.to.toLowerCase()),O.add(H.tokenOwner.toLowerCase())});let _=[...O].sort((H,L)=>{let j=BigInt(H),N=BigInt(L),E=j<N,X=j>N;return E?-1:X?1:0}),F={};return _.forEach((H,L)=>{F[H]=L}),{sorted:_,idx:F}}function C1(z,B){let R=new Set,O=[],_=null;if(z.forEach((F,H)=>{let L=F.from.toLowerCase(),j=F.to.toLowerCase();if(L===B&&j===B)_=H;else if(j===B)O.push(H)}),_!==null)R.add(_);else O.forEach((F)=>R.add(F));return R}function B3(z,B,R,O){let _=z.toLowerCase(),F=B.toLowerCase(),{sorted:H,idx:L}=f(O,_,F),j=C1(O,F),N=O.map((q,g)=>{return{streamSinkId:j.has(g)?1:0,amount:q.value}});if(j.size===0)throw Error(`No terminal edges detected. Flow must have at least one edge delivering to receiver ${F}`);let E=Array.from(j),X=[{sourceCoordinate:L[_],flowEdgeIds:E,data:new Uint8Array(0)}],A=[];O.forEach((q)=>{A.push(L[q.tokenOwner.toLowerCase()]),A.push(L[q.from.toLowerCase()]),A.push(L[q.to.toLowerCase()])});let T=u(A),W=BigInt(R),m=N.filter((q)=>q.streamSinkId===1).reduce((q,g)=>q+BigInt(g.amount.toString()),BigInt(0));if(m!==W)throw Error(`Terminal sum ${m} does not equal expected ${W}`);return{flowVertices:H,flowEdges:N,streams:X,packedCoordinates:T,sourceCoordinate:L[_]}}function R3(z,B){let R=z.streams.map((O)=>({sourceCoordinate:O.sourceCoordinate,flowEdgeIds:O.flowEdgeIds,data:O.data instanceof Uint8Array?y(O.data):O.data}));if(B&&R.length>0)R[0].data=B instanceof Uint8Array?y(B):B;return R}var x=(z)=>BigInt(z),S=(z)=>parseInt(z,16),N1=(z)=>{if(z.startsWith("0x"))z=z.slice(2);if(z.length%2!==0)throw Error("Invalid hex string");let B=new Uint8Array(z.length/2);for(let R=0;R<z.length;R+=2)B[R/2]=parseInt(z.substr(R,2),16);return B};function P1(z,B){if(typeof B==="string"&&B.startsWith("0x")){let R=B.slice(2);if(R.length===40)return B;if(R.length===64){if(z.toLowerCase().includes("digest")||z.toLowerCase().includes("data")||z.toLowerCase().includes("bytes"))return N1(B);try{return x(B)}catch{return B}}try{let O=S(B);if(O<Number.MAX_SAFE_INTEGER)return O;return x(B)}catch{return B}}if(B==="true")return!0;if(B==="false")return!1;return B}function E1(z){let{event:B,values:R}=z,O={$event:B,blockNumber:R.blockNumber?S(R.blockNumber):0,timestamp:R.timestamp?S(R.timestamp):void 0,transactionIndex:R.transactionIndex?S(R.transactionIndex):0,logIndex:R.logIndex?S(R.logIndex):0,transactionHash:R.transactionHash};for(let[_,F]of Object.entries(R)){if(["blockNumber","timestamp","transactionIndex","logIndex","transactionHash"].includes(_))continue;O[_]=P1(_,F)}return O}function D1(z){return z.map(E1)}class w{_subscribers=[];subscribe(z){return this._subscribers.push(z),()=>{let B=this._subscribers.indexOf(z);if(B>-1)this._subscribers.splice(B,1)}}constructor(){this._subscribers=[]}emit(z){this._subscribers.forEach((B)=>B(z))}static create(){let z=new w;return{property:z,emit:(B)=>z.emit(B)}}}class i extends Error{name;code;source;cause;context;constructor(z,B,R){super(B);if(this.name=z,this.code=R?.code,this.source=R?.source??"UNKNOWN",this.cause=R?.cause,this.context=R?.context,Error.captureStackTrace)Error.captureStackTrace(this,this.constructor)}toJSON(){return{name:this.name,message:this.message,code:this.code,source:this.source,context:this.context,cause:this.cause instanceof Error?{name:this.cause.name,message:this.cause.message}:this.cause,stack:this.stack}}toString(){let z=`[${this.source}] ${this.name}: ${this.message}`;if(this.code)z+=` (Code: ${this.code})`;if(this.context)z+=`
2
+ Context: ${JSON.stringify(this.context,null,2)}`;return z}}class D extends i{constructor(z,B){super("RpcError",z,{...B,source:B?.source??"RPC_REQUEST"})}static connectionFailed(z,B){return new D("Failed to connect to RPC endpoint",{code:"RPC_CONNECTION_FAILED",source:"RPC_CONNECTION",cause:B,context:{url:z}})}static timeout(z,B){return new D("RPC request timed out",{code:"RPC_TIMEOUT",source:"RPC_TIMEOUT",context:{method:z,timeout:B}})}static invalidResponse(z,B){return new D("Invalid RPC response",{code:"RPC_INVALID_RESPONSE",source:"RPC_RESPONSE",context:{method:z,response:B}})}static fromJsonRpcError(z){return new D(z.message,{code:z.code,source:"RPC_RESPONSE",context:{data:z.data}})}static websocketError(z,B){return new D(z,{code:"RPC_WEBSOCKET_ERROR",source:"RPC_WEBSOCKET",cause:B})}}class s{rpcUrl;requestId=0;websocket=null;websocketConnected=!1;pendingResponses={};subscriptionListeners={};reconnectAttempt=0;initialBackoff=2000;maxBackoff=120000;constructor(z){this.rpcUrl=z}async call(z,B){this.requestId++;let R={jsonrpc:"2.0",id:this.requestId,method:z,params:B};try{let O=await fetch(this.rpcUrl,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(R)});if(!O.ok)throw D.connectionFailed(this.rpcUrl,Error(`HTTP ${O.status}: ${O.statusText}`));let _=await O.json();if(_.error)throw D.fromJsonRpcError(_.error);if(_.result===void 0)throw D.invalidResponse(z,_);return _.result}catch(O){if(O instanceof D)throw O;throw D.connectionFailed(this.rpcUrl,O)}}setRpcUrl(z){this.rpcUrl=z}getRpcUrl(){return this.rpcUrl}connect(){return new Promise((z)=>{let B=this.rpcUrl.replace("http","ws");if(B.endsWith("/"))B+="ws";else B+="/ws";this.websocket=new WebSocket(B),this.websocket.onopen=()=>{console.log("WebSocket connected"),this.websocketConnected=!0,this.reconnectAttempt=0,z()},this.websocket.onmessage=(R)=>{let O=JSON.parse(R.data),{id:_,method:F,params:H}=O;if(_!==void 0&&this.pendingResponses[_])this.pendingResponses[_].resolve(O),delete this.pendingResponses[_];if(F==="eth_subscription"&&H){let{subscription:L,result:j}=H;if(this.subscriptionListeners[L])this.subscriptionListeners[L].forEach((N)=>N(j))}},this.websocket.onclose=()=>{console.warn("WebSocket closed"),this.websocketConnected=!1},this.websocket.onerror=(R)=>{console.error("WebSocket error:",R),this.websocketConnected=!1,this.scheduleReconnect()}})}scheduleReconnect(){let z=Math.min(this.initialBackoff*Math.pow(2,this.reconnectAttempt),this.maxBackoff),B=z*(Math.random()*0.5),R=z+B;console.log(`Reconnecting in ${Math.round(R)}ms (attempt #${this.reconnectAttempt+1})`),this.reconnectAttempt++,setTimeout(()=>{this.reconnect()},R)}async reconnect(){if(this.websocketConnected)return;try{await this.connect(),console.log("Reconnection successful")}catch(z){console.error("Reconnection attempt failed:",z),this.scheduleReconnect()}}sendMessage(z,B,R=5000){if(!this.websocket||this.websocket.readyState!==WebSocket.OPEN)return Promise.reject(D.connectionFailed(this.rpcUrl));let O=this.requestId++,_={jsonrpc:"2.0",method:z,params:B,id:O};return new Promise((F,H)=>{this.pendingResponses[O]={resolve:F,reject:H},this.websocket.send(JSON.stringify(_)),setTimeout(()=>{if(this.pendingResponses[O])this.pendingResponses[O].reject(D.timeout(z,R)),delete this.pendingResponses[O]},R)})}async subscribe(z){let B=z?.toLowerCase();if(!this.websocketConnected)await this.connect();let R=w.create(),O=JSON.stringify(B?{address:B}:{}),_=(await this.sendMessage("eth_subscribe",["circles",O])).result;if(!this.subscriptionListeners[_])this.subscriptionListeners[_]=[];return this.subscriptionListeners[_].push((F)=>{D1(F).forEach((H)=>R.emit(H))}),R.property}}var I=BigInt(4294967295),Y=BigInt(32);function q1(z,B=!1){if(B)return{h:Number(z&I),l:Number(z>>Y&I)};return{h:Number(z>>Y&I)|0,l:Number(z&I)|0}}function U1(z,B=!1){let R=z.length,O=new Uint32Array(R),_=new Uint32Array(R);for(let F=0;F<R;F++){let{h:H,l:L}=q1(z[F],B);[O[F],_[F]]=[H,L]}return[O,_]}var V1=(z,B,R)=>z<<R|B>>>32-R,X1=(z,B,R)=>B<<R|z>>>32-R,A1=(z,B,R)=>B<<R-32|z>>>64-R,T1=(z,B,R)=>z<<R-32|B>>>64-R;/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */function y1(z){return z instanceof Uint8Array||ArrayBuffer.isView(z)&&z.constructor.name==="Uint8Array"}function l(z){if(!Number.isSafeInteger(z)||z<0)throw Error("positive integer expected, got "+z)}function k(z,...B){if(!y1(z))throw Error("Uint8Array expected");if(B.length>0&&!B.includes(z.length))throw Error("Uint8Array expected of length "+B+", got length="+z.length)}function p(z,B=!0){if(z.destroyed)throw Error("Hash instance has been destroyed");if(B&&z.finished)throw Error("Hash#digest() has already been called")}function Q1(z,B){k(z);let R=B.outputLen;if(z.length<R)throw Error("digestInto() expects output buffer of length at least "+R)}function S1(z){return new Uint32Array(z.buffer,z.byteOffset,Math.floor(z.byteLength/4))}function d(...z){for(let B=0;B<z.length;B++)z[B].fill(0)}var v1=(()=>new Uint8Array(new Uint32Array([287454020]).buffer)[0]===68)();function I1(z){return z<<24&4278190080|z<<8&16711680|z>>>8&65280|z>>>24&255}function k1(z){for(let B=0;B<z.length;B++)z[B]=I1(z[B]);return z}var G=v1?(z)=>z:k1;function g1(z){if(typeof z!=="string")throw Error("string expected");return new Uint8Array(new TextEncoder().encode(z))}function n(z){if(typeof z==="string")z=g1(z);return k(z),z}class o{}function w1(z){let B=(O)=>z().update(n(O)).digest(),R=z();return B.outputLen=R.outputLen,B.blockLen=R.blockLen,B.create=()=>z(),B}var M1=BigInt(0),Q=BigInt(1),h1=BigInt(2),b1=BigInt(7),W1=BigInt(256),m1=BigInt(113),a=[],Z=[],t=[];for(let z=0,B=Q,R=1,O=0;z<24;z++){[R,O]=[O,(2*R+3*O)%5],a.push(2*(5*O+R)),Z.push((z+1)*(z+2)/2%64);let _=M1;for(let F=0;F<7;F++)if(B=(B<<Q^(B>>b1)*m1)%W1,B&h1)_^=Q<<(Q<<BigInt(F))-Q;t.push(_)}var r=U1(t,!0),K1=r[0],u1=r[1],c=(z,B,R)=>R>32?A1(z,B,R):V1(z,B,R),$=(z,B,R)=>R>32?T1(z,B,R):X1(z,B,R);function f1(z,B=24){let R=new Uint32Array(10);for(let O=24-B;O<24;O++){for(let H=0;H<10;H++)R[H]=z[H]^z[H+10]^z[H+20]^z[H+30]^z[H+40];for(let H=0;H<10;H+=2){let L=(H+8)%10,j=(H+2)%10,N=R[j],E=R[j+1],X=c(N,E,1)^R[L],A=$(N,E,1)^R[L+1];for(let T=0;T<50;T+=10)z[H+T]^=X,z[H+T+1]^=A}let _=z[2],F=z[3];for(let H=0;H<24;H++){let L=Z[H],j=c(_,F,L),N=$(_,F,L),E=a[H];_=z[E],F=z[E+1],z[E]=j,z[E+1]=N}for(let H=0;H<50;H+=10){for(let L=0;L<10;L++)R[L]=z[H+L];for(let L=0;L<10;L++)z[H+L]^=~R[(L+2)%10]&R[(L+4)%10]}z[0]^=K1[O],z[1]^=u1[O]}d(R)}class M extends o{constructor(z,B,R,O=!1,_=24){super();if(this.pos=0,this.posOut=0,this.finished=!1,this.destroyed=!1,this.enableXOF=!1,this.blockLen=z,this.suffix=B,this.outputLen=R,this.enableXOF=O,this.rounds=_,l(R),!(0<z&&z<200))throw Error("only keccak-f1600 function is supported");this.state=new Uint8Array(200),this.state32=S1(this.state)}clone(){return this._cloneInto()}keccak(){G(this.state32),f1(this.state32,this.rounds),G(this.state32),this.posOut=0,this.pos=0}update(z){p(this),z=n(z),k(z);let{blockLen:B,state:R}=this,O=z.length;for(let _=0;_<O;){let F=Math.min(B-this.pos,O-_);for(let H=0;H<F;H++)R[this.pos++]^=z[_++];if(this.pos===B)this.keccak()}return this}finish(){if(this.finished)return;this.finished=!0;let{state:z,suffix:B,pos:R,blockLen:O}=this;if(z[R]^=B,(B&128)!==0&&R===O-1)this.keccak();z[O-1]^=128,this.keccak()}writeInto(z){p(this,!1),k(z),this.finish();let B=this.state,{blockLen:R}=this;for(let O=0,_=z.length;O<_;){if(this.posOut>=R)this.keccak();let F=Math.min(R-this.posOut,_-O);z.set(B.subarray(this.posOut,this.posOut+F),O),this.posOut+=F,O+=F}return z}xofInto(z){if(!this.enableXOF)throw Error("XOF is not possible for this instance");return this.writeInto(z)}xof(z){return l(z),this.xofInto(new Uint8Array(z))}digestInto(z){if(Q1(z,this),this.finished)throw Error("digest() was already called");return this.writeInto(z),this.destroy(),z}digest(){return this.digestInto(new Uint8Array(this.outputLen))}destroy(){this.destroyed=!0,d(this.state)}_cloneInto(z){let{blockLen:B,suffix:R,outputLen:O,rounds:_,enableXOF:F}=this;return z||(z=new M(B,R,O,F,_)),z.state32.set(this.state32),z.pos=this.pos,z.posOut=this.posOut,z.finished=this.finished,z.rounds=_,z.suffix=R,z.outputLen=O,z.enableXOF=F,z.destroyed=this.destroyed,z}}var x1=(z,B,R)=>w1(()=>new M(B,z,R)),Y1=(()=>x1(1,136,32))(),e=[];for(let z=0;z<256;z++)e[z]=z.toString(16).padStart(2,"0");function l1(z){let B="0x";for(let R=0;R<z.length;R++)B+=e[z[R]];return B}function p1(z){let B=z.toLowerCase().replace("0x",""),R=l1(Y1(new TextEncoder().encode(B))).slice(2),O="0x";for(let _=0;_<B.length;_++)O+=parseInt(R[_],16)>=8?B[_].toUpperCase():B[_];return O}function C(z){return z.toLowerCase()}function G1(z){return p1(z)}function c1(z){if(typeof z!=="string")return!1;let B=z.replace("0x","");return B.length===40&&/^[0-9a-fA-F]{40}$/.test(B)}function P(z){if(z===null||z===void 0)return z;if(c1(z))return G1(z);if(Array.isArray(z))return z.map((B)=>P(B));if(typeof z==="object"&&z!==null){let B={};for(let R in z)if(Object.prototype.hasOwnProperty.call(z,R))B[R]=P(z[R]);return B}return z}function $1(z){return{Source:C(z.from),Sink:C(z.to),TargetFlow:z.targetFlow.toString(),WithWrap:z.useWrappedBalances,FromTokens:z.fromTokens?.map(C),ToTokens:z.toTokens?.map(C),ExcludedFromTokens:z.excludeFromTokens?.map(C),ExcludedToTokens:z.excludeToTokens?.map(C),SimulatedBalances:z.simulatedBalances?.map((B)=>({Holder:C(B.holder),Token:C(B.token),Amount:B.amount.toString(),IsWrapped:B.isWrapped,IsStatic:B.isStatic})),SimulatedTrusts:z.simulatedTrusts?.map((B)=>({Truster:C(B.truster),Trustee:C(B.trustee)})),MaxTransfers:z.maxTransfers}}function v(z){let B={};for(let R in z){let O=z[R];if(O===null||O===void 0)B[R]=O;else if(typeof O==="string"&&/^\d+$/.test(O))B[R]=BigInt(O);else if(typeof O==="object"&&!Array.isArray(O))B[R]=v(O);else if(Array.isArray(O))B[R]=O.map((_)=>typeof _==="object"&&_!==null?v(_):_);else B[R]=O}return B}var _3=BigInt(96)*BigInt(1000000000000000000),i1=BigInt("9999999999999999999999999999999999999");class J{client;constructor(z){this.client=z}async findPath(z){let B=$1(z),R=await this.client.call("circlesV2_findPath",[B]),O=v(R);return P(O)}async findMaxFlow(z){let B=await this.findPath({...z,targetFlow:i1});return BigInt(B.maxFlow)}}class z1{client;constructor(z){this.client=z}async query(z){let B=await this.client.call("circles_query",[z]);return P(B)}async tables(){return this.client.call("circles_tables",[])}async events(z,B,R=null,O=null,_=!1){let F=await this.client.call("circles_events",[z,B,R,O,_]);return P(F)}}var s1=[{name:"blockNumber",sortOrder:"DESC"},{name:"transactionIndex",sortOrder:"DESC"},{name:"logIndex",sortOrder:"DESC"}];class U{params;client;rowTransformer;cursorColumns;orderColumns;get currentPage(){return this._currentPage}_currentPage;constructor(z,B,R){this.client=z,this.params=B,this.rowTransformer=R||B.rowTransformer,this.orderColumns=B.orderColumns,this.cursorColumns=B.cursorColumns||this.buildEventCursorColumns()}buildEventCursorColumns(){let z=s1.map((B)=>({...B,sortOrder:this.params.sortOrder}));if(this.params.table==="TransferBatch")z.push({name:"batchIndex",sortOrder:this.params.sortOrder});return z}transformCursorValue(z,B){if(B)return B(z);if(typeof z==="bigint")return z.toString();return z}createEqualityPredicate(z,B){return{Type:"FilterPredicate",FilterType:"Equals",Column:z.name,Value:this.transformCursorValue(B,z.toValue)}}createComparisonPredicate(z,B){return{Type:"FilterPredicate",FilterType:z.sortOrder==="ASC"?"GreaterThan":"LessThan",Column:z.name,Value:this.transformCursorValue(B,z.toValue)}}buildCursorFilter(z){if(!z)return[];let B=[];for(let R=0;R<this.cursorColumns.length;R++){let O=this.cursorColumns[R],_=z[O.name];if(_===void 0)continue;if(R===0)B.push(this.createComparisonPredicate(O,_));else{let F=[];for(let H=0;H<R;H++){let L=this.cursorColumns[H],j=z[L.name];if(j!==void 0)F.push(this.createEqualityPredicate(L,j))}F.push(this.createComparisonPredicate(O,_)),B.push({Type:"Conjunction",ConjunctionType:"And",Predicates:F})}}if(B.length===0)return[];return[{Type:"Conjunction",ConjunctionType:"Or",Predicates:B}]}buildOrderBy(){if(this.orderColumns&&this.orderColumns.length>0)return this.orderColumns;return this.cursorColumns.map((z)=>({Column:z.name,SortOrder:z.sortOrder}))}combineFilters(z,B){if(!z?.length&&!B?.length)return[];if(!z?.length)return B||[];if(!B?.length)return z;return[{Type:"Conjunction",ConjunctionType:"And",Predicates:[...z,...B]}]}rowsToObjects(z){let{columns:B,rows:R}=z;return R.map((O)=>{let _={};return B.forEach((F,H)=>{_[F]=O[H]}),this.rowTransformer?this.rowTransformer(_):_})}rowToCursor(z){let B={};for(let R of this.cursorColumns)B[R.name]=z[R.name];return B}getCursors(z){if(z.length===0)return{};return{first:this.rowToCursor(z[0]),last:this.rowToCursor(z[z.length-1])}}async queryNextPage(){let z=this.buildCursorFilter(this._currentPage?.lastCursor),B=this.combineFilters(this.params.filter,z),R={Namespace:this.params.namespace,Table:this.params.table,Columns:this.params.columns,Filter:B,Order:this.buildOrderBy(),Limit:this.params.limit},O=await this.client.call("circles_query",[R]),_=this.rowsToObjects(O),F=this.getCursors(_);return this._currentPage={limit:this.params.limit,size:_.length,firstCursor:F.first,lastCursor:F.last,sortOrder:this.params.sortOrder,hasMore:_.length===this.params.limit,results:_},_.length>0}reset(){this._currentPage=void 0}}class B1{client;constructor(z){this.client=z}transformQueryResponse(z){let{columns:B,rows:R}=z;return R.map((O)=>{let _={};return B.forEach((F,H)=>{_[F]=O[H]}),_})}async getCommonTrust(z,B){let R=await this.client.call("circles_getCommonTrust",[C(z),C(B)]);return P(R)}getTrustRelations(z,B=100,R="DESC"){let O=C(z),_=[{Type:"Conjunction",ConjunctionType:"And",Predicates:[{Type:"FilterPredicate",FilterType:"Equals",Column:"version",Value:2},{Type:"Conjunction",ConjunctionType:"Or",Predicates:[{Type:"FilterPredicate",FilterType:"Equals",Column:"trustee",Value:O},{Type:"FilterPredicate",FilterType:"Equals",Column:"truster",Value:O}]}]}];return new U(this.client,{namespace:"V_Crc",table:"TrustRelations",sortOrder:R,columns:["blockNumber","timestamp","transactionIndex","logIndex","transactionHash","version","trustee","truster","expiryTime"],filter:_,limit:B},(F)=>P(F))}async getAggregatedTrustRelations(z){let B=C(z),R=this.getTrustRelations(B,1000),O=[];while(await R.queryNextPage())if(O.push(...R.currentPage.results),!R.currentPage.hasMore)break;let _={};O.forEach((H)=>{let L=C(H.truster),j=C(H.trustee),N=L!==B?H.truster:H.trustee;if(!_[N])_[N]=[];_[N].push(H)});let F=Object.entries(_).filter(([H])=>C(H)!==B).map(([H,L])=>{let j=Math.max(...L.map((E)=>E.timestamp)),N;if(L.length===2)N="mutuallyTrusts";else if(C(L[0]?.trustee)===B)N="trustedBy";else if(C(L[0]?.truster)===B)N="trusts";else throw Error("Unexpected trust list row. Couldn't determine trust relation.");return{subjectAvatar:B,relation:N,objectAvatar:H,timestamp:j}});return P(F)}async getTrustedBy(z){let B=C(z),R=(await this.getAggregatedTrustRelations(B)).filter((O)=>O.relation==="trustedBy");return P(R)}async getTrusts(z){let B=C(z),R=(await this.getAggregatedTrustRelations(B)).filter((O)=>O.relation==="trusts");return P(R)}async getMutualTrusts(z){let B=C(z),R=(await this.getAggregatedTrustRelations(B)).filter((O)=>O.relation==="mutuallyTrusts");return P(R)}}class V{static ONE_64=1n<<64n;static GAMMA_64=18443079296116538654n;static BETA_64=18450409579521241655n;static SECONDS_PER_DAY=86400n;static INFLATION_DAY_ZERO_UNIX=1602720000n;static ATTO_FACTOR=1000000000000000000n;static FACTOR_1E12=1000000000000n;static V1_ACCURACY=100000000n;static V1_INFLATION_PCT_NUM=107n;static V1_INFLATION_PCT_DEN=100n;static PERIOD_SEC=31556952n;static mul64(z,B){return z*B>>64n}static mulU(z,B){return z*B>>64n}static pow64(z,B){let R=z,O=B,_=this.ONE_64;while(O>0n){if((O&1n)===1n)_=this.mul64(_,R);R=this.mul64(R,R),O>>=1n}return _}static ONE_36=1000000000000000000000000000000000000000n;static GAMMA_36=999801332008598957430613406568191166n;static BETA_36=1000198707468214629156271489013303962n;static mul36(z,B){return z*B/this.ONE_36}static pow36(z,B){let R=this.ONE_36,O=z,_=B;while(_>0n){if((_&1n)===1n)R=this.mul36(R,O);O=this.mul36(O,O),_>>=1n}return R}static attoCirclesToCircles(z){if(z===0n)return 0;let B=z/this.ATTO_FACTOR,R=z%this.ATTO_FACTOR,O=BigInt(Number.MAX_SAFE_INTEGER);if(B>O||B<-O)throw RangeError("Atto value’s integer component exceeds JS double precision.");return Number(B)+Number(R)/Number(this.ATTO_FACTOR)}static circlesToAttoCircles(z){return BigInt(Math.trunc(z*Number(this.ATTO_FACTOR)))}static inflationaryToDemurrage(z,B){return this.mulU(this.pow64(this.GAMMA_64,B),z)}static demurrageToInflationary(z,B){return this.mulU(this.pow64(this.BETA_64,B),z)}static dayFromTimestamp(z){return(z-this.INFLATION_DAY_ZERO_UNIX)/this.SECONDS_PER_DAY}static attoCirclesToAttoStaticCircles(z,B=BigInt(Math.floor(Date.now()/1000))){return this.demurrageToInflationary(z,this.dayFromTimestamp(B))}static attoStaticCirclesToAttoCircles(z,B=BigInt(Math.floor(Date.now()/1000))){return this.inflationaryToDemurrage(z,this.dayFromTimestamp(B))}static inflationaryToDemurrageExact(z,B){let R=this.pow36(this.GAMMA_36,B);return z*R/this.ONE_36}static demurrageToInflationaryExact(z,B){let R=this.pow36(this.BETA_36,B);return z*R/this.ONE_36}static attoCirclesToAttoStaticCirclesExact(z,B=BigInt(Math.floor(Date.now()/1000))){let R=this.dayFromTimestamp(B);return this.demurrageToInflationaryExact(z,R)}static attoStaticCirclesToAttoCirclesExact(z,B=BigInt(Math.floor(Date.now()/1000))){let R=this.dayFromTimestamp(B);return this.inflationaryToDemurrageExact(z,R)}static truncateToInt64(z){let B=z/this.FACTOR_1E12,R=9223372036854775807n;return B>R?R:B}static blowUpToBigInt(z){return z*this.FACTOR_1E12}static truncateToSixDecimals(z){return this.blowUpToBigInt(this.truncateToInt64(z))}static v1InflateFactor(z){if(z===0n)return this.V1_ACCURACY;return this.V1_ACCURACY*this.V1_INFLATION_PCT_NUM**z/this.V1_INFLATION_PCT_DEN**z}static attoCrcToAttoCircles(z,B){let R=B-this.INFLATION_DAY_ZERO_UNIX,O=R/this.PERIOD_SEC,_=R%this.PERIOD_SEC,F=this.v1InflateFactor(O),H=this.v1InflateFactor(O+1n);return this.v1ToDemurrage(z,F,H,_,this.PERIOD_SEC)}static attoCirclesToAttoCrc(z,B){let R=B-this.INFLATION_DAY_ZERO_UNIX,O=R/this.PERIOD_SEC,_=R%this.PERIOD_SEC,F=this.v1InflateFactor(O),H=this.v1InflateFactor(O+1n),L=F*(this.PERIOD_SEC-_)+H*_;return z*3n*this.V1_ACCURACY*this.PERIOD_SEC/L}static v1ToDemurrage(z,B,R,O,_){let F=B*(_-O)+R*O;return z*3n*this.V1_ACCURACY*_/F}}class R1{client;constructor(z){this.client=z}async getTotalBalance(z,B=!0){let R=await this.client.call("circlesV2_getTotalBalance",[C(z),B]);return V.circlesToAttoCircles(R)}async getTokenBalances(z){let B=(await this.client.call("circles_getTokenBalances",[C(z)])).map((R)=>v(R));return P(B)}}class O1{client;constructor(z){this.client=z}async getAvatarInfo(z){let B=await this.getAvatarInfoBatch([z]);return B.length>0?B[0]:void 0}async getAvatarInfoBatch(z){if(z.length===0)return[];let B=z.map((O)=>C(O)),R=await this.client.call("circles_getAvatarInfoBatch",[B]);return P(R)}async getNetworkSnapshot(){let z=await this.client.call("circles_getNetworkSnapshot",[]);return P(z)}}class _1{client;constructor(z){this.client=z}async getProfileByCid(z){return this.client.call("circles_getProfileByCid",[z])}async getProfileByCidBatch(z){return this.client.call("circles_getProfileByCidBatch",[z])}async getProfileByAddress(z){return this.client.call("circles_getProfileByAddress",[C(z)])}async getProfileByAddressBatch(z){return this.client.call("circles_getProfileByAddressBatch",[z.map((B)=>B===null?null:C(B))])}async searchProfiles(z,B=10,R=0,O){return this.client.call("circles_searchProfiles",[z.toLowerCase(),B,R,O])}async searchByAddressOrName(z,B=10,R=0,O){let _=[],F=/^0x[a-fA-F0-9]{40}$/.test(z);if(F)try{let H=await this.getProfileByAddress(z);if(H){let L={...H,address:z};if(!O||!L.avatarType||O.includes(L.avatarType))_.push(L)}}catch(H){console.warn("Failed to get profile by address:",H)}try{let H=await this.searchProfiles(z,B,R,O);if(F&&_.length>0){let L=z.toLowerCase(),j=H.filter((N)=>N.address?.toLowerCase()!==L);_.push(...j)}else _.push(...H)}catch(H){console.warn("Failed to search profiles by text:",H)}return _.slice(0,B)}}class F1{client;constructor(z){this.client=z}async getTokenInfo(z){let B=await this.getTokenInfoBatch([z]);return B.length>0?B[0]:void 0}async getTokenInfoBatch(z){if(z.length===0)return[];let B=z.map((O)=>C(O)),R=(await this.client.call("circles_getTokenInfoBatch",[B])).map((O)=>v(O));return P(R)}getTokenHolders(z,B=100,R="DESC"){let O=C(z);return new U(this.client,{namespace:"V_CrcV2",table:"BalancesByAccountAndToken",columns:["account","tokenAddress","demurragedTotalBalance"],filter:[{Type:"FilterPredicate",FilterType:"Equals",Column:"tokenAddress",Value:O}],cursorColumns:[{name:"demurragedTotalBalance",sortOrder:R},{name:"account",sortOrder:"ASC"}],orderColumns:[{Column:"demurragedTotalBalance",SortOrder:R},{Column:"account",SortOrder:"ASC"}],limit:B,sortOrder:R},(_)=>({account:_.account,tokenAddress:_.tokenAddress,demurragedTotalBalance:_.demurragedTotalBalance}))}}class H1{client;constructor(z){this.client=z}transformQueryResponse(z){let{columns:B,rows:R}=z;return R.map((O)=>{let _={};return B.forEach((F,H)=>{_[F]=O[H]}),_})}async getInvitedBy(z){let B=C(z),R=await this.client.call("circles_query",[{Namespace:"CrcV2",Table:"RegisterHuman",Columns:["inviter"],Filter:[{Type:"FilterPredicate",FilterType:"Equals",Column:"avatar",Value:B}],Order:[{Column:"blockNumber",SortOrder:"DESC"}],Limit:1}]);if(R.length>0)return P(R[0].inviter);return}async getInvitations(z){let B=C(z),R=96,O=await this.client.call("circles_getAvatarInfoBatch",[[B]]);if((O.length>0?O[0]:void 0)?.version===2)return[];let _=await this.client.call("circles_query",[{Namespace:"V_Crc",Table:"TrustRelations",Columns:["truster","trustee"],Filter:[{Type:"Conjunction",ConjunctionType:"And",Predicates:[{Type:"FilterPredicate",FilterType:"Equals",Column:"version",Value:2},{Type:"FilterPredicate",FilterType:"Equals",Column:"trustee",Value:B}]}],Order:[]}]),F=this.transformQueryResponse(_).map((j)=>j.truster);if(F.length===0)return[];let H=await this.client.call("circles_getAvatarInfoBatch",[F]),L=[];for(let j of H){if(!j?.isHuman)continue;let N=(await this.client.call("circles_getTokenBalances",[j.avatar])).find((E)=>C(E.tokenAddress)===C(j.avatar));if(N&&N.circles>=96)L.push(j)}return P(L)}async getInvitationsFrom(z,B=!1){let R=C(z);if(B){let O=await this.client.call("circles_query",[{Namespace:"CrcV2",Table:"RegisterHuman",Columns:["avatar"],Filter:[{Type:"FilterPredicate",FilterType:"Equals",Column:"inviter",Value:R}],Order:[{Column:"blockNumber",SortOrder:"DESC"}]}]),_=this.transformQueryResponse(O).map((F)=>F.avatar);return P(_)}else{let O=await this.client.call("circles_query",[{Namespace:"V_Crc",Table:"TrustRelations",Columns:["trustee","truster"],Filter:[{Type:"Conjunction",ConjunctionType:"And",Predicates:[{Type:"FilterPredicate",FilterType:"Equals",Column:"version",Value:2},{Type:"FilterPredicate",FilterType:"Equals",Column:"truster",Value:R}]}],Order:[]}]),_=this.transformQueryResponse(O).map((j)=>j.trustee);if(_.length===0)return[];let F=await this.client.call("circles_getAvatarInfoBatch",[_]),H=new Set(F.filter((j)=>j!==null).map((j)=>C(j.avatar))),L=_.filter((j)=>!H.has(C(j)));return P(L)}}}function d1(z,B){let R=BigInt(z),O=V.attoCirclesToCircles(R),_=V.attoCirclesToAttoCrc(R,BigInt(B)),F=V.attoCirclesToCircles(_),H=V.attoCirclesToAttoStaticCircles(R,BigInt(B)),L=V.attoCirclesToCircles(H);return{attoCircles:R,circles:O,staticAttoCircles:H,staticCircles:L,attoCrc:_,crc:F}}class L1{client;constructor(z){this.client=z}getTransactionHistory(z,B=50,R="DESC"){let O=C(z),_=[{Type:"Conjunction",ConjunctionType:"And",Predicates:[{Type:"FilterPredicate",FilterType:"Equals",Column:"version",Value:2},{Type:"Conjunction",ConjunctionType:"Or",Predicates:[{Type:"FilterPredicate",FilterType:"Equals",Column:"from",Value:O},{Type:"FilterPredicate",FilterType:"Equals",Column:"to",Value:O}]}]}];return new U(this.client,{namespace:"V_Crc",table:"TransferSummary",sortOrder:R,columns:[],filter:_,limit:B},(F)=>{let H=d1(F.value,F.timestamp),L={...F,...H};return P(L)})}}class j1{client;constructor(z){this.client=z}async findGroups(z=50,B){let R=this.getGroups(z,B,"DESC"),O=[];while(await R.queryNextPage()){if(O.push(...R.currentPage.results),O.length>=z)break;if(!R.currentPage.hasMore)break}return O.slice(0,z)}getGroupMemberships(z,B=50,R="DESC"){let O=C(z);return new U(this.client,{namespace:"V_CrcV2",table:"GroupMemberships",sortOrder:R,columns:["blockNumber","timestamp","transactionIndex","logIndex","transactionHash","group","member","expiryTime"],filter:[{Type:"FilterPredicate",FilterType:"Equals",Column:"member",Value:O}],limit:B},(_)=>P(_))}getGroupHolders(z,B=100){let R=C(z);return new U(this.client,{namespace:"V_CrcV2",table:"GroupTokenHoldersBalance",sortOrder:"DESC",columns:["group","holder","totalBalance","demurragedTotalBalance","fractionOwnership"],cursorColumns:[{name:"holder",sortOrder:"ASC"}],orderColumns:[{Column:"totalBalance",SortOrder:"DESC"},{Column:"holder",SortOrder:"ASC"}],filter:[{Type:"FilterPredicate",FilterType:"Equals",Column:"group",Value:R}],limit:B,rowTransformer:(O)=>{let _={...O,totalBalance:BigInt(O.totalBalance),demurragedTotalBalance:BigInt(O.demurragedTotalBalance)};return P(_)}})}getGroupMembers(z,B=100,R="DESC"){let O=C(z);return new U(this.client,{namespace:"V_CrcV2",table:"GroupMemberships",sortOrder:R,columns:["blockNumber","timestamp","transactionIndex","logIndex","transactionHash","group","member","expiryTime"],filter:[{Type:"FilterPredicate",FilterType:"Equals",Column:"group",Value:O}],limit:B},(_)=>P(_))}getGroups(z=50,B,R="DESC"){let O=[];if(B){if(B.nameStartsWith)O.push({Type:"FilterPredicate",FilterType:"Like",Column:"name",Value:B.nameStartsWith+"%"});if(B.symbolStartsWith)O.push({Type:"FilterPredicate",FilterType:"Like",Column:"symbol",Value:B.symbolStartsWith+"%"});if(B.groupAddressIn&&B.groupAddressIn.length>0){let F=B.groupAddressIn.map((H)=>({Type:"FilterPredicate",FilterType:"Equals",Column:"group",Value:C(H)}));if(F.length===1)O.push(F[0]);else O.push({Type:"Conjunction",ConjunctionType:"Or",Predicates:F})}if(B.groupTypeIn&&B.groupTypeIn.length>0){let F=B.groupTypeIn.map((H)=>({Type:"FilterPredicate",FilterType:"Equals",Column:"type",Value:H}));if(F.length===1)O.push(F[0]);else O.push({Type:"Conjunction",ConjunctionType:"Or",Predicates:F})}if(B.ownerIn&&B.ownerIn.length>0){let F=B.ownerIn.map((H)=>({Type:"FilterPredicate",FilterType:"Equals",Column:"owner",Value:C(H)}));if(F.length===1)O.push(F[0]);else O.push({Type:"Conjunction",ConjunctionType:"Or",Predicates:F})}if(B.mintHandlerEquals)O.push({Type:"FilterPredicate",FilterType:"Equals",Column:"mintHandler",Value:C(B.mintHandlerEquals)});if(B.treasuryEquals)O.push({Type:"FilterPredicate",FilterType:"Equals",Column:"treasury",Value:C(B.treasuryEquals)})}let _=O.length>1?[{Type:"Conjunction",ConjunctionType:"And",Predicates:O}]:O;return new U(this.client,{namespace:"V_CrcV2",table:"Groups",sortOrder:R,columns:["blockNumber","timestamp","transactionIndex","logIndex","transactionHash","group","type","owner","mintPolicy","mintHandler","treasury","service","feeCollection","memberCount","name","symbol","cidV0Digest","erc20WrapperDemurraged","erc20WrapperStatic"],filter:_,limit:z},(F)=>P(F))}}class h{client;_pathfinder;_query;_trust;_balance;_avatar;_profile;_token;_invitation;_transaction;_group;constructor(z="https://rpc.circlesubi.network/"){this.client=new s(z)}get pathfinder(){if(!this._pathfinder)this._pathfinder=new J(this.client);return this._pathfinder}get query(){if(!this._query)this._query=new z1(this.client);return this._query}get trust(){if(!this._trust)this._trust=new B1(this.client);return this._trust}get balance(){if(!this._balance)this._balance=new R1(this.client);return this._balance}get avatar(){if(!this._avatar)this._avatar=new O1(this.client);return this._avatar}get profile(){if(!this._profile)this._profile=new _1(this.client);return this._profile}get token(){if(!this._token)this._token=new F1(this.client);return this._token}get invitation(){if(!this._invitation)this._invitation=new H1(this.client);return this._invitation}get transaction(){if(!this._transaction)this._transaction=new L1(this.client);return this._transaction}get group(){if(!this._group)this._group=new j1(this.client);return this._group}setRpcUrl(z){this.client.setRpcUrl(z)}getRpcUrl(){return this.client.getRpcUrl()}}class b{static ONE_64=1n<<64n;static GAMMA_64=18443079296116538654n;static BETA_64=18450409579521241655n;static SECONDS_PER_DAY=86400n;static INFLATION_DAY_ZERO_UNIX=1602720000n;static ATTO_FACTOR=1000000000000000000n;static FACTOR_1E12=1000000000000n;static V1_ACCURACY=100000000n;static V1_INFLATION_PCT_NUM=107n;static V1_INFLATION_PCT_DEN=100n;static PERIOD_SEC=31556952n;static mul64(z,B){return z*B>>64n}static mulU(z,B){return z*B>>64n}static pow64(z,B){let R=z,O=B,_=this.ONE_64;while(O>0n){if((O&1n)===1n)_=this.mul64(_,R);R=this.mul64(R,R),O>>=1n}return _}static ONE_36=1000000000000000000000000000000000000000n;static GAMMA_36=999801332008598957430613406568191166n;static BETA_36=1000198707468214629156271489013303962n;static mul36(z,B){return z*B/this.ONE_36}static pow36(z,B){let R=this.ONE_36,O=z,_=B;while(_>0n){if((_&1n)===1n)R=this.mul36(R,O);O=this.mul36(O,O),_>>=1n}return R}static attoCirclesToCircles(z){if(z===0n)return 0;let B=z/this.ATTO_FACTOR,R=z%this.ATTO_FACTOR,O=BigInt(Number.MAX_SAFE_INTEGER);if(B>O||B<-O)throw RangeError("Atto value’s integer component exceeds JS double precision.");return Number(B)+Number(R)/Number(this.ATTO_FACTOR)}static circlesToAttoCircles(z){return BigInt(Math.trunc(z*Number(this.ATTO_FACTOR)))}static inflationaryToDemurrage(z,B){return this.mulU(this.pow64(this.GAMMA_64,B),z)}static demurrageToInflationary(z,B){return this.mulU(this.pow64(this.BETA_64,B),z)}static dayFromTimestamp(z){return(z-this.INFLATION_DAY_ZERO_UNIX)/this.SECONDS_PER_DAY}static attoCirclesToAttoStaticCircles(z,B=BigInt(Math.floor(Date.now()/1000))){return this.demurrageToInflationary(z,this.dayFromTimestamp(B))}static attoStaticCirclesToAttoCircles(z,B=BigInt(Math.floor(Date.now()/1000))){return this.inflationaryToDemurrage(z,this.dayFromTimestamp(B))}static inflationaryToDemurrageExact(z,B){let R=this.pow36(this.GAMMA_36,B);return z*R/this.ONE_36}static demurrageToInflationaryExact(z,B){let R=this.pow36(this.BETA_36,B);return z*R/this.ONE_36}static attoCirclesToAttoStaticCirclesExact(z,B=BigInt(Math.floor(Date.now()/1000))){let R=this.dayFromTimestamp(B);return this.demurrageToInflationaryExact(z,R)}static attoStaticCirclesToAttoCirclesExact(z,B=BigInt(Math.floor(Date.now()/1000))){let R=this.dayFromTimestamp(B);return this.inflationaryToDemurrageExact(z,R)}static truncateToInt64(z){let B=z/this.FACTOR_1E12,R=9223372036854775807n;return B>R?R:B}static blowUpToBigInt(z){return z*this.FACTOR_1E12}static truncateToSixDecimals(z){return this.blowUpToBigInt(this.truncateToInt64(z))}static v1InflateFactor(z){if(z===0n)return this.V1_ACCURACY;return this.V1_ACCURACY*this.V1_INFLATION_PCT_NUM**z/this.V1_INFLATION_PCT_DEN**z}static attoCrcToAttoCircles(z,B){let R=B-this.INFLATION_DAY_ZERO_UNIX,O=R/this.PERIOD_SEC,_=R%this.PERIOD_SEC,F=this.v1InflateFactor(O),H=this.v1InflateFactor(O+1n);return this.v1ToDemurrage(z,F,H,_,this.PERIOD_SEC)}static attoCirclesToAttoCrc(z,B){let R=B-this.INFLATION_DAY_ZERO_UNIX,O=R/this.PERIOD_SEC,_=R%this.PERIOD_SEC,F=this.v1InflateFactor(O),H=this.v1InflateFactor(O+1n),L=F*(this.PERIOD_SEC-_)+H*_;return z*3n*this.V1_ACCURACY*this.PERIOD_SEC/L}static v1ToDemurrage(z,B,R,O,_){let F=B*(_-O)+R*O;return z*3n*this.V1_ACCURACY*_/F}}async function C3(z,B,R){let O=new Map,_=new Set;return R.transfers.forEach((L)=>{if(z.toLowerCase()===L.from.toLowerCase())_.add(L.tokenOwner.toLowerCase())}),(await new h(B).token.getTokenInfoBatch(Array.from(_))).forEach((L)=>{if(L.isWrapped&&!L.isInflationary)L.tokenType="CrcV2_ERC20WrapperDeployed_Demurraged";O.set(L.tokenAddress.toLowerCase(),L)}),O}function N3(z,B){let R={};return z.transfers.forEach((O)=>{let _=B.get(O.tokenOwner.toLowerCase());if(_&&_.tokenType.startsWith("CrcV2_ERC20WrapperDeployed")){if(!R[O.tokenOwner])R[O.tokenOwner]=[BigInt(0),_.tokenType];R[O.tokenOwner][0]+=BigInt(O.value)}}),R}function P3(z,B){let R={};return Object.entries(z).forEach(([O,[_,F]])=>{let H=B.get(O.toLowerCase());if(!H)return;if(F==="CrcV2_ERC20WrapperDeployed_Demurraged")R[O]=[_,H.tokenOwner];if(F==="CrcV2_ERC20WrapperDeployed_Inflationary")R[O]=[b.attoStaticCirclesToAttoCircles(_),H.tokenOwner]}),R}function E3(z,B){let R=z.transfers.map((O)=>{let _=B.get(O.tokenOwner.toLowerCase());if(_&&_.tokenType.startsWith("CrcV2_ERC20WrapperDeployed"))return{...O,tokenOwner:_.tokenOwner};return O});return{...z,transfers:R}}function D3(z,B){let R={};Object.entries(B).forEach(([_,[,F]])=>{R[_.toLowerCase()]=F});let O=z.transfers.map((_)=>{let F=_.tokenOwner.toLowerCase(),H=R[F]||_.tokenOwner;return{..._,tokenOwner:H}});return{...z,transfers:O}}function q3(z,B,R=BigInt(999999999999)){let O=new Map,_=[],F=BigInt(1000000000000);return z.transfers.forEach((L)=>{let j=BigInt(L.value)*R/F;if(j===BigInt(0))return;_.push({...L,value:j}),O.set(L.to,(O.get(L.to)??BigInt(0))+j)}),{maxFlow:B?O.get(B.toLowerCase())??BigInt(0):BigInt(0),transfers:_}}function U3(z,B,R){let O=o1(z),{source:_,sink:F}=n1(z,B,R),H=_===F;O.forEach((L,j)=>{if(H){if(L!==BigInt(0))throw Error(`Vertex ${j} is unbalanced: ${L}`);return}let N=j===_,E=j===F;if(N&&L>=BigInt(0))throw Error(`Source ${j} should be net negative, got ${L}`);if(E&&L<=BigInt(0))throw Error(`Sink ${j} should be net positive, got ${L}`);if(!N&&!E&&L!==BigInt(0))throw Error(`Vertex ${j} is unbalanced: ${L}`)})}function n1(z,B,R){let O=new Set(z.transfers.map((L)=>L.from.toLowerCase())),_=new Set(z.transfers.map((L)=>L.to.toLowerCase())),F=[...O].find((L)=>!_.has(L)),H=[..._].find((L)=>!O.has(L));if(!(F??B)||!(H??R))throw Error("Could not determine unique source / sink");return{source:F??B,sink:H??R}}function o1(z){let B=new Map;return z.transfers.forEach(({from:R,to:O,value:_})=>{let F=BigInt(_);B.set(R.toLowerCase(),(B.get(R.toLowerCase())??BigInt(0))-F),B.set(O.toLowerCase(),(B.get(O.toLowerCase())??BigInt(0))+F)}),B}export{f as transformToFlowVertices,q3 as shrinkPathValues,E3 as replaceWrappedTokensWithAvatars,D3 as replaceWrappedTokens,R3 as prepareFlowMatrixStreams,u as packCoordinates,N3 as getWrappedTokensFromPath,C3 as getTokenInfoMapFromPath,P3 as getExpectedUnwrappedTokenTotals,B3 as createFlowMatrix,o1 as computeNettedFlow,U3 as assertNoNettedFlowMismatch};