@rolly-dev/wasm-signer 1.21.0 → 1.24.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -18,13 +18,22 @@ export function amount_split(amount) {
18
18
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
19
19
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
20
20
  var v1 = getArrayU32FromWasm0(r0, r1).slice();
21
- wasm.__wbindgen_export2(r0, r1 * 4, 4);
21
+ wasm.__wbindgen_export4(r0, r1 * 4, 4);
22
22
  return v1;
23
23
  } finally {
24
24
  wasm.__wbindgen_add_to_stack_pointer(16);
25
25
  }
26
26
  }
27
27
 
28
+ /**
29
+ * Aviato RTP percent (99). Canonical source for backend/frontend.
30
+ * @returns {number}
31
+ */
32
+ export function aviato_rtp_percent() {
33
+ const ret = wasm.aviato_rtp_percent();
34
+ return ret >>> 0;
35
+ }
36
+
28
37
  /**
29
38
  * CoinFlip multiplier × 10000 (19800 = 1.98×). Canonical source for backend/frontend.
30
39
  * @returns {number}
@@ -39,7 +48,7 @@ export function coinflip_multiplier_x10000() {
39
48
  * @returns {number}
40
49
  */
41
50
  export function coinflip_rtp_percent() {
42
- const ret = wasm.coinflip_rtp_percent();
51
+ const ret = wasm.aviato_rtp_percent();
43
52
  return ret >>> 0;
44
53
  }
45
54
 
@@ -52,13 +61,13 @@ export function coinflip_rtp_percent() {
52
61
  export function compute_address_hash(address_hex) {
53
62
  try {
54
63
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
55
- const ptr0 = passStringToWasm0(address_hex, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
64
+ const ptr0 = passStringToWasm0(address_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
56
65
  const len0 = WASM_VECTOR_LEN;
57
66
  wasm.compute_address_hash(retptr, ptr0, len0);
58
67
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
59
68
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
60
69
  var v2 = getArrayU64FromWasm0(r0, r1).slice();
61
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
70
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
62
71
  return v2;
63
72
  } finally {
64
73
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -66,17 +75,17 @@ export function compute_address_hash(address_hex) {
66
75
  }
67
76
 
68
77
  /**
69
- * Extract crash point (×100) from Poseidon2 random output.
78
+ * Extract aviato point (×100) from raw server seed fields.
70
79
  *
71
- * `random` must be exactly 4 elements.
72
- * Returns the clamped crash multiplier ×100 (100..=1_000_000, i.e. 1.00x..10000.00x).
80
+ * `random` must be exactly 4 elements (first 4 fields of server_seed).
81
+ * Returns the clamped aviato multiplier ×100 (100..=1_000_000, i.e. 1.00x..10000.00x).
73
82
  * @param {BigUint64Array} random
74
83
  * @returns {number}
75
84
  */
76
- export function compute_crash_point(random) {
77
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
85
+ export function compute_aviato_point(random) {
86
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
78
87
  const len0 = WASM_VECTOR_LEN;
79
- const ret = wasm.compute_crash_point(ptr0, len0);
88
+ const ret = wasm.compute_aviato_point(ptr0, len0);
80
89
  return ret >>> 0;
81
90
  }
82
91
 
@@ -92,13 +101,13 @@ export function compute_crash_point(random) {
92
101
  export function compute_drawn_keno(random) {
93
102
  try {
94
103
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
95
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
104
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
96
105
  const len0 = WASM_VECTOR_LEN;
97
106
  wasm.compute_drawn_keno(retptr, ptr0, len0);
98
107
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
99
108
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
100
109
  var v2 = getArrayU8FromWasm0(r0, r1).slice();
101
- wasm.__wbindgen_export2(r0, r1 * 1, 1);
110
+ wasm.__wbindgen_export4(r0, r1 * 1, 1);
102
111
  return v2;
103
112
  } finally {
104
113
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -119,28 +128,30 @@ export function compute_multi_dice(win_numbers) {
119
128
  }
120
129
 
121
130
  /**
122
- * Full coinflip payout computation — pure integer arithmetic, zero floats.
131
+ * Full aviato payout computation — pure integer arithmetic, zero floats.
123
132
  *
124
- * `random`: 4 Goldilocks field elements (Poseidon2 output).
133
+ * `random`: 4 Goldilocks field elements (first 4 fields of raw server_seed).
125
134
  * `bet_atomic`: bet in atomic units (1 USDT = 1_000_000).
126
- * `prediction`: 0 or 1.
135
+ * `cashout_x100`: multiplier at which the user cashed out (×100).
136
+ * - 0 = user did NOT cash out (loss).
137
+ * - 100..=1_000_000 = user stopped at this multiplier.
127
138
  *
128
- * Returns `BigUint64Array[4]`: `[win_amount, roll (0|1), is_win (0|1), multiplier×10000]`.
139
+ * Returns `BigUint64Array[4]`: `[win_amount, aviato_x100, is_win (0|1), multiplier×10000]`.
129
140
  * @param {BigUint64Array} random
130
141
  * @param {bigint} bet_atomic
131
- * @param {number} prediction
142
+ * @param {number} cashout_x100
132
143
  * @returns {BigUint64Array}
133
144
  */
134
- export function compute_payout_coinflip(random, bet_atomic, prediction) {
145
+ export function compute_payout_aviato(random, bet_atomic, cashout_x100) {
135
146
  try {
136
147
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
137
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
148
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
138
149
  const len0 = WASM_VECTOR_LEN;
139
- wasm.compute_payout_coinflip(retptr, ptr0, len0, bet_atomic, prediction);
150
+ wasm.compute_payout_aviato(retptr, ptr0, len0, bet_atomic, cashout_x100);
140
151
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
141
152
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
142
153
  var v2 = getArrayU64FromWasm0(r0, r1).slice();
143
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
154
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
144
155
  return v2;
145
156
  } finally {
146
157
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -148,30 +159,28 @@ export function compute_payout_coinflip(random, bet_atomic, prediction) {
148
159
  }
149
160
 
150
161
  /**
151
- * Full crash payout computation — pure integer arithmetic, zero floats.
162
+ * Full coinflip payout computation — pure integer arithmetic, zero floats.
152
163
  *
153
- * `random`: 4 Goldilocks field elements (Poseidon2 output of server_seed).
164
+ * `random`: 4 Goldilocks field elements (Poseidon2 output).
154
165
  * `bet_atomic`: bet in atomic units (1 USDT = 1_000_000).
155
- * `cashout_x100`: multiplier at which the user cashed out (×100).
156
- * - 0 = user did NOT cash out (loss).
157
- * - 100..=1_000_000 = user stopped at this multiplier.
166
+ * `prediction`: 0 or 1.
158
167
  *
159
- * Returns `BigUint64Array[4]`: `[win_amount, crash_x100, is_win (0|1), multiplier×10000]`.
168
+ * Returns `BigUint64Array[4]`: `[win_amount, roll (0|1), is_win (0|1), multiplier×10000]`.
160
169
  * @param {BigUint64Array} random
161
170
  * @param {bigint} bet_atomic
162
- * @param {number} cashout_x100
171
+ * @param {number} prediction
163
172
  * @returns {BigUint64Array}
164
173
  */
165
- export function compute_payout_crash(random, bet_atomic, cashout_x100) {
174
+ export function compute_payout_coinflip(random, bet_atomic, prediction) {
166
175
  try {
167
176
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
168
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
177
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
169
178
  const len0 = WASM_VECTOR_LEN;
170
- wasm.compute_payout_crash(retptr, ptr0, len0, bet_atomic, cashout_x100);
179
+ wasm.compute_payout_coinflip(retptr, ptr0, len0, bet_atomic, prediction);
171
180
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
172
181
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
173
182
  var v2 = getArrayU64FromWasm0(r0, r1).slice();
174
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
183
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
175
184
  return v2;
176
185
  } finally {
177
186
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -197,13 +206,13 @@ export function compute_payout_crash(random, bet_atomic, cashout_x100) {
197
206
  export function compute_payout_dice(random, bet_atomic, game_mode, prediction_lo, prediction_hi) {
198
207
  try {
199
208
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
200
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
209
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
201
210
  const len0 = WASM_VECTOR_LEN;
202
211
  wasm.compute_payout_dice(retptr, ptr0, len0, bet_atomic, game_mode, prediction_lo, prediction_hi);
203
212
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
204
213
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
205
214
  var v2 = getArrayU64FromWasm0(r0, r1).slice();
206
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
215
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
207
216
  return v2;
208
217
  } finally {
209
218
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -228,15 +237,15 @@ export function compute_payout_dice(random, bet_atomic, game_mode, prediction_lo
228
237
  export function compute_payout_keno(random, bet_atomic, risk, selected) {
229
238
  try {
230
239
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
231
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
240
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
232
241
  const len0 = WASM_VECTOR_LEN;
233
- const ptr1 = passArray8ToWasm0(selected, wasm.__wbindgen_export3);
242
+ const ptr1 = passArray8ToWasm0(selected, wasm.__wbindgen_export);
234
243
  const len1 = WASM_VECTOR_LEN;
235
244
  wasm.compute_payout_keno(retptr, ptr0, len0, bet_atomic, risk, ptr1, len1);
236
245
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
237
246
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
238
247
  var v3 = getArrayU64FromWasm0(r0, r1).slice();
239
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
248
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
240
249
  return v3;
241
250
  } finally {
242
251
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -259,13 +268,13 @@ export function compute_payout_keno(random, bet_atomic, risk, selected) {
259
268
  export function compute_payout_limbo(random, bet_atomic, prediction_x100) {
260
269
  try {
261
270
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
262
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
271
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
263
272
  const len0 = WASM_VECTOR_LEN;
264
273
  wasm.compute_payout_limbo(retptr, ptr0, len0, bet_atomic, prediction_x100);
265
274
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
266
275
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
267
276
  var v2 = getArrayU64FromWasm0(r0, r1).slice();
268
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
277
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
269
278
  return v2;
270
279
  } finally {
271
280
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -292,13 +301,13 @@ export function compute_payout_limbo(random, bet_atomic, prediction_x100) {
292
301
  export function compute_payout_plinko(random, bet_atomic, sector, rows, is_extreme) {
293
302
  try {
294
303
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
295
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
304
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
296
305
  const len0 = WASM_VECTOR_LEN;
297
306
  wasm.compute_payout_plinko(retptr, ptr0, len0, bet_atomic, sector, rows, is_extreme);
298
307
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
299
308
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
300
309
  var v2 = getArrayU64FromWasm0(r0, r1).slice();
301
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
310
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
302
311
  return v2;
303
312
  } finally {
304
313
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -329,7 +338,7 @@ export function compute_prediction_hash(game_id, p0, p1, p2) {
329
338
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
330
339
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
331
340
  var v1 = getArrayU64FromWasm0(r0, r1).slice();
332
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
341
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
333
342
  return v1;
334
343
  } finally {
335
344
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -353,13 +362,13 @@ export function compute_prediction_hash(game_id, p0, p1, p2) {
353
362
  export function compute_prediction_hash_keno(game_id, risk, pick_count, selected) {
354
363
  try {
355
364
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
356
- const ptr0 = passArray8ToWasm0(selected, wasm.__wbindgen_export3);
365
+ const ptr0 = passArray8ToWasm0(selected, wasm.__wbindgen_export);
357
366
  const len0 = WASM_VECTOR_LEN;
358
367
  wasm.compute_prediction_hash_keno(retptr, game_id, risk, pick_count, ptr0, len0);
359
368
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
360
369
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
361
370
  var v2 = getArrayU64FromWasm0(r0, r1).slice();
362
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
371
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
363
372
  return v2;
364
373
  } finally {
365
374
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -374,7 +383,7 @@ export function compute_prediction_hash_keno(game_id, risk, pick_count, selected
374
383
  * @returns {number}
375
384
  */
376
385
  export function compute_roll_coinflip(random) {
377
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
386
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
378
387
  const len0 = WASM_VECTOR_LEN;
379
388
  const ret = wasm.compute_roll_coinflip(ptr0, len0);
380
389
  return ret >>> 0;
@@ -388,7 +397,7 @@ export function compute_roll_coinflip(random) {
388
397
  * @returns {number}
389
398
  */
390
399
  export function compute_roll_dice(random) {
391
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
400
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
392
401
  const len0 = WASM_VECTOR_LEN;
393
402
  const ret = wasm.compute_roll_dice(ptr0, len0);
394
403
  return ret >>> 0;
@@ -403,7 +412,7 @@ export function compute_roll_dice(random) {
403
412
  * @returns {number}
404
413
  */
405
414
  export function compute_roll_limbo(random) {
406
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
415
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
407
416
  const len0 = WASM_VECTOR_LEN;
408
417
  const ret = wasm.compute_roll_limbo(ptr0, len0);
409
418
  return ret >>> 0;
@@ -420,7 +429,7 @@ export function compute_roll_limbo(random) {
420
429
  * @returns {number}
421
430
  */
422
431
  export function compute_roll_plinko(random, rows) {
423
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
432
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
424
433
  const len0 = WASM_VECTOR_LEN;
425
434
  const ret = wasm.compute_roll_plinko(ptr0, len0, rows);
426
435
  return ret >>> 0;
@@ -441,13 +450,13 @@ export function compute_roll_plinko(random, rows) {
441
450
  export function compute_server_seed_hash(server_seed) {
442
451
  try {
443
452
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
444
- const ptr0 = passArray64ToWasm0(server_seed, wasm.__wbindgen_export3);
453
+ const ptr0 = passArray64ToWasm0(server_seed, wasm.__wbindgen_export);
445
454
  const len0 = WASM_VECTOR_LEN;
446
455
  wasm.compute_server_seed_hash(retptr, ptr0, len0);
447
456
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
448
457
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
449
458
  var v2 = getArrayU64FromWasm0(r0, r1).slice();
450
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
459
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
451
460
  return v2;
452
461
  } finally {
453
462
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -473,30 +482,21 @@ export function compute_server_seed_hash(server_seed) {
473
482
  export function compute_user_seed_binding(game_id, bet, pred_hash, secret) {
474
483
  try {
475
484
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
476
- const ptr0 = passArray64ToWasm0(pred_hash, wasm.__wbindgen_export3);
485
+ const ptr0 = passArray64ToWasm0(pred_hash, wasm.__wbindgen_export);
477
486
  const len0 = WASM_VECTOR_LEN;
478
- const ptr1 = passArray64ToWasm0(secret, wasm.__wbindgen_export3);
487
+ const ptr1 = passArray64ToWasm0(secret, wasm.__wbindgen_export);
479
488
  const len1 = WASM_VECTOR_LEN;
480
489
  wasm.compute_user_seed_binding(retptr, game_id, bet, ptr0, len0, ptr1, len1);
481
490
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
482
491
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
483
492
  var v3 = getArrayU64FromWasm0(r0, r1).slice();
484
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
493
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
485
494
  return v3;
486
495
  } finally {
487
496
  wasm.__wbindgen_add_to_stack_pointer(16);
488
497
  }
489
498
  }
490
499
 
491
- /**
492
- * Crash RTP percent (99). Canonical source for backend/frontend.
493
- * @returns {number}
494
- */
495
- export function crash_rtp_percent() {
496
- const ret = wasm.coinflip_rtp_percent();
497
- return ret >>> 0;
498
- }
499
-
500
500
  /**
501
501
  * Derive a session key from 32 bytes of entropy (e.g. MetaMask signature).
502
502
  *
@@ -518,13 +518,13 @@ export function crash_rtp_percent() {
518
518
  export function derive_session_key(sig_bytes) {
519
519
  try {
520
520
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
521
- const ptr0 = passArray8ToWasm0(sig_bytes, wasm.__wbindgen_export3);
521
+ const ptr0 = passArray8ToWasm0(sig_bytes, wasm.__wbindgen_export);
522
522
  const len0 = WASM_VECTOR_LEN;
523
523
  wasm.derive_session_key(retptr, ptr0, len0);
524
524
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
525
525
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
526
526
  var v2 = getArrayU64FromWasm0(r0, r1).slice();
527
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
527
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
528
528
  return v2;
529
529
  } finally {
530
530
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -536,7 +536,7 @@ export function derive_session_key(sig_bytes) {
536
536
  * @returns {number}
537
537
  */
538
538
  export function dice_rtp_percent() {
539
- const ret = wasm.coinflip_rtp_percent();
539
+ const ret = wasm.aviato_rtp_percent();
540
540
  return ret >>> 0;
541
541
  }
542
542
 
@@ -552,13 +552,13 @@ export function dice_rtp_percent() {
552
552
  export function encode_keno_selected(selected_1indexed) {
553
553
  try {
554
554
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
555
- const ptr0 = passArray8ToWasm0(selected_1indexed, wasm.__wbindgen_export3);
555
+ const ptr0 = passArray8ToWasm0(selected_1indexed, wasm.__wbindgen_export);
556
556
  const len0 = WASM_VECTOR_LEN;
557
557
  wasm.encode_keno_selected(retptr, ptr0, len0);
558
558
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
559
559
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
560
560
  var v2 = getArrayU32FromWasm0(r0, r1).slice();
561
- wasm.__wbindgen_export2(r0, r1 * 4, 4);
561
+ wasm.__wbindgen_export4(r0, r1 * 4, 4);
562
562
  return v2;
563
563
  } finally {
564
564
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -584,7 +584,7 @@ export function generate_user_secret() {
584
584
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
585
585
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
586
586
  var v1 = getArrayU64FromWasm0(r0, r1).slice();
587
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
587
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
588
588
  return v1;
589
589
  } finally {
590
590
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -616,7 +616,7 @@ export function generate_user_seed() {
616
616
  return getStringFromWasm0(r0, r1);
617
617
  } finally {
618
618
  wasm.__wbindgen_add_to_stack_pointer(16);
619
- wasm.__wbindgen_export2(deferred1_0, deferred1_1, 1);
619
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
620
620
  }
621
621
  }
622
622
 
@@ -637,7 +637,7 @@ export function goldilocks_fields_to_hex(fields) {
637
637
  let deferred2_1;
638
638
  try {
639
639
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
640
- const ptr0 = passArray64ToWasm0(fields, wasm.__wbindgen_export3);
640
+ const ptr0 = passArray64ToWasm0(fields, wasm.__wbindgen_export);
641
641
  const len0 = WASM_VECTOR_LEN;
642
642
  wasm.goldilocks_fields_to_hex(retptr, ptr0, len0);
643
643
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
@@ -647,7 +647,7 @@ export function goldilocks_fields_to_hex(fields) {
647
647
  return getStringFromWasm0(r0, r1);
648
648
  } finally {
649
649
  wasm.__wbindgen_add_to_stack_pointer(16);
650
- wasm.__wbindgen_export2(deferred2_0, deferred2_1, 1);
650
+ wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
651
651
  }
652
652
  }
653
653
 
@@ -693,13 +693,13 @@ export function goldilocks_reduce(value) {
693
693
  export function hash_balance_leaf(raw) {
694
694
  try {
695
695
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
696
- const ptr0 = passArray64ToWasm0(raw, wasm.__wbindgen_export3);
696
+ const ptr0 = passArray64ToWasm0(raw, wasm.__wbindgen_export);
697
697
  const len0 = WASM_VECTOR_LEN;
698
698
  wasm.hash_balance_leaf(retptr, ptr0, len0);
699
699
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
700
700
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
701
701
  var v2 = getArrayU64FromWasm0(r0, r1).slice();
702
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
702
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
703
703
  return v2;
704
704
  } finally {
705
705
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -759,7 +759,7 @@ export function keno_multiplier_table(risk, pick_count) {
759
759
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
760
760
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
761
761
  var v1 = getArrayU64FromWasm0(r0, r1).slice();
762
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
762
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
763
763
  return v1;
764
764
  } finally {
765
765
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -790,7 +790,7 @@ export function keno_rtp_x100(risk, pick_count) {
790
790
  * @returns {number}
791
791
  */
792
792
  export function limbo_rtp_percent() {
793
- const ret = wasm.coinflip_rtp_percent();
793
+ const ret = wasm.limbo_rtp_percent();
794
794
  return ret >>> 0;
795
795
  }
796
796
 
@@ -817,17 +817,17 @@ export function limbo_rtp_percent() {
817
817
  export function make_main_leaf(balance_hash, pk_hash, address_hash) {
818
818
  try {
819
819
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
820
- const ptr0 = passArray64ToWasm0(balance_hash, wasm.__wbindgen_export3);
820
+ const ptr0 = passArray64ToWasm0(balance_hash, wasm.__wbindgen_export);
821
821
  const len0 = WASM_VECTOR_LEN;
822
- const ptr1 = passArray64ToWasm0(pk_hash, wasm.__wbindgen_export3);
822
+ const ptr1 = passArray64ToWasm0(pk_hash, wasm.__wbindgen_export);
823
823
  const len1 = WASM_VECTOR_LEN;
824
- const ptr2 = passArray64ToWasm0(address_hash, wasm.__wbindgen_export3);
824
+ const ptr2 = passArray64ToWasm0(address_hash, wasm.__wbindgen_export);
825
825
  const len2 = WASM_VECTOR_LEN;
826
826
  wasm.make_main_leaf(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
827
827
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
828
828
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
829
829
  var v4 = getArrayU64FromWasm0(r0, r1).slice();
830
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
830
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
831
831
  return v4;
832
832
  } finally {
833
833
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -897,7 +897,7 @@ export function plinko_multiplier_table(sector, rows, is_extreme) {
897
897
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
898
898
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
899
899
  var v1 = getArrayU64FromWasm0(r0, r1).slice();
900
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
900
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
901
901
  return v1;
902
902
  } finally {
903
903
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -943,13 +943,13 @@ export function plinko_rtp_x100(sector, rows, is_extreme) {
943
943
  export function poseidon2_hash(input) {
944
944
  try {
945
945
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
946
- const ptr0 = passArray64ToWasm0(input, wasm.__wbindgen_export3);
946
+ const ptr0 = passArray64ToWasm0(input, wasm.__wbindgen_export);
947
947
  const len0 = WASM_VECTOR_LEN;
948
948
  wasm.poseidon2_hash(retptr, ptr0, len0);
949
949
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
950
950
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
951
951
  var v2 = getArrayU64FromWasm0(r0, r1).slice();
952
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
952
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
953
953
  return v2;
954
954
  } finally {
955
955
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -970,15 +970,15 @@ export function poseidon2_hash(input) {
970
970
  export function poseidon2_two_to_one(left, right) {
971
971
  try {
972
972
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
973
- const ptr0 = passArray64ToWasm0(left, wasm.__wbindgen_export3);
973
+ const ptr0 = passArray64ToWasm0(left, wasm.__wbindgen_export);
974
974
  const len0 = WASM_VECTOR_LEN;
975
- const ptr1 = passArray64ToWasm0(right, wasm.__wbindgen_export3);
975
+ const ptr1 = passArray64ToWasm0(right, wasm.__wbindgen_export);
976
976
  const len1 = WASM_VECTOR_LEN;
977
977
  wasm.poseidon2_two_to_one(retptr, ptr0, len0, ptr1, len1);
978
978
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
979
979
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
980
980
  var v3 = getArrayU64FromWasm0(r0, r1).slice();
981
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
981
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
982
982
  return v3;
983
983
  } finally {
984
984
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -1001,13 +1001,13 @@ export function poseidon2_two_to_one(left, right) {
1001
1001
  export function seed_hash_truncated(server_seed) {
1002
1002
  try {
1003
1003
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1004
- const ptr0 = passArray64ToWasm0(server_seed, wasm.__wbindgen_export3);
1004
+ const ptr0 = passArray64ToWasm0(server_seed, wasm.__wbindgen_export);
1005
1005
  const len0 = WASM_VECTOR_LEN;
1006
1006
  wasm.seed_hash_truncated(retptr, ptr0, len0);
1007
1007
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1008
1008
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1009
1009
  var v2 = getArrayU64FromWasm0(r0, r1).slice();
1010
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
1010
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
1011
1011
  return v2;
1012
1012
  } finally {
1013
1013
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -1029,13 +1029,13 @@ export function seed_hash_truncated(server_seed) {
1029
1029
  export function session_public_key(session_key, session_expiry) {
1030
1030
  try {
1031
1031
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1032
- const ptr0 = passArray64ToWasm0(session_key, wasm.__wbindgen_export3);
1032
+ const ptr0 = passArray64ToWasm0(session_key, wasm.__wbindgen_export);
1033
1033
  const len0 = WASM_VECTOR_LEN;
1034
1034
  wasm.session_public_key(retptr, ptr0, len0, session_expiry);
1035
1035
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1036
1036
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1037
1037
  var v2 = getArrayU64FromWasm0(r0, r1).slice();
1038
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
1038
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
1039
1039
  return v2;
1040
1040
  } finally {
1041
1041
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -1061,13 +1061,13 @@ export function session_public_key(session_key, session_expiry) {
1061
1061
  export function string_to_user_seed(input) {
1062
1062
  try {
1063
1063
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1064
- const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
1064
+ const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1065
1065
  const len0 = WASM_VECTOR_LEN;
1066
1066
  wasm.string_to_user_seed(retptr, ptr0, len0);
1067
1067
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1068
1068
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1069
1069
  var v2 = getArrayU64FromWasm0(r0, r1).slice();
1070
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
1070
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
1071
1071
  return v2;
1072
1072
  } finally {
1073
1073
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -1092,7 +1092,7 @@ export function string_to_user_seed_hex(input) {
1092
1092
  let deferred2_1;
1093
1093
  try {
1094
1094
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1095
- const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
1095
+ const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1096
1096
  const len0 = WASM_VECTOR_LEN;
1097
1097
  wasm.string_to_user_seed_hex(retptr, ptr0, len0);
1098
1098
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
@@ -1102,13 +1102,80 @@ export function string_to_user_seed_hex(input) {
1102
1102
  return getStringFromWasm0(r0, r1);
1103
1103
  } finally {
1104
1104
  wasm.__wbindgen_add_to_stack_pointer(16);
1105
- wasm.__wbindgen_export2(deferred2_0, deferred2_1, 1);
1105
+ wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
1106
+ }
1107
+ }
1108
+
1109
+ /**
1110
+ * Re-check every per-slot circuit constraint on a candidate witness, returning
1111
+ * the post-tx effects on success or a typed rejection reason on failure.
1112
+ *
1113
+ * Input: a JS object matching `tx_validator::SlotInput` (serde-compatible).
1114
+ * Output on success: `{ ok: true, effects: SlotEffects }`.
1115
+ * Output on failure: `{ ok: false, reason: string }`.
1116
+ * @param {any} input
1117
+ * @returns {any}
1118
+ */
1119
+ export function validate_slot(input) {
1120
+ try {
1121
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1122
+ wasm.validate_slot(retptr, addHeapObject(input));
1123
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1124
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1125
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1126
+ if (r2) {
1127
+ throw takeObject(r1);
1128
+ }
1129
+ return takeObject(r0);
1130
+ } finally {
1131
+ wasm.__wbindgen_add_to_stack_pointer(16);
1106
1132
  }
1107
1133
  }
1108
1134
 
1109
1135
  function __wbg_get_imports() {
1110
1136
  const import0 = {
1111
1137
  __proto__: null,
1138
+ __wbg_Error_8c4e43fe74559d73: function(arg0, arg1) {
1139
+ const ret = Error(getStringFromWasm0(arg0, arg1));
1140
+ return addHeapObject(ret);
1141
+ },
1142
+ __wbg_Number_04624de7d0e8332d: function(arg0) {
1143
+ const ret = Number(getObject(arg0));
1144
+ return ret;
1145
+ },
1146
+ __wbg_String_8f0eb39a4a4c2f66: function(arg0, arg1) {
1147
+ const ret = String(getObject(arg1));
1148
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1149
+ const len1 = WASM_VECTOR_LEN;
1150
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
1151
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
1152
+ },
1153
+ __wbg___wbindgen_bigint_get_as_i64_8fcf4ce7f1ca72a2: function(arg0, arg1) {
1154
+ const v = getObject(arg1);
1155
+ const ret = typeof(v) === 'bigint' ? v : undefined;
1156
+ getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
1157
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
1158
+ },
1159
+ __wbg___wbindgen_boolean_get_bbbb1c18aa2f5e25: function(arg0) {
1160
+ const v = getObject(arg0);
1161
+ const ret = typeof(v) === 'boolean' ? v : undefined;
1162
+ return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
1163
+ },
1164
+ __wbg___wbindgen_debug_string_0bc8482c6e3508ae: function(arg0, arg1) {
1165
+ const ret = debugString(getObject(arg1));
1166
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1167
+ const len1 = WASM_VECTOR_LEN;
1168
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
1169
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
1170
+ },
1171
+ __wbg___wbindgen_in_47fa6863be6f2f25: function(arg0, arg1) {
1172
+ const ret = getObject(arg0) in getObject(arg1);
1173
+ return ret;
1174
+ },
1175
+ __wbg___wbindgen_is_bigint_31b12575b56f32fc: function(arg0) {
1176
+ const ret = typeof(getObject(arg0)) === 'bigint';
1177
+ return ret;
1178
+ },
1112
1179
  __wbg___wbindgen_is_function_0095a73b8b156f76: function(arg0) {
1113
1180
  const ret = typeof(getObject(arg0)) === 'function';
1114
1181
  return ret;
@@ -1126,6 +1193,28 @@ function __wbg_get_imports() {
1126
1193
  const ret = getObject(arg0) === undefined;
1127
1194
  return ret;
1128
1195
  },
1196
+ __wbg___wbindgen_jsval_eq_11888390b0186270: function(arg0, arg1) {
1197
+ const ret = getObject(arg0) === getObject(arg1);
1198
+ return ret;
1199
+ },
1200
+ __wbg___wbindgen_jsval_loose_eq_9dd77d8cd6671811: function(arg0, arg1) {
1201
+ const ret = getObject(arg0) == getObject(arg1);
1202
+ return ret;
1203
+ },
1204
+ __wbg___wbindgen_number_get_8ff4255516ccad3e: function(arg0, arg1) {
1205
+ const obj = getObject(arg1);
1206
+ const ret = typeof(obj) === 'number' ? obj : undefined;
1207
+ getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
1208
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
1209
+ },
1210
+ __wbg___wbindgen_string_get_72fb696202c56729: function(arg0, arg1) {
1211
+ const obj = getObject(arg1);
1212
+ const ret = typeof(obj) === 'string' ? obj : undefined;
1213
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1214
+ var len1 = WASM_VECTOR_LEN;
1215
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
1216
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
1217
+ },
1129
1218
  __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
1130
1219
  throw new Error(getStringFromWasm0(arg0, arg1));
1131
1220
  },
@@ -1141,13 +1230,65 @@ function __wbg_get_imports() {
1141
1230
  const ret = getObject(arg0).crypto;
1142
1231
  return addHeapObject(ret);
1143
1232
  },
1233
+ __wbg_done_57b39ecd9addfe81: function(arg0) {
1234
+ const ret = getObject(arg0).done;
1235
+ return ret;
1236
+ },
1144
1237
  __wbg_getRandomValues_b3f15fcbfabb0f8b: function() { return handleError(function (arg0, arg1) {
1145
1238
  getObject(arg0).getRandomValues(getObject(arg1));
1146
1239
  }, arguments); },
1240
+ __wbg_get_9b94d73e6221f75c: function(arg0, arg1) {
1241
+ const ret = getObject(arg0)[arg1 >>> 0];
1242
+ return addHeapObject(ret);
1243
+ },
1244
+ __wbg_get_b3ed3ad4be2bc8ac: function() { return handleError(function (arg0, arg1) {
1245
+ const ret = Reflect.get(getObject(arg0), getObject(arg1));
1246
+ return addHeapObject(ret);
1247
+ }, arguments); },
1248
+ __wbg_get_with_ref_key_1dc361bd10053bfe: function(arg0, arg1) {
1249
+ const ret = getObject(arg0)[getObject(arg1)];
1250
+ return addHeapObject(ret);
1251
+ },
1252
+ __wbg_instanceof_ArrayBuffer_c367199e2fa2aa04: function(arg0) {
1253
+ let result;
1254
+ try {
1255
+ result = getObject(arg0) instanceof ArrayBuffer;
1256
+ } catch (_) {
1257
+ result = false;
1258
+ }
1259
+ const ret = result;
1260
+ return ret;
1261
+ },
1262
+ __wbg_instanceof_Uint8Array_9b9075935c74707c: function(arg0) {
1263
+ let result;
1264
+ try {
1265
+ result = getObject(arg0) instanceof Uint8Array;
1266
+ } catch (_) {
1267
+ result = false;
1268
+ }
1269
+ const ret = result;
1270
+ return ret;
1271
+ },
1272
+ __wbg_isArray_d314bb98fcf08331: function(arg0) {
1273
+ const ret = Array.isArray(getObject(arg0));
1274
+ return ret;
1275
+ },
1276
+ __wbg_isSafeInteger_bfbc7332a9768d2a: function(arg0) {
1277
+ const ret = Number.isSafeInteger(getObject(arg0));
1278
+ return ret;
1279
+ },
1280
+ __wbg_iterator_6ff6560ca1568e55: function() {
1281
+ const ret = Symbol.iterator;
1282
+ return addHeapObject(ret);
1283
+ },
1147
1284
  __wbg_length_32ed9a279acd054c: function(arg0) {
1148
1285
  const ret = getObject(arg0).length;
1149
1286
  return ret;
1150
1287
  },
1288
+ __wbg_length_35a7bace40f36eac: function(arg0) {
1289
+ const ret = getObject(arg0).length;
1290
+ return ret;
1291
+ },
1151
1292
  __wbg_msCrypto_d562bbe83e0d4b91: function(arg0) {
1152
1293
  const ret = getObject(arg0).msCrypto;
1153
1294
  return addHeapObject(ret);
@@ -1156,6 +1297,14 @@ function __wbg_get_imports() {
1156
1297
  const ret = new Object();
1157
1298
  return addHeapObject(ret);
1158
1299
  },
1300
+ __wbg_new_3eb36ae241fe6f44: function() {
1301
+ const ret = new Array();
1302
+ return addHeapObject(ret);
1303
+ },
1304
+ __wbg_new_dd2b680c8bf6ae29: function(arg0) {
1305
+ const ret = new Uint8Array(getObject(arg0));
1306
+ return addHeapObject(ret);
1307
+ },
1159
1308
  __wbg_new_no_args_1c7c842f08d00ebb: function(arg0, arg1) {
1160
1309
  const ret = new Function(getStringFromWasm0(arg0, arg1));
1161
1310
  return addHeapObject(ret);
@@ -1164,6 +1313,14 @@ function __wbg_get_imports() {
1164
1313
  const ret = new Uint8Array(arg0 >>> 0);
1165
1314
  return addHeapObject(ret);
1166
1315
  },
1316
+ __wbg_next_3482f54c49e8af19: function() { return handleError(function (arg0) {
1317
+ const ret = getObject(arg0).next();
1318
+ return addHeapObject(ret);
1319
+ }, arguments); },
1320
+ __wbg_next_418f80d8f5303233: function(arg0) {
1321
+ const ret = getObject(arg0).next;
1322
+ return addHeapObject(ret);
1323
+ },
1167
1324
  __wbg_node_e1f24f89a7336c2e: function(arg0) {
1168
1325
  const ret = getObject(arg0).node;
1169
1326
  return addHeapObject(ret);
@@ -1182,10 +1339,16 @@ function __wbg_get_imports() {
1182
1339
  const ret = module.require;
1183
1340
  return addHeapObject(ret);
1184
1341
  }, arguments); },
1342
+ __wbg_set_3f1d0b984ed272ed: function(arg0, arg1, arg2) {
1343
+ getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
1344
+ },
1185
1345
  __wbg_set_6cb8631f80447a67: function() { return handleError(function (arg0, arg1, arg2) {
1186
1346
  const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
1187
1347
  return ret;
1188
1348
  }, arguments); },
1349
+ __wbg_set_f43e577aea94465b: function(arg0, arg1, arg2) {
1350
+ getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
1351
+ },
1189
1352
  __wbg_static_accessor_GLOBAL_12837167ad935116: function() {
1190
1353
  const ret = typeof global === 'undefined' ? null : global;
1191
1354
  return isLikeNone(ret) ? 0 : addHeapObject(ret);
@@ -1206,21 +1369,30 @@ function __wbg_get_imports() {
1206
1369
  const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
1207
1370
  return addHeapObject(ret);
1208
1371
  },
1372
+ __wbg_value_0546255b415e96c1: function(arg0) {
1373
+ const ret = getObject(arg0).value;
1374
+ return addHeapObject(ret);
1375
+ },
1209
1376
  __wbg_versions_4e31226f5e8dc909: function(arg0) {
1210
1377
  const ret = getObject(arg0).versions;
1211
1378
  return addHeapObject(ret);
1212
1379
  },
1213
- __wbindgen_cast_0000000000000001: function(arg0, arg1) {
1380
+ __wbindgen_cast_0000000000000001: function(arg0) {
1381
+ // Cast intrinsic for `F64 -> Externref`.
1382
+ const ret = arg0;
1383
+ return addHeapObject(ret);
1384
+ },
1385
+ __wbindgen_cast_0000000000000002: function(arg0, arg1) {
1214
1386
  // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
1215
1387
  const ret = getArrayU8FromWasm0(arg0, arg1);
1216
1388
  return addHeapObject(ret);
1217
1389
  },
1218
- __wbindgen_cast_0000000000000002: function(arg0, arg1) {
1390
+ __wbindgen_cast_0000000000000003: function(arg0, arg1) {
1219
1391
  // Cast intrinsic for `Ref(String) -> Externref`.
1220
1392
  const ret = getStringFromWasm0(arg0, arg1);
1221
1393
  return addHeapObject(ret);
1222
1394
  },
1223
- __wbindgen_cast_0000000000000003: function(arg0) {
1395
+ __wbindgen_cast_0000000000000004: function(arg0) {
1224
1396
  // Cast intrinsic for `U64 -> Externref`.
1225
1397
  const ret = BigInt.asUintN(64, arg0);
1226
1398
  return addHeapObject(ret);
@@ -1248,6 +1420,71 @@ function addHeapObject(obj) {
1248
1420
  return idx;
1249
1421
  }
1250
1422
 
1423
+ function debugString(val) {
1424
+ // primitive types
1425
+ const type = typeof val;
1426
+ if (type == 'number' || type == 'boolean' || val == null) {
1427
+ return `${val}`;
1428
+ }
1429
+ if (type == 'string') {
1430
+ return `"${val}"`;
1431
+ }
1432
+ if (type == 'symbol') {
1433
+ const description = val.description;
1434
+ if (description == null) {
1435
+ return 'Symbol';
1436
+ } else {
1437
+ return `Symbol(${description})`;
1438
+ }
1439
+ }
1440
+ if (type == 'function') {
1441
+ const name = val.name;
1442
+ if (typeof name == 'string' && name.length > 0) {
1443
+ return `Function(${name})`;
1444
+ } else {
1445
+ return 'Function';
1446
+ }
1447
+ }
1448
+ // objects
1449
+ if (Array.isArray(val)) {
1450
+ const length = val.length;
1451
+ let debug = '[';
1452
+ if (length > 0) {
1453
+ debug += debugString(val[0]);
1454
+ }
1455
+ for(let i = 1; i < length; i++) {
1456
+ debug += ', ' + debugString(val[i]);
1457
+ }
1458
+ debug += ']';
1459
+ return debug;
1460
+ }
1461
+ // Test for built-in
1462
+ const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
1463
+ let className;
1464
+ if (builtInMatches && builtInMatches.length > 1) {
1465
+ className = builtInMatches[1];
1466
+ } else {
1467
+ // Failed to match the standard '[object ClassName]'
1468
+ return toString.call(val);
1469
+ }
1470
+ if (className == 'Object') {
1471
+ // we're a user defined class or Object
1472
+ // JSON.stringify avoids problems with cycles, and is generally much
1473
+ // easier than looping through ownProperties of `val`.
1474
+ try {
1475
+ return 'Object(' + JSON.stringify(val) + ')';
1476
+ } catch (_) {
1477
+ return 'Object';
1478
+ }
1479
+ }
1480
+ // errors
1481
+ if (val instanceof Error) {
1482
+ return `${val.name}: ${val.message}\n${val.stack}`;
1483
+ }
1484
+ // TODO we could test for more things here, like `Set`s and `Map`s.
1485
+ return className;
1486
+ }
1487
+
1251
1488
  function dropObject(idx) {
1252
1489
  if (idx < 132) return;
1253
1490
  heap[idx] = heap_next;
@@ -1312,7 +1549,7 @@ function handleError(f, args) {
1312
1549
  try {
1313
1550
  return f.apply(this, args);
1314
1551
  } catch (e) {
1315
- wasm.__wbindgen_export(addHeapObject(e));
1552
+ wasm.__wbindgen_export3(addHeapObject(e));
1316
1553
  }
1317
1554
  }
1318
1555