@noir-lang/acvm_js 0.46.0 → 0.47.0-30c50f5.nightly
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/nodejs/acvm_js.d.ts +87 -104
- package/nodejs/acvm_js.js +197 -648
- package/nodejs/acvm_js_bg.wasm +0 -0
- package/nodejs/acvm_js_bg.wasm.d.ts +12 -18
- package/package.json +1 -1
- package/web/acvm_js.d.ts +99 -122
- package/web/acvm_js.js +178 -565
- package/web/acvm_js_bg.wasm +0 -0
- package/web/acvm_js_bg.wasm.d.ts +12 -18
package/web/acvm_js.js
CHANGED
|
@@ -124,15 +124,6 @@ function getFloat64Memory0() {
|
|
|
124
124
|
return cachedFloat64Memory0;
|
|
125
125
|
}
|
|
126
126
|
|
|
127
|
-
let cachedBigInt64Memory0 = null;
|
|
128
|
-
|
|
129
|
-
function getBigInt64Memory0() {
|
|
130
|
-
if (cachedBigInt64Memory0 === null || cachedBigInt64Memory0.byteLength === 0) {
|
|
131
|
-
cachedBigInt64Memory0 = new BigInt64Array(wasm.memory.buffer);
|
|
132
|
-
}
|
|
133
|
-
return cachedBigInt64Memory0;
|
|
134
|
-
}
|
|
135
|
-
|
|
136
127
|
function debugString(val) {
|
|
137
128
|
// primitive types
|
|
138
129
|
const type = typeof val;
|
|
@@ -222,29 +213,8 @@ function makeMutClosure(arg0, arg1, dtor, f) {
|
|
|
222
213
|
|
|
223
214
|
return real;
|
|
224
215
|
}
|
|
225
|
-
function
|
|
226
|
-
wasm.
|
|
227
|
-
}
|
|
228
|
-
|
|
229
|
-
/**
|
|
230
|
-
* Sets the package's logging level.
|
|
231
|
-
*
|
|
232
|
-
* @param {LogLevel} level - The maximum level of logging to be emitted.
|
|
233
|
-
*/
|
|
234
|
-
export function initLogLevel(filter) {
|
|
235
|
-
try {
|
|
236
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
237
|
-
const ptr0 = passStringToWasm0(filter, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
238
|
-
const len0 = WASM_VECTOR_LEN;
|
|
239
|
-
wasm.initLogLevel(retptr, ptr0, len0);
|
|
240
|
-
var r0 = getInt32Memory0()[retptr / 4 + 0];
|
|
241
|
-
var r1 = getInt32Memory0()[retptr / 4 + 1];
|
|
242
|
-
if (r1) {
|
|
243
|
-
throw takeObject(r0);
|
|
244
|
-
}
|
|
245
|
-
} finally {
|
|
246
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
247
|
-
}
|
|
216
|
+
function __wbg_adapter_22(arg0, arg1, arg2) {
|
|
217
|
+
wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h36bac5ff3ea3c380(arg0, arg1, addHeapObject(arg2));
|
|
248
218
|
}
|
|
249
219
|
|
|
250
220
|
/**
|
|
@@ -256,144 +226,10 @@ export function buildInfo() {
|
|
|
256
226
|
return takeObject(ret);
|
|
257
227
|
}
|
|
258
228
|
|
|
259
|
-
/**
|
|
260
|
-
* Performs a bitwise AND operation between `lhs` and `rhs`
|
|
261
|
-
* @param {string} lhs
|
|
262
|
-
* @param {string} rhs
|
|
263
|
-
* @returns {string}
|
|
264
|
-
*/
|
|
265
|
-
export function and(lhs, rhs) {
|
|
266
|
-
const ret = wasm.and(addHeapObject(lhs), addHeapObject(rhs));
|
|
267
|
-
return takeObject(ret);
|
|
268
|
-
}
|
|
269
|
-
|
|
270
|
-
/**
|
|
271
|
-
* Performs a bitwise XOR operation between `lhs` and `rhs`
|
|
272
|
-
* @param {string} lhs
|
|
273
|
-
* @param {string} rhs
|
|
274
|
-
* @returns {string}
|
|
275
|
-
*/
|
|
276
|
-
export function xor(lhs, rhs) {
|
|
277
|
-
const ret = wasm.xor(addHeapObject(lhs), addHeapObject(rhs));
|
|
278
|
-
return takeObject(ret);
|
|
279
|
-
}
|
|
280
|
-
|
|
281
|
-
function passArray8ToWasm0(arg, malloc) {
|
|
282
|
-
const ptr = malloc(arg.length * 1) >>> 0;
|
|
283
|
-
getUint8Memory0().set(arg, ptr / 1);
|
|
284
|
-
WASM_VECTOR_LEN = arg.length;
|
|
285
|
-
return ptr;
|
|
286
|
-
}
|
|
287
|
-
|
|
288
229
|
function getArrayU8FromWasm0(ptr, len) {
|
|
289
230
|
ptr = ptr >>> 0;
|
|
290
231
|
return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
|
|
291
232
|
}
|
|
292
|
-
/**
|
|
293
|
-
* Calculates the SHA256 hash of the input bytes
|
|
294
|
-
* @param {Uint8Array} inputs
|
|
295
|
-
* @returns {Uint8Array}
|
|
296
|
-
*/
|
|
297
|
-
export function sha256(inputs) {
|
|
298
|
-
try {
|
|
299
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
300
|
-
const ptr0 = passArray8ToWasm0(inputs, wasm.__wbindgen_malloc);
|
|
301
|
-
const len0 = WASM_VECTOR_LEN;
|
|
302
|
-
wasm.sha256(retptr, ptr0, len0);
|
|
303
|
-
var r0 = getInt32Memory0()[retptr / 4 + 0];
|
|
304
|
-
var r1 = getInt32Memory0()[retptr / 4 + 1];
|
|
305
|
-
var v2 = getArrayU8FromWasm0(r0, r1).slice();
|
|
306
|
-
wasm.__wbindgen_free(r0, r1 * 1);
|
|
307
|
-
return v2;
|
|
308
|
-
} finally {
|
|
309
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
310
|
-
}
|
|
311
|
-
}
|
|
312
|
-
|
|
313
|
-
/**
|
|
314
|
-
* Calculates the Blake2s256 hash of the input bytes
|
|
315
|
-
* @param {Uint8Array} inputs
|
|
316
|
-
* @returns {Uint8Array}
|
|
317
|
-
*/
|
|
318
|
-
export function blake2s256(inputs) {
|
|
319
|
-
try {
|
|
320
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
321
|
-
const ptr0 = passArray8ToWasm0(inputs, wasm.__wbindgen_malloc);
|
|
322
|
-
const len0 = WASM_VECTOR_LEN;
|
|
323
|
-
wasm.blake2s256(retptr, ptr0, len0);
|
|
324
|
-
var r0 = getInt32Memory0()[retptr / 4 + 0];
|
|
325
|
-
var r1 = getInt32Memory0()[retptr / 4 + 1];
|
|
326
|
-
var v2 = getArrayU8FromWasm0(r0, r1).slice();
|
|
327
|
-
wasm.__wbindgen_free(r0, r1 * 1);
|
|
328
|
-
return v2;
|
|
329
|
-
} finally {
|
|
330
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
331
|
-
}
|
|
332
|
-
}
|
|
333
|
-
|
|
334
|
-
/**
|
|
335
|
-
* Calculates the Keccak256 hash of the input bytes
|
|
336
|
-
* @param {Uint8Array} inputs
|
|
337
|
-
* @returns {Uint8Array}
|
|
338
|
-
*/
|
|
339
|
-
export function keccak256(inputs) {
|
|
340
|
-
try {
|
|
341
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
342
|
-
const ptr0 = passArray8ToWasm0(inputs, wasm.__wbindgen_malloc);
|
|
343
|
-
const len0 = WASM_VECTOR_LEN;
|
|
344
|
-
wasm.keccak256(retptr, ptr0, len0);
|
|
345
|
-
var r0 = getInt32Memory0()[retptr / 4 + 0];
|
|
346
|
-
var r1 = getInt32Memory0()[retptr / 4 + 1];
|
|
347
|
-
var v2 = getArrayU8FromWasm0(r0, r1).slice();
|
|
348
|
-
wasm.__wbindgen_free(r0, r1 * 1);
|
|
349
|
-
return v2;
|
|
350
|
-
} finally {
|
|
351
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
352
|
-
}
|
|
353
|
-
}
|
|
354
|
-
|
|
355
|
-
/**
|
|
356
|
-
* Verifies a ECDSA signature over the secp256k1 curve.
|
|
357
|
-
* @param {Uint8Array} hashed_msg
|
|
358
|
-
* @param {Uint8Array} public_key_x_bytes
|
|
359
|
-
* @param {Uint8Array} public_key_y_bytes
|
|
360
|
-
* @param {Uint8Array} signature
|
|
361
|
-
* @returns {boolean}
|
|
362
|
-
*/
|
|
363
|
-
export function ecdsa_secp256k1_verify(hashed_msg, public_key_x_bytes, public_key_y_bytes, signature) {
|
|
364
|
-
const ptr0 = passArray8ToWasm0(hashed_msg, wasm.__wbindgen_malloc);
|
|
365
|
-
const len0 = WASM_VECTOR_LEN;
|
|
366
|
-
const ptr1 = passArray8ToWasm0(public_key_x_bytes, wasm.__wbindgen_malloc);
|
|
367
|
-
const len1 = WASM_VECTOR_LEN;
|
|
368
|
-
const ptr2 = passArray8ToWasm0(public_key_y_bytes, wasm.__wbindgen_malloc);
|
|
369
|
-
const len2 = WASM_VECTOR_LEN;
|
|
370
|
-
const ptr3 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
|
|
371
|
-
const len3 = WASM_VECTOR_LEN;
|
|
372
|
-
const ret = wasm.ecdsa_secp256k1_verify(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
|
|
373
|
-
return ret !== 0;
|
|
374
|
-
}
|
|
375
|
-
|
|
376
|
-
/**
|
|
377
|
-
* Verifies a ECDSA signature over the secp256r1 curve.
|
|
378
|
-
* @param {Uint8Array} hashed_msg
|
|
379
|
-
* @param {Uint8Array} public_key_x_bytes
|
|
380
|
-
* @param {Uint8Array} public_key_y_bytes
|
|
381
|
-
* @param {Uint8Array} signature
|
|
382
|
-
* @returns {boolean}
|
|
383
|
-
*/
|
|
384
|
-
export function ecdsa_secp256r1_verify(hashed_msg, public_key_x_bytes, public_key_y_bytes, signature) {
|
|
385
|
-
const ptr0 = passArray8ToWasm0(hashed_msg, wasm.__wbindgen_malloc);
|
|
386
|
-
const len0 = WASM_VECTOR_LEN;
|
|
387
|
-
const ptr1 = passArray8ToWasm0(public_key_x_bytes, wasm.__wbindgen_malloc);
|
|
388
|
-
const len1 = WASM_VECTOR_LEN;
|
|
389
|
-
const ptr2 = passArray8ToWasm0(public_key_y_bytes, wasm.__wbindgen_malloc);
|
|
390
|
-
const len2 = WASM_VECTOR_LEN;
|
|
391
|
-
const ptr3 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
|
|
392
|
-
const len3 = WASM_VECTOR_LEN;
|
|
393
|
-
const ret = wasm.ecdsa_secp256r1_verify(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
|
|
394
|
-
return ret !== 0;
|
|
395
|
-
}
|
|
396
|
-
|
|
397
233
|
/**
|
|
398
234
|
* Compresses a `WitnessMap` into the binary format outputted by Nargo.
|
|
399
235
|
*
|
|
@@ -419,6 +255,12 @@ export function compressWitness(witness_map) {
|
|
|
419
255
|
}
|
|
420
256
|
}
|
|
421
257
|
|
|
258
|
+
function passArray8ToWasm0(arg, malloc) {
|
|
259
|
+
const ptr = malloc(arg.length * 1) >>> 0;
|
|
260
|
+
getUint8Memory0().set(arg, ptr / 1);
|
|
261
|
+
WASM_VECTOR_LEN = arg.length;
|
|
262
|
+
return ptr;
|
|
263
|
+
}
|
|
422
264
|
/**
|
|
423
265
|
* Decompresses a compressed witness as outputted by Nargo into a `WitnessMap`.
|
|
424
266
|
* This should be used to only fetch the witness map for the main function.
|
|
@@ -493,14 +335,6 @@ export function decompressWitnessStack(compressed_witness) {
|
|
|
493
335
|
}
|
|
494
336
|
}
|
|
495
337
|
|
|
496
|
-
/**
|
|
497
|
-
* @returns {Promise<WasmBlackBoxFunctionSolver>}
|
|
498
|
-
*/
|
|
499
|
-
export function createBlackBoxSolver() {
|
|
500
|
-
const ret = wasm.createBlackBoxSolver();
|
|
501
|
-
return takeObject(ret);
|
|
502
|
-
}
|
|
503
|
-
|
|
504
338
|
/**
|
|
505
339
|
* Executes an ACIR circuit to generate the solved witness from the initial witness.
|
|
506
340
|
*
|
|
@@ -516,48 +350,29 @@ export function executeCircuit(program, initial_witness, foreign_call_handler) {
|
|
|
516
350
|
return takeObject(ret);
|
|
517
351
|
}
|
|
518
352
|
|
|
519
|
-
function _assertClass(instance, klass) {
|
|
520
|
-
if (!(instance instanceof klass)) {
|
|
521
|
-
throw new Error(`expected instance of ${klass.name}`);
|
|
522
|
-
}
|
|
523
|
-
return instance.ptr;
|
|
524
|
-
}
|
|
525
353
|
/**
|
|
526
354
|
* Executes an ACIR circuit to generate the solved witness from the initial witness.
|
|
527
355
|
* This method also extracts the public return values from the solved witness into its own return witness.
|
|
528
356
|
*
|
|
529
|
-
* @param {&WasmBlackBoxFunctionSolver} solver - A black box solver.
|
|
530
357
|
* @param {Uint8Array} circuit - A serialized representation of an ACIR circuit
|
|
531
358
|
* @param {WitnessMap} initial_witness - The initial witness map defining all of the inputs to `circuit`..
|
|
532
359
|
* @param {ForeignCallHandler} foreign_call_handler - A callback to process any foreign calls from the circuit.
|
|
533
360
|
* @returns {SolvedAndReturnWitness} The solved witness calculated by executing the circuit on the provided inputs, as well as the return witness indices as specified by the circuit.
|
|
534
361
|
*/
|
|
535
|
-
export function executeCircuitWithReturnWitness(
|
|
536
|
-
_assertClass(solver, WasmBlackBoxFunctionSolver);
|
|
362
|
+
export function executeCircuitWithReturnWitness(program, initial_witness, foreign_call_handler) {
|
|
537
363
|
const ptr0 = passArray8ToWasm0(program, wasm.__wbindgen_malloc);
|
|
538
364
|
const len0 = WASM_VECTOR_LEN;
|
|
539
|
-
const ret = wasm.executeCircuitWithReturnWitness(
|
|
365
|
+
const ret = wasm.executeCircuitWithReturnWitness(ptr0, len0, addHeapObject(initial_witness), addHeapObject(foreign_call_handler));
|
|
540
366
|
return takeObject(ret);
|
|
541
367
|
}
|
|
542
368
|
|
|
543
369
|
/**
|
|
544
370
|
* Executes an ACIR circuit to generate the solved witness from the initial witness.
|
|
545
371
|
*
|
|
546
|
-
* @param {
|
|
547
|
-
* @param {
|
|
548
|
-
* @param {
|
|
549
|
-
* @
|
|
550
|
-
* @returns {WitnessMap} The solved witness calculated by executing the circuit on the provided inputs.
|
|
551
|
-
*/
|
|
552
|
-
export function executeCircuitWithBlackBoxSolver(solver, program, initial_witness, foreign_call_handler) {
|
|
553
|
-
_assertClass(solver, WasmBlackBoxFunctionSolver);
|
|
554
|
-
const ptr0 = passArray8ToWasm0(program, wasm.__wbindgen_malloc);
|
|
555
|
-
const len0 = WASM_VECTOR_LEN;
|
|
556
|
-
const ret = wasm.executeCircuitWithBlackBoxSolver(solver.__wbg_ptr, ptr0, len0, addHeapObject(initial_witness), addHeapObject(foreign_call_handler));
|
|
557
|
-
return takeObject(ret);
|
|
558
|
-
}
|
|
559
|
-
|
|
560
|
-
/**
|
|
372
|
+
* @param {Uint8Array} program - A serialized representation of an ACIR program
|
|
373
|
+
* @param {WitnessMap} initial_witness - The initial witness map defining all of the inputs to `program`.
|
|
374
|
+
* @param {ForeignCallHandler} foreign_call_handler - A callback to process any foreign calls from the program.
|
|
375
|
+
* @returns {WitnessStack} The solved witness calculated by executing the program on the provided inputs.
|
|
561
376
|
*/
|
|
562
377
|
export function executeProgram(program, initial_witness, foreign_call_handler) {
|
|
563
378
|
const ptr0 = passArray8ToWasm0(program, wasm.__wbindgen_malloc);
|
|
@@ -566,16 +381,6 @@ export function executeProgram(program, initial_witness, foreign_call_handler) {
|
|
|
566
381
|
return takeObject(ret);
|
|
567
382
|
}
|
|
568
383
|
|
|
569
|
-
/**
|
|
570
|
-
*/
|
|
571
|
-
export function executeProgramWithBlackBoxSolver(solver, program, initial_witness, foreign_call_executor) {
|
|
572
|
-
_assertClass(solver, WasmBlackBoxFunctionSolver);
|
|
573
|
-
const ptr0 = passArray8ToWasm0(program, wasm.__wbindgen_malloc);
|
|
574
|
-
const len0 = WASM_VECTOR_LEN;
|
|
575
|
-
const ret = wasm.executeProgramWithBlackBoxSolver(solver.__wbg_ptr, ptr0, len0, addHeapObject(initial_witness), addHeapObject(foreign_call_executor));
|
|
576
|
-
return takeObject(ret);
|
|
577
|
-
}
|
|
578
|
-
|
|
579
384
|
/**
|
|
580
385
|
* Extracts a `WitnessMap` containing the witness indices corresponding to the circuit's return values.
|
|
581
386
|
*
|
|
@@ -660,69 +465,168 @@ export function getPublicWitness(program, solved_witness) {
|
|
|
660
465
|
}
|
|
661
466
|
}
|
|
662
467
|
|
|
663
|
-
|
|
664
|
-
|
|
665
|
-
|
|
666
|
-
|
|
667
|
-
|
|
668
|
-
|
|
669
|
-
|
|
670
|
-
|
|
671
|
-
|
|
468
|
+
/**
|
|
469
|
+
* Performs a bitwise AND operation between `lhs` and `rhs`
|
|
470
|
+
* @param {string} lhs
|
|
471
|
+
* @param {string} rhs
|
|
472
|
+
* @returns {string}
|
|
473
|
+
*/
|
|
474
|
+
export function and(lhs, rhs) {
|
|
475
|
+
const ret = wasm.and(addHeapObject(lhs), addHeapObject(rhs));
|
|
476
|
+
return takeObject(ret);
|
|
672
477
|
}
|
|
673
478
|
|
|
674
|
-
|
|
675
|
-
|
|
479
|
+
/**
|
|
480
|
+
* Performs a bitwise XOR operation between `lhs` and `rhs`
|
|
481
|
+
* @param {string} lhs
|
|
482
|
+
* @param {string} rhs
|
|
483
|
+
* @returns {string}
|
|
484
|
+
*/
|
|
485
|
+
export function xor(lhs, rhs) {
|
|
486
|
+
const ret = wasm.xor(addHeapObject(lhs), addHeapObject(rhs));
|
|
487
|
+
return takeObject(ret);
|
|
676
488
|
}
|
|
677
489
|
|
|
678
490
|
/**
|
|
679
|
-
*
|
|
491
|
+
* Calculates the SHA256 hash of the input bytes
|
|
492
|
+
* @param {Uint8Array} inputs
|
|
493
|
+
* @returns {Uint8Array}
|
|
680
494
|
*/
|
|
681
|
-
export
|
|
682
|
-
|
|
683
|
-
|
|
684
|
-
const
|
|
685
|
-
|
|
686
|
-
|
|
687
|
-
|
|
495
|
+
export function sha256(inputs) {
|
|
496
|
+
try {
|
|
497
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
498
|
+
const ptr0 = passArray8ToWasm0(inputs, wasm.__wbindgen_malloc);
|
|
499
|
+
const len0 = WASM_VECTOR_LEN;
|
|
500
|
+
wasm.sha256(retptr, ptr0, len0);
|
|
501
|
+
var r0 = getInt32Memory0()[retptr / 4 + 0];
|
|
502
|
+
var r1 = getInt32Memory0()[retptr / 4 + 1];
|
|
503
|
+
var v2 = getArrayU8FromWasm0(r0, r1).slice();
|
|
504
|
+
wasm.__wbindgen_free(r0, r1 * 1);
|
|
505
|
+
return v2;
|
|
506
|
+
} finally {
|
|
507
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
688
508
|
}
|
|
509
|
+
}
|
|
689
510
|
|
|
690
|
-
|
|
691
|
-
|
|
692
|
-
|
|
511
|
+
/**
|
|
512
|
+
* Calculates the Blake2s256 hash of the input bytes
|
|
513
|
+
* @param {Uint8Array} inputs
|
|
514
|
+
* @returns {Uint8Array}
|
|
515
|
+
*/
|
|
516
|
+
export function blake2s256(inputs) {
|
|
517
|
+
try {
|
|
518
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
519
|
+
const ptr0 = passArray8ToWasm0(inputs, wasm.__wbindgen_malloc);
|
|
520
|
+
const len0 = WASM_VECTOR_LEN;
|
|
521
|
+
wasm.blake2s256(retptr, ptr0, len0);
|
|
522
|
+
var r0 = getInt32Memory0()[retptr / 4 + 0];
|
|
523
|
+
var r1 = getInt32Memory0()[retptr / 4 + 1];
|
|
524
|
+
var v2 = getArrayU8FromWasm0(r0, r1).slice();
|
|
525
|
+
wasm.__wbindgen_free(r0, r1 * 1);
|
|
526
|
+
return v2;
|
|
527
|
+
} finally {
|
|
528
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
693
529
|
}
|
|
694
|
-
|
|
695
|
-
|
|
696
|
-
|
|
697
|
-
|
|
698
|
-
|
|
699
|
-
|
|
530
|
+
}
|
|
531
|
+
|
|
532
|
+
/**
|
|
533
|
+
* Calculates the Keccak256 hash of the input bytes
|
|
534
|
+
* @param {Uint8Array} inputs
|
|
535
|
+
* @returns {Uint8Array}
|
|
536
|
+
*/
|
|
537
|
+
export function keccak256(inputs) {
|
|
538
|
+
try {
|
|
539
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
540
|
+
const ptr0 = passArray8ToWasm0(inputs, wasm.__wbindgen_malloc);
|
|
541
|
+
const len0 = WASM_VECTOR_LEN;
|
|
542
|
+
wasm.keccak256(retptr, ptr0, len0);
|
|
543
|
+
var r0 = getInt32Memory0()[retptr / 4 + 0];
|
|
544
|
+
var r1 = getInt32Memory0()[retptr / 4 + 1];
|
|
545
|
+
var v2 = getArrayU8FromWasm0(r0, r1).slice();
|
|
546
|
+
wasm.__wbindgen_free(r0, r1 * 1);
|
|
547
|
+
return v2;
|
|
548
|
+
} finally {
|
|
549
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
700
550
|
}
|
|
701
551
|
}
|
|
552
|
+
|
|
702
553
|
/**
|
|
554
|
+
* Verifies a ECDSA signature over the secp256k1 curve.
|
|
555
|
+
* @param {Uint8Array} hashed_msg
|
|
556
|
+
* @param {Uint8Array} public_key_x_bytes
|
|
557
|
+
* @param {Uint8Array} public_key_y_bytes
|
|
558
|
+
* @param {Uint8Array} signature
|
|
559
|
+
* @returns {boolean}
|
|
703
560
|
*/
|
|
704
|
-
export
|
|
561
|
+
export function ecdsa_secp256k1_verify(hashed_msg, public_key_x_bytes, public_key_y_bytes, signature) {
|
|
562
|
+
const ptr0 = passArray8ToWasm0(hashed_msg, wasm.__wbindgen_malloc);
|
|
563
|
+
const len0 = WASM_VECTOR_LEN;
|
|
564
|
+
const ptr1 = passArray8ToWasm0(public_key_x_bytes, wasm.__wbindgen_malloc);
|
|
565
|
+
const len1 = WASM_VECTOR_LEN;
|
|
566
|
+
const ptr2 = passArray8ToWasm0(public_key_y_bytes, wasm.__wbindgen_malloc);
|
|
567
|
+
const len2 = WASM_VECTOR_LEN;
|
|
568
|
+
const ptr3 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
|
|
569
|
+
const len3 = WASM_VECTOR_LEN;
|
|
570
|
+
const ret = wasm.ecdsa_secp256k1_verify(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
|
|
571
|
+
return ret !== 0;
|
|
572
|
+
}
|
|
705
573
|
|
|
706
|
-
|
|
707
|
-
|
|
708
|
-
|
|
709
|
-
|
|
574
|
+
/**
|
|
575
|
+
* Verifies a ECDSA signature over the secp256r1 curve.
|
|
576
|
+
* @param {Uint8Array} hashed_msg
|
|
577
|
+
* @param {Uint8Array} public_key_x_bytes
|
|
578
|
+
* @param {Uint8Array} public_key_y_bytes
|
|
579
|
+
* @param {Uint8Array} signature
|
|
580
|
+
* @returns {boolean}
|
|
581
|
+
*/
|
|
582
|
+
export function ecdsa_secp256r1_verify(hashed_msg, public_key_x_bytes, public_key_y_bytes, signature) {
|
|
583
|
+
const ptr0 = passArray8ToWasm0(hashed_msg, wasm.__wbindgen_malloc);
|
|
584
|
+
const len0 = WASM_VECTOR_LEN;
|
|
585
|
+
const ptr1 = passArray8ToWasm0(public_key_x_bytes, wasm.__wbindgen_malloc);
|
|
586
|
+
const len1 = WASM_VECTOR_LEN;
|
|
587
|
+
const ptr2 = passArray8ToWasm0(public_key_y_bytes, wasm.__wbindgen_malloc);
|
|
588
|
+
const len2 = WASM_VECTOR_LEN;
|
|
589
|
+
const ptr3 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
|
|
590
|
+
const len3 = WASM_VECTOR_LEN;
|
|
591
|
+
const ret = wasm.ecdsa_secp256r1_verify(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
|
|
592
|
+
return ret !== 0;
|
|
593
|
+
}
|
|
710
594
|
|
|
711
|
-
|
|
595
|
+
/**
|
|
596
|
+
* Sets the package's logging level.
|
|
597
|
+
*
|
|
598
|
+
* @param {LogLevel} level - The maximum level of logging to be emitted.
|
|
599
|
+
*/
|
|
600
|
+
export function initLogLevel(filter) {
|
|
601
|
+
try {
|
|
602
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
603
|
+
const ptr0 = passStringToWasm0(filter, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
604
|
+
const len0 = WASM_VECTOR_LEN;
|
|
605
|
+
wasm.initLogLevel(retptr, ptr0, len0);
|
|
606
|
+
var r0 = getInt32Memory0()[retptr / 4 + 0];
|
|
607
|
+
var r1 = getInt32Memory0()[retptr / 4 + 1];
|
|
608
|
+
if (r1) {
|
|
609
|
+
throw takeObject(r0);
|
|
610
|
+
}
|
|
611
|
+
} finally {
|
|
612
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
712
613
|
}
|
|
614
|
+
}
|
|
713
615
|
|
|
714
|
-
|
|
715
|
-
|
|
716
|
-
|
|
717
|
-
|
|
718
|
-
return ptr;
|
|
719
|
-
}
|
|
616
|
+
function __wbg_adapter_76(arg0, arg1, arg2, arg3, arg4) {
|
|
617
|
+
wasm.wasm_bindgen__convert__closures__invoke3_mut__h629417323d5efbaa(arg0, arg1, addHeapObject(arg2), arg3, addHeapObject(arg4));
|
|
618
|
+
}
|
|
720
619
|
|
|
721
|
-
|
|
722
|
-
|
|
723
|
-
|
|
620
|
+
function handleError(f, args) {
|
|
621
|
+
try {
|
|
622
|
+
return f.apply(this, args);
|
|
623
|
+
} catch (e) {
|
|
624
|
+
wasm.__wbindgen_exn_store(addHeapObject(e));
|
|
724
625
|
}
|
|
725
626
|
}
|
|
627
|
+
function __wbg_adapter_93(arg0, arg1, arg2, arg3) {
|
|
628
|
+
wasm.wasm_bindgen__convert__closures__invoke2_mut__h4efdd1050cfb3ea7(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
|
|
629
|
+
}
|
|
726
630
|
|
|
727
631
|
async function __wbg_load(module, imports) {
|
|
728
632
|
if (typeof Response === 'function' && module instanceof Response) {
|
|
@@ -761,15 +665,19 @@ function __wbg_get_imports() {
|
|
|
761
665
|
imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
|
|
762
666
|
takeObject(arg0);
|
|
763
667
|
};
|
|
764
|
-
imports.wbg.
|
|
765
|
-
const ret =
|
|
668
|
+
imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
|
|
669
|
+
const ret = getStringFromWasm0(arg0, arg1);
|
|
766
670
|
return addHeapObject(ret);
|
|
767
671
|
};
|
|
768
|
-
imports.wbg.
|
|
769
|
-
const ret = getObject(arg0);
|
|
672
|
+
imports.wbg.__wbindgen_is_array = function(arg0) {
|
|
673
|
+
const ret = Array.isArray(getObject(arg0));
|
|
674
|
+
return ret;
|
|
675
|
+
};
|
|
676
|
+
imports.wbg.__wbg_constructor_971e67e66cc5bd6a = function(arg0) {
|
|
677
|
+
const ret = new Error(takeObject(arg0));
|
|
770
678
|
return addHeapObject(ret);
|
|
771
679
|
};
|
|
772
|
-
imports.wbg.
|
|
680
|
+
imports.wbg.__wbg_new_193bac1dd2be232d = function() {
|
|
773
681
|
const ret = new Map();
|
|
774
682
|
return addHeapObject(ret);
|
|
775
683
|
};
|
|
@@ -777,10 +685,6 @@ function __wbg_get_imports() {
|
|
|
777
685
|
const ret = arg0;
|
|
778
686
|
return addHeapObject(ret);
|
|
779
687
|
};
|
|
780
|
-
imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
|
|
781
|
-
const ret = getStringFromWasm0(arg0, arg1);
|
|
782
|
-
return addHeapObject(ret);
|
|
783
|
-
};
|
|
784
688
|
imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
|
|
785
689
|
const obj = getObject(arg1);
|
|
786
690
|
const ret = typeof(obj) === 'string' ? obj : undefined;
|
|
@@ -789,13 +693,11 @@ function __wbg_get_imports() {
|
|
|
789
693
|
getInt32Memory0()[arg0 / 4 + 1] = len1;
|
|
790
694
|
getInt32Memory0()[arg0 / 4 + 0] = ptr1;
|
|
791
695
|
};
|
|
792
|
-
imports.wbg.
|
|
793
|
-
const
|
|
794
|
-
|
|
795
|
-
|
|
796
|
-
|
|
797
|
-
const ret = new Error(takeObject(arg0));
|
|
798
|
-
return addHeapObject(ret);
|
|
696
|
+
imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
|
|
697
|
+
const obj = getObject(arg1);
|
|
698
|
+
const ret = typeof(obj) === 'number' ? obj : undefined;
|
|
699
|
+
getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
|
|
700
|
+
getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
|
|
799
701
|
};
|
|
800
702
|
imports.wbg.__wbindgen_cb_drop = function(arg0) {
|
|
801
703
|
const obj = takeObject(arg0).original;
|
|
@@ -806,28 +708,14 @@ function __wbg_get_imports() {
|
|
|
806
708
|
const ret = false;
|
|
807
709
|
return ret;
|
|
808
710
|
};
|
|
809
|
-
imports.wbg.
|
|
810
|
-
const ret =
|
|
811
|
-
return ret;
|
|
812
|
-
};
|
|
813
|
-
imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
|
|
814
|
-
const obj = getObject(arg1);
|
|
815
|
-
const ret = typeof(obj) === 'number' ? obj : undefined;
|
|
816
|
-
getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
|
|
817
|
-
getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
|
|
818
|
-
};
|
|
819
|
-
imports.wbg.__wbindgen_is_array = function(arg0) {
|
|
820
|
-
const ret = Array.isArray(getObject(arg0));
|
|
821
|
-
return ret;
|
|
711
|
+
imports.wbg.__wbg_new_f139361aad331bd0 = function() {
|
|
712
|
+
const ret = new Array();
|
|
713
|
+
return addHeapObject(ret);
|
|
822
714
|
};
|
|
823
715
|
imports.wbg.__wbindgen_is_string = function(arg0) {
|
|
824
716
|
const ret = typeof(getObject(arg0)) === 'string';
|
|
825
717
|
return ret;
|
|
826
718
|
};
|
|
827
|
-
imports.wbg.__wbg_new_ee5ac63ff3b0fa4d = function() {
|
|
828
|
-
const ret = new Array();
|
|
829
|
-
return addHeapObject(ret);
|
|
830
|
-
};
|
|
831
719
|
imports.wbg.__wbg_new_abda76e883ba8a5f = function() {
|
|
832
720
|
const ret = new Error();
|
|
833
721
|
return addHeapObject(ret);
|
|
@@ -850,53 +738,6 @@ function __wbg_get_imports() {
|
|
|
850
738
|
wasm.__wbindgen_free(deferred0_0, deferred0_1);
|
|
851
739
|
}
|
|
852
740
|
};
|
|
853
|
-
imports.wbg.__wbindgen_ge = function(arg0, arg1) {
|
|
854
|
-
const ret = getObject(arg0) >= getObject(arg1);
|
|
855
|
-
return ret;
|
|
856
|
-
};
|
|
857
|
-
imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
|
|
858
|
-
const ret = BigInt.asUintN(64, arg0);
|
|
859
|
-
return addHeapObject(ret);
|
|
860
|
-
};
|
|
861
|
-
imports.wbg.__wbindgen_shr = function(arg0, arg1) {
|
|
862
|
-
const ret = getObject(arg0) >> getObject(arg1);
|
|
863
|
-
return addHeapObject(ret);
|
|
864
|
-
};
|
|
865
|
-
imports.wbg.__wbindgen_jsval_eq = function(arg0, arg1) {
|
|
866
|
-
const ret = getObject(arg0) === getObject(arg1);
|
|
867
|
-
return ret;
|
|
868
|
-
};
|
|
869
|
-
imports.wbg.__wbindgen_is_bigint = function(arg0) {
|
|
870
|
-
const ret = typeof(getObject(arg0)) === 'bigint';
|
|
871
|
-
return ret;
|
|
872
|
-
};
|
|
873
|
-
imports.wbg.__wbindgen_bigint_from_i64 = function(arg0) {
|
|
874
|
-
const ret = arg0;
|
|
875
|
-
return addHeapObject(ret);
|
|
876
|
-
};
|
|
877
|
-
imports.wbg.__wbindgen_bigint_from_u128 = function(arg0, arg1) {
|
|
878
|
-
const ret = BigInt.asUintN(64, arg0) << BigInt(64) | BigInt.asUintN(64, arg1);
|
|
879
|
-
return addHeapObject(ret);
|
|
880
|
-
};
|
|
881
|
-
imports.wbg.__wbindgen_is_object = function(arg0) {
|
|
882
|
-
const val = getObject(arg0);
|
|
883
|
-
const ret = typeof(val) === 'object' && val !== null;
|
|
884
|
-
return ret;
|
|
885
|
-
};
|
|
886
|
-
imports.wbg.__wbindgen_is_function = function(arg0) {
|
|
887
|
-
const ret = typeof(getObject(arg0)) === 'function';
|
|
888
|
-
return ret;
|
|
889
|
-
};
|
|
890
|
-
imports.wbg.__wbg_instanceof_Global_f4b019d2b45e18ab = function(arg0) {
|
|
891
|
-
let result;
|
|
892
|
-
try {
|
|
893
|
-
result = getObject(arg0) instanceof WebAssembly.Global;
|
|
894
|
-
} catch {
|
|
895
|
-
result = false;
|
|
896
|
-
}
|
|
897
|
-
const ret = result;
|
|
898
|
-
return ret;
|
|
899
|
-
};
|
|
900
741
|
imports.wbg.__wbg_debug_e3f6a1578e6d45ca = function(arg0) {
|
|
901
742
|
console.debug(getObject(arg0));
|
|
902
743
|
};
|
|
@@ -921,36 +762,6 @@ function __wbg_get_imports() {
|
|
|
921
762
|
imports.wbg.__wbg_warn_8342bfbc6028193a = function(arg0, arg1, arg2, arg3) {
|
|
922
763
|
console.warn(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
|
|
923
764
|
};
|
|
924
|
-
imports.wbg.__wbg_crypto_c48a774b022d20ac = function(arg0) {
|
|
925
|
-
const ret = getObject(arg0).crypto;
|
|
926
|
-
return addHeapObject(ret);
|
|
927
|
-
};
|
|
928
|
-
imports.wbg.__wbg_process_298734cf255a885d = function(arg0) {
|
|
929
|
-
const ret = getObject(arg0).process;
|
|
930
|
-
return addHeapObject(ret);
|
|
931
|
-
};
|
|
932
|
-
imports.wbg.__wbg_versions_e2e78e134e3e5d01 = function(arg0) {
|
|
933
|
-
const ret = getObject(arg0).versions;
|
|
934
|
-
return addHeapObject(ret);
|
|
935
|
-
};
|
|
936
|
-
imports.wbg.__wbg_node_1cd7a5d853dbea79 = function(arg0) {
|
|
937
|
-
const ret = getObject(arg0).node;
|
|
938
|
-
return addHeapObject(ret);
|
|
939
|
-
};
|
|
940
|
-
imports.wbg.__wbg_msCrypto_bcb970640f50a1e8 = function(arg0) {
|
|
941
|
-
const ret = getObject(arg0).msCrypto;
|
|
942
|
-
return addHeapObject(ret);
|
|
943
|
-
};
|
|
944
|
-
imports.wbg.__wbg_require_8f08ceecec0f4fee = function() { return handleError(function () {
|
|
945
|
-
const ret = module.require;
|
|
946
|
-
return addHeapObject(ret);
|
|
947
|
-
}, arguments) };
|
|
948
|
-
imports.wbg.__wbg_randomFillSync_dc1e9a60c158336d = function() { return handleError(function (arg0, arg1) {
|
|
949
|
-
getObject(arg0).randomFillSync(takeObject(arg1));
|
|
950
|
-
}, arguments) };
|
|
951
|
-
imports.wbg.__wbg_getRandomValues_37fa2ca9e4e07fab = function() { return handleError(function (arg0, arg1) {
|
|
952
|
-
getObject(arg0).getRandomValues(getObject(arg1));
|
|
953
|
-
}, arguments) };
|
|
954
765
|
imports.wbg.__wbg_get_7303ed2ef026b2f5 = function(arg0, arg1) {
|
|
955
766
|
const ret = getObject(arg0)[arg1 >>> 0];
|
|
956
767
|
return addHeapObject(ret);
|
|
@@ -963,53 +774,10 @@ function __wbg_get_imports() {
|
|
|
963
774
|
const ret = new Array();
|
|
964
775
|
return addHeapObject(ret);
|
|
965
776
|
};
|
|
966
|
-
imports.wbg.__wbg_BigInt_9523742cb675bb6f = function(arg0) {
|
|
967
|
-
const ret = BigInt(getObject(arg0));
|
|
968
|
-
return addHeapObject(ret);
|
|
969
|
-
};
|
|
970
|
-
imports.wbg.__wbg_newnoargs_c9e6043b8ad84109 = function(arg0, arg1) {
|
|
971
|
-
const ret = new Function(getStringFromWasm0(arg0, arg1));
|
|
972
|
-
return addHeapObject(ret);
|
|
973
|
-
};
|
|
974
777
|
imports.wbg.__wbg_new_0f2b71ca2f2a6029 = function() {
|
|
975
778
|
const ret = new Map();
|
|
976
779
|
return addHeapObject(ret);
|
|
977
780
|
};
|
|
978
|
-
imports.wbg.__wbg_get_f53c921291c381bd = function() { return handleError(function (arg0, arg1) {
|
|
979
|
-
const ret = Reflect.get(getObject(arg0), getObject(arg1));
|
|
980
|
-
return addHeapObject(ret);
|
|
981
|
-
}, arguments) };
|
|
982
|
-
imports.wbg.__wbg_call_557a2f2deacc4912 = function() { return handleError(function (arg0, arg1) {
|
|
983
|
-
const ret = getObject(arg0).call(getObject(arg1));
|
|
984
|
-
return addHeapObject(ret);
|
|
985
|
-
}, arguments) };
|
|
986
|
-
imports.wbg.__wbg_new_2b6fea4ea03b1b95 = function() {
|
|
987
|
-
const ret = new Object();
|
|
988
|
-
return addHeapObject(ret);
|
|
989
|
-
};
|
|
990
|
-
imports.wbg.__wbg_self_742dd6eab3e9211e = function() { return handleError(function () {
|
|
991
|
-
const ret = self.self;
|
|
992
|
-
return addHeapObject(ret);
|
|
993
|
-
}, arguments) };
|
|
994
|
-
imports.wbg.__wbg_window_c409e731db53a0e2 = function() { return handleError(function () {
|
|
995
|
-
const ret = window.window;
|
|
996
|
-
return addHeapObject(ret);
|
|
997
|
-
}, arguments) };
|
|
998
|
-
imports.wbg.__wbg_globalThis_b70c095388441f2d = function() { return handleError(function () {
|
|
999
|
-
const ret = globalThis.globalThis;
|
|
1000
|
-
return addHeapObject(ret);
|
|
1001
|
-
}, arguments) };
|
|
1002
|
-
imports.wbg.__wbg_global_1c72617491ed7194 = function() { return handleError(function () {
|
|
1003
|
-
const ret = global.global;
|
|
1004
|
-
return addHeapObject(ret);
|
|
1005
|
-
}, arguments) };
|
|
1006
|
-
imports.wbg.__wbg_newwithlength_cd1db47a173e3944 = function(arg0) {
|
|
1007
|
-
const ret = new Array(arg0 >>> 0);
|
|
1008
|
-
return addHeapObject(ret);
|
|
1009
|
-
};
|
|
1010
|
-
imports.wbg.__wbg_set_b4da98d504ac6091 = function(arg0, arg1, arg2) {
|
|
1011
|
-
getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
|
|
1012
|
-
};
|
|
1013
781
|
imports.wbg.__wbg_from_6bc98a09a0b58bb1 = function(arg0) {
|
|
1014
782
|
const ret = Array.from(getObject(arg0));
|
|
1015
783
|
return addHeapObject(ret);
|
|
@@ -1021,7 +789,7 @@ function __wbg_get_imports() {
|
|
|
1021
789
|
const a = state0.a;
|
|
1022
790
|
state0.a = 0;
|
|
1023
791
|
try {
|
|
1024
|
-
return
|
|
792
|
+
return __wbg_adapter_76(a, state0.b, arg0, arg1, arg2);
|
|
1025
793
|
} finally {
|
|
1026
794
|
state0.a = a;
|
|
1027
795
|
}
|
|
@@ -1039,27 +807,6 @@ function __wbg_get_imports() {
|
|
|
1039
807
|
const ret = getObject(arg0).reverse();
|
|
1040
808
|
return addHeapObject(ret);
|
|
1041
809
|
};
|
|
1042
|
-
imports.wbg.__wbg_byteLength_1a59a59856fc656a = function(arg0) {
|
|
1043
|
-
const ret = getObject(arg0).byteLength;
|
|
1044
|
-
return ret;
|
|
1045
|
-
};
|
|
1046
|
-
imports.wbg.__wbg_toString_68dcf9fa017bbb08 = function(arg0, arg1, arg2) {
|
|
1047
|
-
const ret = getObject(arg1).toString(arg2);
|
|
1048
|
-
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1049
|
-
const len1 = WASM_VECTOR_LEN;
|
|
1050
|
-
getInt32Memory0()[arg0 / 4 + 1] = len1;
|
|
1051
|
-
getInt32Memory0()[arg0 / 4 + 0] = ptr1;
|
|
1052
|
-
};
|
|
1053
|
-
imports.wbg.__wbg_instanceof_Error_fac23a8832b241da = function(arg0) {
|
|
1054
|
-
let result;
|
|
1055
|
-
try {
|
|
1056
|
-
result = getObject(arg0) instanceof Error;
|
|
1057
|
-
} catch {
|
|
1058
|
-
result = false;
|
|
1059
|
-
}
|
|
1060
|
-
const ret = result;
|
|
1061
|
-
return ret;
|
|
1062
|
-
};
|
|
1063
810
|
imports.wbg.__wbg_new_87297f22973157c8 = function(arg0, arg1) {
|
|
1064
811
|
const ret = new Error(getStringFromWasm0(arg0, arg1));
|
|
1065
812
|
return addHeapObject(ret);
|
|
@@ -1067,20 +814,6 @@ function __wbg_get_imports() {
|
|
|
1067
814
|
imports.wbg.__wbg_setcause_394738aae0ce9341 = function(arg0, arg1) {
|
|
1068
815
|
getObject(arg0).cause = getObject(arg1);
|
|
1069
816
|
};
|
|
1070
|
-
imports.wbg.__wbg_message_eab7d45ec69a2135 = function(arg0) {
|
|
1071
|
-
const ret = getObject(arg0).message;
|
|
1072
|
-
return addHeapObject(ret);
|
|
1073
|
-
};
|
|
1074
|
-
imports.wbg.__wbg_instanceof_Function_8e1bcaacb89c4438 = function(arg0) {
|
|
1075
|
-
let result;
|
|
1076
|
-
try {
|
|
1077
|
-
result = getObject(arg0) instanceof Function;
|
|
1078
|
-
} catch {
|
|
1079
|
-
result = false;
|
|
1080
|
-
}
|
|
1081
|
-
const ret = result;
|
|
1082
|
-
return ret;
|
|
1083
|
-
};
|
|
1084
817
|
imports.wbg.__wbg_call_587b30eea3e09332 = function() { return handleError(function (arg0, arg1, arg2) {
|
|
1085
818
|
const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
|
|
1086
819
|
return addHeapObject(ret);
|
|
@@ -1089,14 +822,6 @@ function __wbg_get_imports() {
|
|
|
1089
822
|
const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
|
|
1090
823
|
return addHeapObject(ret);
|
|
1091
824
|
}, arguments) };
|
|
1092
|
-
imports.wbg.__wbg_bind_7d5ce7224bedd5b8 = function(arg0, arg1, arg2) {
|
|
1093
|
-
const ret = getObject(arg0).bind(getObject(arg1), getObject(arg2));
|
|
1094
|
-
return addHeapObject(ret);
|
|
1095
|
-
};
|
|
1096
|
-
imports.wbg.__wbg_bind_f5218b29220675c3 = function(arg0, arg1, arg2, arg3) {
|
|
1097
|
-
const ret = getObject(arg0).bind(getObject(arg1), getObject(arg2), getObject(arg3));
|
|
1098
|
-
return addHeapObject(ret);
|
|
1099
|
-
};
|
|
1100
825
|
imports.wbg.__wbg_forEach_942772130a8d06a6 = function(arg0, arg1, arg2) {
|
|
1101
826
|
try {
|
|
1102
827
|
var state0 = {a: arg1, b: arg2};
|
|
@@ -1104,7 +829,7 @@ function __wbg_get_imports() {
|
|
|
1104
829
|
const a = state0.a;
|
|
1105
830
|
state0.a = 0;
|
|
1106
831
|
try {
|
|
1107
|
-
return
|
|
832
|
+
return __wbg_adapter_93(a, state0.b, arg0, arg1);
|
|
1108
833
|
} finally {
|
|
1109
834
|
state0.a = a;
|
|
1110
835
|
}
|
|
@@ -1118,28 +843,10 @@ function __wbg_get_imports() {
|
|
|
1118
843
|
const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
|
|
1119
844
|
return addHeapObject(ret);
|
|
1120
845
|
};
|
|
1121
|
-
imports.wbg.__wbg_instanceof_Object_a9e9e5766628e8b5 = function(arg0) {
|
|
1122
|
-
let result;
|
|
1123
|
-
try {
|
|
1124
|
-
result = getObject(arg0) instanceof Object;
|
|
1125
|
-
} catch {
|
|
1126
|
-
result = false;
|
|
1127
|
-
}
|
|
1128
|
-
const ret = result;
|
|
1129
|
-
return ret;
|
|
1130
|
-
};
|
|
1131
|
-
imports.wbg.__wbg_constructor_f2623999a1f453eb = function(arg0) {
|
|
1132
|
-
const ret = getObject(arg0).constructor;
|
|
1133
|
-
return addHeapObject(ret);
|
|
1134
|
-
};
|
|
1135
846
|
imports.wbg.__wbg_fromEntries_d1b310956d20d858 = function() { return handleError(function (arg0) {
|
|
1136
847
|
const ret = Object.fromEntries(getObject(arg0));
|
|
1137
848
|
return addHeapObject(ret);
|
|
1138
849
|
}, arguments) };
|
|
1139
|
-
imports.wbg.__wbg_toString_e2b23ac99490a381 = function(arg0) {
|
|
1140
|
-
const ret = getObject(arg0).toString();
|
|
1141
|
-
return addHeapObject(ret);
|
|
1142
|
-
};
|
|
1143
850
|
imports.wbg.__wbg_values_099fd000c271c313 = function(arg0) {
|
|
1144
851
|
const ret = Object.values(getObject(arg0));
|
|
1145
852
|
return addHeapObject(ret);
|
|
@@ -1151,7 +858,7 @@ function __wbg_get_imports() {
|
|
|
1151
858
|
const a = state0.a;
|
|
1152
859
|
state0.a = 0;
|
|
1153
860
|
try {
|
|
1154
|
-
return
|
|
861
|
+
return __wbg_adapter_93(a, state0.b, arg0, arg1);
|
|
1155
862
|
} finally {
|
|
1156
863
|
state0.a = a;
|
|
1157
864
|
}
|
|
@@ -1174,99 +881,14 @@ function __wbg_get_imports() {
|
|
|
1174
881
|
const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
|
|
1175
882
|
return addHeapObject(ret);
|
|
1176
883
|
};
|
|
1177
|
-
imports.wbg.__wbg_buffer_55ba7a6b1b92e2ac = function(arg0) {
|
|
1178
|
-
const ret = getObject(arg0).buffer;
|
|
1179
|
-
return addHeapObject(ret);
|
|
1180
|
-
};
|
|
1181
|
-
imports.wbg.__wbg_newwithbyteoffsetandlength_88d1d8be5df94b9b = function(arg0, arg1, arg2) {
|
|
1182
|
-
const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
|
|
1183
|
-
return addHeapObject(ret);
|
|
1184
|
-
};
|
|
1185
|
-
imports.wbg.__wbg_new_09938a7d020f049b = function(arg0) {
|
|
1186
|
-
const ret = new Uint8Array(getObject(arg0));
|
|
1187
|
-
return addHeapObject(ret);
|
|
1188
|
-
};
|
|
1189
|
-
imports.wbg.__wbg_set_3698e3ca519b3c3c = function(arg0, arg1, arg2) {
|
|
1190
|
-
getObject(arg0).set(getObject(arg1), arg2 >>> 0);
|
|
1191
|
-
};
|
|
1192
|
-
imports.wbg.__wbg_length_0aab7ffd65ad19ed = function(arg0) {
|
|
1193
|
-
const ret = getObject(arg0).length;
|
|
1194
|
-
return ret;
|
|
1195
|
-
};
|
|
1196
|
-
imports.wbg.__wbg_newwithlength_89eeca401d8918c2 = function(arg0) {
|
|
1197
|
-
const ret = new Uint8Array(arg0 >>> 0);
|
|
1198
|
-
return addHeapObject(ret);
|
|
1199
|
-
};
|
|
1200
|
-
imports.wbg.__wbg_subarray_d82be056deb4ad27 = function(arg0, arg1, arg2) {
|
|
1201
|
-
const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
|
|
1202
|
-
return addHeapObject(ret);
|
|
1203
|
-
};
|
|
1204
884
|
imports.wbg.__wbg_parse_76a8a18ca3f8730b = function() { return handleError(function (arg0, arg1) {
|
|
1205
885
|
const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
|
|
1206
886
|
return addHeapObject(ret);
|
|
1207
887
|
}, arguments) };
|
|
1208
|
-
imports.wbg.__wbg_compile_eefe73dfb19bff3d = function(arg0) {
|
|
1209
|
-
const ret = WebAssembly.compile(getObject(arg0));
|
|
1210
|
-
return addHeapObject(ret);
|
|
1211
|
-
};
|
|
1212
|
-
imports.wbg.__wbg_instantiate_e61ee50cd947cd36 = function(arg0, arg1) {
|
|
1213
|
-
const ret = WebAssembly.instantiate(getObject(arg0), getObject(arg1));
|
|
1214
|
-
return addHeapObject(ret);
|
|
1215
|
-
};
|
|
1216
|
-
imports.wbg.__wbg_exports_311291a1333429a3 = function(arg0) {
|
|
1217
|
-
const ret = getObject(arg0).exports;
|
|
1218
|
-
return addHeapObject(ret);
|
|
1219
|
-
};
|
|
1220
|
-
imports.wbg.__wbg_exports_12505982ae149cb0 = function(arg0) {
|
|
1221
|
-
const ret = WebAssembly.Module.exports(getObject(arg0));
|
|
1222
|
-
return addHeapObject(ret);
|
|
1223
|
-
};
|
|
1224
|
-
imports.wbg.__wbg_instanceof_Table_b0af5234a12a19f9 = function(arg0) {
|
|
1225
|
-
let result;
|
|
1226
|
-
try {
|
|
1227
|
-
result = getObject(arg0) instanceof WebAssembly.Table;
|
|
1228
|
-
} catch {
|
|
1229
|
-
result = false;
|
|
1230
|
-
}
|
|
1231
|
-
const ret = result;
|
|
1232
|
-
return ret;
|
|
1233
|
-
};
|
|
1234
|
-
imports.wbg.__wbg_get_b5def15f90c3e295 = function() { return handleError(function (arg0, arg1) {
|
|
1235
|
-
const ret = getObject(arg0).get(arg1 >>> 0);
|
|
1236
|
-
return addHeapObject(ret);
|
|
1237
|
-
}, arguments) };
|
|
1238
|
-
imports.wbg.__wbg_instanceof_Memory_331618ccd3fa615d = function(arg0) {
|
|
1239
|
-
let result;
|
|
1240
|
-
try {
|
|
1241
|
-
result = getObject(arg0) instanceof WebAssembly.Memory;
|
|
1242
|
-
} catch {
|
|
1243
|
-
result = false;
|
|
1244
|
-
}
|
|
1245
|
-
const ret = result;
|
|
1246
|
-
return ret;
|
|
1247
|
-
};
|
|
1248
|
-
imports.wbg.__wbg_new_e40873b83efb2dcd = function() { return handleError(function (arg0) {
|
|
1249
|
-
const ret = new WebAssembly.Memory(getObject(arg0));
|
|
1250
|
-
return addHeapObject(ret);
|
|
1251
|
-
}, arguments) };
|
|
1252
|
-
imports.wbg.__wbg_apply_46ea2bb0ad750196 = function() { return handleError(function (arg0, arg1, arg2) {
|
|
1253
|
-
const ret = Reflect.apply(getObject(arg0), getObject(arg1), getObject(arg2));
|
|
1254
|
-
return addHeapObject(ret);
|
|
1255
|
-
}, arguments) };
|
|
1256
|
-
imports.wbg.__wbg_getPrototypeOf_7dc7a2328db2bc0e = function() { return handleError(function (arg0) {
|
|
1257
|
-
const ret = Reflect.getPrototypeOf(getObject(arg0));
|
|
1258
|
-
return addHeapObject(ret);
|
|
1259
|
-
}, arguments) };
|
|
1260
888
|
imports.wbg.__wbg_set_07da13cc24b69217 = function() { return handleError(function (arg0, arg1, arg2) {
|
|
1261
889
|
const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
|
|
1262
890
|
return ret;
|
|
1263
891
|
}, arguments) };
|
|
1264
|
-
imports.wbg.__wbindgen_bigint_get_as_i64 = function(arg0, arg1) {
|
|
1265
|
-
const v = getObject(arg1);
|
|
1266
|
-
const ret = typeof(v) === 'bigint' ? v : undefined;
|
|
1267
|
-
getBigInt64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? BigInt(0) : ret;
|
|
1268
|
-
getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
|
|
1269
|
-
};
|
|
1270
892
|
imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
|
|
1271
893
|
const ret = debugString(getObject(arg1));
|
|
1272
894
|
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
@@ -1277,16 +899,8 @@ function __wbg_get_imports() {
|
|
|
1277
899
|
imports.wbg.__wbindgen_throw = function(arg0, arg1) {
|
|
1278
900
|
throw new Error(getStringFromWasm0(arg0, arg1));
|
|
1279
901
|
};
|
|
1280
|
-
imports.wbg.
|
|
1281
|
-
const ret =
|
|
1282
|
-
return addHeapObject(ret);
|
|
1283
|
-
};
|
|
1284
|
-
imports.wbg.__wbindgen_function_table = function() {
|
|
1285
|
-
const ret = wasm.__wbindgen_export_2;
|
|
1286
|
-
return addHeapObject(ret);
|
|
1287
|
-
};
|
|
1288
|
-
imports.wbg.__wbindgen_closure_wrapper2147 = function(arg0, arg1, arg2) {
|
|
1289
|
-
const ret = makeMutClosure(arg0, arg1, 720, __wbg_adapter_52);
|
|
902
|
+
imports.wbg.__wbindgen_closure_wrapper748 = function(arg0, arg1, arg2) {
|
|
903
|
+
const ret = makeMutClosure(arg0, arg1, 246, __wbg_adapter_22);
|
|
1290
904
|
return addHeapObject(ret);
|
|
1291
905
|
};
|
|
1292
906
|
|
|
@@ -1300,7 +914,6 @@ function __wbg_init_memory(imports, maybe_memory) {
|
|
|
1300
914
|
function __wbg_finalize_init(instance, module) {
|
|
1301
915
|
wasm = instance.exports;
|
|
1302
916
|
__wbg_init.__wbindgen_wasm_module = module;
|
|
1303
|
-
cachedBigInt64Memory0 = null;
|
|
1304
917
|
cachedFloat64Memory0 = null;
|
|
1305
918
|
cachedInt32Memory0 = null;
|
|
1306
919
|
cachedUint8Memory0 = null;
|