@rolly-dev/wasm-signer 1.22.0 → 1.24.1

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,7 +18,7 @@ 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);
@@ -61,13 +61,13 @@ export function coinflip_rtp_percent() {
61
61
  export function compute_address_hash(address_hex) {
62
62
  try {
63
63
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
64
- const ptr0 = passStringToWasm0(address_hex, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
64
+ const ptr0 = passStringToWasm0(address_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
65
65
  const len0 = WASM_VECTOR_LEN;
66
66
  wasm.compute_address_hash(retptr, ptr0, len0);
67
67
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
68
68
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
69
69
  var v2 = getArrayU64FromWasm0(r0, r1).slice();
70
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
70
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
71
71
  return v2;
72
72
  } finally {
73
73
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -75,15 +75,15 @@ export function compute_address_hash(address_hex) {
75
75
  }
76
76
 
77
77
  /**
78
- * Extract aviato point (×100) from Poseidon2 random output.
78
+ * Extract aviato point (×100) from raw server seed fields.
79
79
  *
80
- * `random` must be exactly 4 elements.
80
+ * `random` must be exactly 4 elements (first 4 fields of server_seed).
81
81
  * Returns the clamped aviato multiplier ×100 (100..=1_000_000, i.e. 1.00x..10000.00x).
82
82
  * @param {BigUint64Array} random
83
83
  * @returns {number}
84
84
  */
85
85
  export function compute_aviato_point(random) {
86
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
86
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
87
87
  const len0 = WASM_VECTOR_LEN;
88
88
  const ret = wasm.compute_aviato_point(ptr0, len0);
89
89
  return ret >>> 0;
@@ -101,13 +101,13 @@ export function compute_aviato_point(random) {
101
101
  export function compute_drawn_keno(random) {
102
102
  try {
103
103
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
104
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
104
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
105
105
  const len0 = WASM_VECTOR_LEN;
106
106
  wasm.compute_drawn_keno(retptr, ptr0, len0);
107
107
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
108
108
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
109
109
  var v2 = getArrayU8FromWasm0(r0, r1).slice();
110
- wasm.__wbindgen_export2(r0, r1 * 1, 1);
110
+ wasm.__wbindgen_export4(r0, r1 * 1, 1);
111
111
  return v2;
112
112
  } finally {
113
113
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -130,7 +130,7 @@ export function compute_multi_dice(win_numbers) {
130
130
  /**
131
131
  * Full aviato payout computation — pure integer arithmetic, zero floats.
132
132
  *
133
- * `random`: 4 Goldilocks field elements (Poseidon2 output of server_seed).
133
+ * `random`: 4 Goldilocks field elements (first 4 fields of raw server_seed).
134
134
  * `bet_atomic`: bet in atomic units (1 USDT = 1_000_000).
135
135
  * `cashout_x100`: multiplier at which the user cashed out (×100).
136
136
  * - 0 = user did NOT cash out (loss).
@@ -145,13 +145,13 @@ export function compute_multi_dice(win_numbers) {
145
145
  export function compute_payout_aviato(random, bet_atomic, cashout_x100) {
146
146
  try {
147
147
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
148
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
148
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
149
149
  const len0 = WASM_VECTOR_LEN;
150
150
  wasm.compute_payout_aviato(retptr, ptr0, len0, bet_atomic, cashout_x100);
151
151
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
152
152
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
153
153
  var v2 = getArrayU64FromWasm0(r0, r1).slice();
154
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
154
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
155
155
  return v2;
156
156
  } finally {
157
157
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -174,13 +174,13 @@ export function compute_payout_aviato(random, bet_atomic, cashout_x100) {
174
174
  export function compute_payout_coinflip(random, bet_atomic, prediction) {
175
175
  try {
176
176
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
177
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
177
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
178
178
  const len0 = WASM_VECTOR_LEN;
179
179
  wasm.compute_payout_coinflip(retptr, ptr0, len0, bet_atomic, prediction);
180
180
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
181
181
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
182
182
  var v2 = getArrayU64FromWasm0(r0, r1).slice();
183
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
183
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
184
184
  return v2;
185
185
  } finally {
186
186
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -206,13 +206,13 @@ export function compute_payout_coinflip(random, bet_atomic, prediction) {
206
206
  export function compute_payout_dice(random, bet_atomic, game_mode, prediction_lo, prediction_hi) {
207
207
  try {
208
208
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
209
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
209
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
210
210
  const len0 = WASM_VECTOR_LEN;
211
211
  wasm.compute_payout_dice(retptr, ptr0, len0, bet_atomic, game_mode, prediction_lo, prediction_hi);
212
212
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
213
213
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
214
214
  var v2 = getArrayU64FromWasm0(r0, r1).slice();
215
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
215
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
216
216
  return v2;
217
217
  } finally {
218
218
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -237,15 +237,15 @@ export function compute_payout_dice(random, bet_atomic, game_mode, prediction_lo
237
237
  export function compute_payout_keno(random, bet_atomic, risk, selected) {
238
238
  try {
239
239
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
240
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
240
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
241
241
  const len0 = WASM_VECTOR_LEN;
242
- const ptr1 = passArray8ToWasm0(selected, wasm.__wbindgen_export3);
242
+ const ptr1 = passArray8ToWasm0(selected, wasm.__wbindgen_export);
243
243
  const len1 = WASM_VECTOR_LEN;
244
244
  wasm.compute_payout_keno(retptr, ptr0, len0, bet_atomic, risk, ptr1, len1);
245
245
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
246
246
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
247
247
  var v3 = getArrayU64FromWasm0(r0, r1).slice();
248
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
248
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
249
249
  return v3;
250
250
  } finally {
251
251
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -268,13 +268,13 @@ export function compute_payout_keno(random, bet_atomic, risk, selected) {
268
268
  export function compute_payout_limbo(random, bet_atomic, prediction_x100) {
269
269
  try {
270
270
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
271
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
271
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
272
272
  const len0 = WASM_VECTOR_LEN;
273
273
  wasm.compute_payout_limbo(retptr, ptr0, len0, bet_atomic, prediction_x100);
274
274
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
275
275
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
276
276
  var v2 = getArrayU64FromWasm0(r0, r1).slice();
277
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
277
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
278
278
  return v2;
279
279
  } finally {
280
280
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -301,13 +301,13 @@ export function compute_payout_limbo(random, bet_atomic, prediction_x100) {
301
301
  export function compute_payout_plinko(random, bet_atomic, sector, rows, is_extreme) {
302
302
  try {
303
303
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
304
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
304
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
305
305
  const len0 = WASM_VECTOR_LEN;
306
306
  wasm.compute_payout_plinko(retptr, ptr0, len0, bet_atomic, sector, rows, is_extreme);
307
307
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
308
308
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
309
309
  var v2 = getArrayU64FromWasm0(r0, r1).slice();
310
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
310
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
311
311
  return v2;
312
312
  } finally {
313
313
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -338,7 +338,7 @@ export function compute_prediction_hash(game_id, p0, p1, p2) {
338
338
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
339
339
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
340
340
  var v1 = getArrayU64FromWasm0(r0, r1).slice();
341
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
341
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
342
342
  return v1;
343
343
  } finally {
344
344
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -362,13 +362,13 @@ export function compute_prediction_hash(game_id, p0, p1, p2) {
362
362
  export function compute_prediction_hash_keno(game_id, risk, pick_count, selected) {
363
363
  try {
364
364
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
365
- const ptr0 = passArray8ToWasm0(selected, wasm.__wbindgen_export3);
365
+ const ptr0 = passArray8ToWasm0(selected, wasm.__wbindgen_export);
366
366
  const len0 = WASM_VECTOR_LEN;
367
367
  wasm.compute_prediction_hash_keno(retptr, game_id, risk, pick_count, ptr0, len0);
368
368
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
369
369
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
370
370
  var v2 = getArrayU64FromWasm0(r0, r1).slice();
371
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
371
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
372
372
  return v2;
373
373
  } finally {
374
374
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -383,7 +383,7 @@ export function compute_prediction_hash_keno(game_id, risk, pick_count, selected
383
383
  * @returns {number}
384
384
  */
385
385
  export function compute_roll_coinflip(random) {
386
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
386
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
387
387
  const len0 = WASM_VECTOR_LEN;
388
388
  const ret = wasm.compute_roll_coinflip(ptr0, len0);
389
389
  return ret >>> 0;
@@ -397,7 +397,7 @@ export function compute_roll_coinflip(random) {
397
397
  * @returns {number}
398
398
  */
399
399
  export function compute_roll_dice(random) {
400
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
400
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
401
401
  const len0 = WASM_VECTOR_LEN;
402
402
  const ret = wasm.compute_roll_dice(ptr0, len0);
403
403
  return ret >>> 0;
@@ -412,7 +412,7 @@ export function compute_roll_dice(random) {
412
412
  * @returns {number}
413
413
  */
414
414
  export function compute_roll_limbo(random) {
415
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
415
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
416
416
  const len0 = WASM_VECTOR_LEN;
417
417
  const ret = wasm.compute_roll_limbo(ptr0, len0);
418
418
  return ret >>> 0;
@@ -429,7 +429,7 @@ export function compute_roll_limbo(random) {
429
429
  * @returns {number}
430
430
  */
431
431
  export function compute_roll_plinko(random, rows) {
432
- const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
432
+ const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export);
433
433
  const len0 = WASM_VECTOR_LEN;
434
434
  const ret = wasm.compute_roll_plinko(ptr0, len0, rows);
435
435
  return ret >>> 0;
@@ -450,13 +450,13 @@ export function compute_roll_plinko(random, rows) {
450
450
  export function compute_server_seed_hash(server_seed) {
451
451
  try {
452
452
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
453
- const ptr0 = passArray64ToWasm0(server_seed, wasm.__wbindgen_export3);
453
+ const ptr0 = passArray64ToWasm0(server_seed, wasm.__wbindgen_export);
454
454
  const len0 = WASM_VECTOR_LEN;
455
455
  wasm.compute_server_seed_hash(retptr, ptr0, len0);
456
456
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
457
457
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
458
458
  var v2 = getArrayU64FromWasm0(r0, r1).slice();
459
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
459
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
460
460
  return v2;
461
461
  } finally {
462
462
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -482,15 +482,15 @@ export function compute_server_seed_hash(server_seed) {
482
482
  export function compute_user_seed_binding(game_id, bet, pred_hash, secret) {
483
483
  try {
484
484
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
485
- const ptr0 = passArray64ToWasm0(pred_hash, wasm.__wbindgen_export3);
485
+ const ptr0 = passArray64ToWasm0(pred_hash, wasm.__wbindgen_export);
486
486
  const len0 = WASM_VECTOR_LEN;
487
- const ptr1 = passArray64ToWasm0(secret, wasm.__wbindgen_export3);
487
+ const ptr1 = passArray64ToWasm0(secret, wasm.__wbindgen_export);
488
488
  const len1 = WASM_VECTOR_LEN;
489
489
  wasm.compute_user_seed_binding(retptr, game_id, bet, ptr0, len0, ptr1, len1);
490
490
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
491
491
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
492
492
  var v3 = getArrayU64FromWasm0(r0, r1).slice();
493
- wasm.__wbindgen_export2(r0, r1 * 8, 8);
493
+ wasm.__wbindgen_export4(r0, r1 * 8, 8);
494
494
  return v3;
495
495
  } finally {
496
496
  wasm.__wbindgen_add_to_stack_pointer(16);
@@ -518,13 +518,13 @@ export function compute_user_seed_binding(game_id, bet, pred_hash, secret) {
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);
@@ -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);
@@ -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