@aztec/noir-acvm_js 0.0.1-commit.fce3e4f → 0.0.1-commit.ffe5b04ea
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 +141 -123
- package/nodejs/acvm_js.js +686 -726
- package/nodejs/acvm_js_bg.wasm +0 -0
- package/nodejs/acvm_js_bg.wasm.d.ts +16 -15
- package/package.json +7 -7
- package/web/acvm_js.d.ts +188 -168
- package/web/acvm_js.js +723 -722
- package/web/acvm_js_bg.wasm +0 -0
- package/web/acvm_js_bg.wasm.d.ts +16 -15
package/nodejs/acvm_js.js
CHANGED
|
@@ -1,213 +1,155 @@
|
|
|
1
|
+
/* @ts-self-types="./acvm_js.d.ts" */
|
|
1
2
|
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
wasm.
|
|
10
|
-
return
|
|
11
|
-
}
|
|
12
|
-
|
|
13
|
-
function handleError(f, args) {
|
|
14
|
-
try {
|
|
15
|
-
return f.apply(this, args);
|
|
16
|
-
} catch (e) {
|
|
17
|
-
const idx = addToExternrefTable0(e);
|
|
18
|
-
wasm.__wbindgen_exn_store(idx);
|
|
19
|
-
}
|
|
20
|
-
}
|
|
21
|
-
|
|
22
|
-
let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
|
|
23
|
-
|
|
24
|
-
cachedTextDecoder.decode();
|
|
25
|
-
|
|
26
|
-
let cachedUint8ArrayMemory0 = null;
|
|
27
|
-
|
|
28
|
-
function getUint8ArrayMemory0() {
|
|
29
|
-
if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
|
|
30
|
-
cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
|
|
31
|
-
}
|
|
32
|
-
return cachedUint8ArrayMemory0;
|
|
3
|
+
/**
|
|
4
|
+
* Performs a bitwise AND operation between `lhs` and `rhs`
|
|
5
|
+
* @param {string} lhs
|
|
6
|
+
* @param {string} rhs
|
|
7
|
+
* @returns {string}
|
|
8
|
+
*/
|
|
9
|
+
function and(lhs, rhs) {
|
|
10
|
+
const ret = wasm.and(lhs, rhs);
|
|
11
|
+
return ret;
|
|
33
12
|
}
|
|
13
|
+
exports.and = and;
|
|
34
14
|
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
15
|
+
/**
|
|
16
|
+
* Calculates the Blake2s256 hash of the input bytes
|
|
17
|
+
* @param {Uint8Array} inputs
|
|
18
|
+
* @returns {Uint8Array}
|
|
19
|
+
*/
|
|
20
|
+
function blake2s256(inputs) {
|
|
21
|
+
const ptr0 = passArray8ToWasm0(inputs, wasm.__wbindgen_malloc);
|
|
22
|
+
const len0 = WASM_VECTOR_LEN;
|
|
23
|
+
const ret = wasm.blake2s256(ptr0, len0);
|
|
24
|
+
var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
25
|
+
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
26
|
+
return v2;
|
|
38
27
|
}
|
|
28
|
+
exports.blake2s256 = blake2s256;
|
|
39
29
|
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
return
|
|
30
|
+
/**
|
|
31
|
+
* Returns the `BuildInfo` object containing information about how the installed package was built.
|
|
32
|
+
* @returns {BuildInfo} - Information on how the installed package was built.
|
|
33
|
+
*/
|
|
34
|
+
function buildInfo() {
|
|
35
|
+
const ret = wasm.buildInfo();
|
|
36
|
+
return ret;
|
|
47
37
|
}
|
|
48
|
-
|
|
49
|
-
const buf = cachedTextEncoder.encode(arg);
|
|
50
|
-
view.set(buf);
|
|
51
|
-
return {
|
|
52
|
-
read: arg.length,
|
|
53
|
-
written: buf.length
|
|
54
|
-
};
|
|
55
|
-
});
|
|
56
|
-
|
|
57
|
-
function passStringToWasm0(arg, malloc, realloc) {
|
|
58
|
-
|
|
59
|
-
if (realloc === undefined) {
|
|
60
|
-
const buf = cachedTextEncoder.encode(arg);
|
|
61
|
-
const ptr = malloc(buf.length, 1) >>> 0;
|
|
62
|
-
getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
|
|
63
|
-
WASM_VECTOR_LEN = buf.length;
|
|
64
|
-
return ptr;
|
|
65
|
-
}
|
|
66
|
-
|
|
67
|
-
let len = arg.length;
|
|
68
|
-
let ptr = malloc(len, 1) >>> 0;
|
|
69
|
-
|
|
70
|
-
const mem = getUint8ArrayMemory0();
|
|
38
|
+
exports.buildInfo = buildInfo;
|
|
71
39
|
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
40
|
+
/**
|
|
41
|
+
* Compresses a `WitnessMap` into the binary format outputted by Nargo.
|
|
42
|
+
*
|
|
43
|
+
* @param {WitnessMap} witness_map - A witness map.
|
|
44
|
+
* @returns {Uint8Array} A compressed witness map
|
|
45
|
+
*/
|
|
46
|
+
function compressWitness(witness_map) {
|
|
47
|
+
const ret = wasm.compressWitness(witness_map);
|
|
48
|
+
if (ret[3]) {
|
|
49
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
78
50
|
}
|
|
51
|
+
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
52
|
+
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
53
|
+
return v1;
|
|
54
|
+
}
|
|
55
|
+
exports.compressWitness = compressWitness;
|
|
79
56
|
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
57
|
+
/**
|
|
58
|
+
* Compresses a `WitnessStack` into the binary format outputted by Nargo.
|
|
59
|
+
*
|
|
60
|
+
* @param {WitnessStack} witness_stack - A witness stack.
|
|
61
|
+
* @returns {Uint8Array} A compressed witness stack
|
|
62
|
+
*/
|
|
63
|
+
function compressWitnessStack(witness_stack) {
|
|
64
|
+
const ret = wasm.compressWitnessStack(witness_stack);
|
|
65
|
+
if (ret[3]) {
|
|
66
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
90
67
|
}
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
return
|
|
68
|
+
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
69
|
+
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
70
|
+
return v1;
|
|
94
71
|
}
|
|
72
|
+
exports.compressWitnessStack = compressWitnessStack;
|
|
95
73
|
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
74
|
+
/**
|
|
75
|
+
* Decompresses a compressed witness as outputted by Nargo into a `WitnessMap`.
|
|
76
|
+
* This should be used to only fetch the witness map for the main function.
|
|
77
|
+
*
|
|
78
|
+
* @param {Uint8Array} compressed_witness - A compressed witness.
|
|
79
|
+
* @returns {WitnessMap} The decompressed witness map.
|
|
80
|
+
*/
|
|
81
|
+
function decompressWitness(compressed_witness) {
|
|
82
|
+
const ptr0 = passArray8ToWasm0(compressed_witness, wasm.__wbindgen_malloc);
|
|
83
|
+
const len0 = WASM_VECTOR_LEN;
|
|
84
|
+
const ret = wasm.decompressWitness(ptr0, len0);
|
|
85
|
+
if (ret[2]) {
|
|
86
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
101
87
|
}
|
|
102
|
-
return
|
|
88
|
+
return takeFromExternrefTable0(ret[0]);
|
|
103
89
|
}
|
|
90
|
+
exports.decompressWitness = decompressWitness;
|
|
104
91
|
|
|
105
|
-
|
|
106
|
-
|
|
92
|
+
/**
|
|
93
|
+
* Decompresses a compressed witness stack as outputted by Nargo into a `WitnessStack`.
|
|
94
|
+
*
|
|
95
|
+
* @param {Uint8Array} compressed_witness - A compressed witness.
|
|
96
|
+
* @returns {WitnessStack} The decompressed witness stack.
|
|
97
|
+
*/
|
|
98
|
+
function decompressWitnessStack(compressed_witness) {
|
|
99
|
+
const ptr0 = passArray8ToWasm0(compressed_witness, wasm.__wbindgen_malloc);
|
|
100
|
+
const len0 = WASM_VECTOR_LEN;
|
|
101
|
+
const ret = wasm.decompressWitnessStack(ptr0, len0);
|
|
102
|
+
if (ret[2]) {
|
|
103
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
104
|
+
}
|
|
105
|
+
return takeFromExternrefTable0(ret[0]);
|
|
107
106
|
}
|
|
107
|
+
exports.decompressWitnessStack = decompressWitnessStack;
|
|
108
108
|
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
}
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
wasm.__wbindgen_export_6.get(state.dtor)(a, state.b);
|
|
129
|
-
CLOSURE_DTORS.unregister(state);
|
|
130
|
-
} else {
|
|
131
|
-
state.a = a;
|
|
132
|
-
}
|
|
133
|
-
}
|
|
134
|
-
};
|
|
135
|
-
real.original = state;
|
|
136
|
-
CLOSURE_DTORS.register(real, state, state);
|
|
137
|
-
return real;
|
|
109
|
+
/**
|
|
110
|
+
* Verifies a ECDSA signature over the secp256k1 curve.
|
|
111
|
+
* @param {Uint8Array} hashed_msg
|
|
112
|
+
* @param {Uint8Array} public_key_x_bytes
|
|
113
|
+
* @param {Uint8Array} public_key_y_bytes
|
|
114
|
+
* @param {Uint8Array} signature
|
|
115
|
+
* @returns {boolean}
|
|
116
|
+
*/
|
|
117
|
+
function ecdsa_secp256k1_verify(hashed_msg, public_key_x_bytes, public_key_y_bytes, signature) {
|
|
118
|
+
const ptr0 = passArray8ToWasm0(hashed_msg, wasm.__wbindgen_malloc);
|
|
119
|
+
const len0 = WASM_VECTOR_LEN;
|
|
120
|
+
const ptr1 = passArray8ToWasm0(public_key_x_bytes, wasm.__wbindgen_malloc);
|
|
121
|
+
const len1 = WASM_VECTOR_LEN;
|
|
122
|
+
const ptr2 = passArray8ToWasm0(public_key_y_bytes, wasm.__wbindgen_malloc);
|
|
123
|
+
const len2 = WASM_VECTOR_LEN;
|
|
124
|
+
const ptr3 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
|
|
125
|
+
const len3 = WASM_VECTOR_LEN;
|
|
126
|
+
const ret = wasm.ecdsa_secp256k1_verify(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
|
|
127
|
+
return ret !== 0;
|
|
138
128
|
}
|
|
129
|
+
exports.ecdsa_secp256k1_verify = ecdsa_secp256k1_verify;
|
|
139
130
|
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
if (typeof name == 'string' && name.length > 0) {
|
|
160
|
-
return `Function(${name})`;
|
|
161
|
-
} else {
|
|
162
|
-
return 'Function';
|
|
163
|
-
}
|
|
164
|
-
}
|
|
165
|
-
// objects
|
|
166
|
-
if (Array.isArray(val)) {
|
|
167
|
-
const length = val.length;
|
|
168
|
-
let debug = '[';
|
|
169
|
-
if (length > 0) {
|
|
170
|
-
debug += debugString(val[0]);
|
|
171
|
-
}
|
|
172
|
-
for(let i = 1; i < length; i++) {
|
|
173
|
-
debug += ', ' + debugString(val[i]);
|
|
174
|
-
}
|
|
175
|
-
debug += ']';
|
|
176
|
-
return debug;
|
|
177
|
-
}
|
|
178
|
-
// Test for built-in
|
|
179
|
-
const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
|
|
180
|
-
let className;
|
|
181
|
-
if (builtInMatches && builtInMatches.length > 1) {
|
|
182
|
-
className = builtInMatches[1];
|
|
183
|
-
} else {
|
|
184
|
-
// Failed to match the standard '[object ClassName]'
|
|
185
|
-
return toString.call(val);
|
|
186
|
-
}
|
|
187
|
-
if (className == 'Object') {
|
|
188
|
-
// we're a user defined class or Object
|
|
189
|
-
// JSON.stringify avoids problems with cycles, and is generally much
|
|
190
|
-
// easier than looping through ownProperties of `val`.
|
|
191
|
-
try {
|
|
192
|
-
return 'Object(' + JSON.stringify(val) + ')';
|
|
193
|
-
} catch (_) {
|
|
194
|
-
return 'Object';
|
|
195
|
-
}
|
|
196
|
-
}
|
|
197
|
-
// errors
|
|
198
|
-
if (val instanceof Error) {
|
|
199
|
-
return `${val.name}: ${val.message}\n${val.stack}`;
|
|
200
|
-
}
|
|
201
|
-
// TODO we could test for more things here, like `Set`s and `Map`s.
|
|
202
|
-
return className;
|
|
131
|
+
/**
|
|
132
|
+
* Verifies a ECDSA signature over the secp256r1 curve.
|
|
133
|
+
* @param {Uint8Array} hashed_msg
|
|
134
|
+
* @param {Uint8Array} public_key_x_bytes
|
|
135
|
+
* @param {Uint8Array} public_key_y_bytes
|
|
136
|
+
* @param {Uint8Array} signature
|
|
137
|
+
* @returns {boolean}
|
|
138
|
+
*/
|
|
139
|
+
function ecdsa_secp256r1_verify(hashed_msg, public_key_x_bytes, public_key_y_bytes, signature) {
|
|
140
|
+
const ptr0 = passArray8ToWasm0(hashed_msg, wasm.__wbindgen_malloc);
|
|
141
|
+
const len0 = WASM_VECTOR_LEN;
|
|
142
|
+
const ptr1 = passArray8ToWasm0(public_key_x_bytes, wasm.__wbindgen_malloc);
|
|
143
|
+
const len1 = WASM_VECTOR_LEN;
|
|
144
|
+
const ptr2 = passArray8ToWasm0(public_key_y_bytes, wasm.__wbindgen_malloc);
|
|
145
|
+
const len2 = WASM_VECTOR_LEN;
|
|
146
|
+
const ptr3 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
|
|
147
|
+
const len3 = WASM_VECTOR_LEN;
|
|
148
|
+
const ret = wasm.ecdsa_secp256r1_verify(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
|
|
149
|
+
return ret !== 0;
|
|
203
150
|
}
|
|
151
|
+
exports.ecdsa_secp256r1_verify = ecdsa_secp256r1_verify;
|
|
204
152
|
|
|
205
|
-
function passArray8ToWasm0(arg, malloc) {
|
|
206
|
-
const ptr = malloc(arg.length * 1, 1) >>> 0;
|
|
207
|
-
getUint8ArrayMemory0().set(arg, ptr / 1);
|
|
208
|
-
WASM_VECTOR_LEN = arg.length;
|
|
209
|
-
return ptr;
|
|
210
|
-
}
|
|
211
153
|
/**
|
|
212
154
|
* Executes an ACIR circuit to generate the solved witness from the initial witness.
|
|
213
155
|
*
|
|
@@ -216,12 +158,13 @@ function passArray8ToWasm0(arg, malloc) {
|
|
|
216
158
|
* @param {ForeignCallHandler} foreign_call_handler - A callback to process any foreign calls from the circuit.
|
|
217
159
|
* @returns {WitnessMap} The solved witness calculated by executing the circuit on the provided inputs.
|
|
218
160
|
*/
|
|
219
|
-
|
|
161
|
+
function executeCircuit(program, initial_witness, foreign_call_handler) {
|
|
220
162
|
const ptr0 = passArray8ToWasm0(program, wasm.__wbindgen_malloc);
|
|
221
163
|
const len0 = WASM_VECTOR_LEN;
|
|
222
164
|
const ret = wasm.executeCircuit(ptr0, len0, initial_witness, foreign_call_handler);
|
|
223
165
|
return ret;
|
|
224
|
-
}
|
|
166
|
+
}
|
|
167
|
+
exports.executeCircuit = executeCircuit;
|
|
225
168
|
|
|
226
169
|
/**
|
|
227
170
|
* Executes an ACIR circuit to generate the solved witness from the initial witness.
|
|
@@ -232,12 +175,13 @@ module.exports.executeCircuit = function(program, initial_witness, foreign_call_
|
|
|
232
175
|
* @param {ForeignCallHandler} foreign_call_handler - A callback to process any foreign calls from the circuit.
|
|
233
176
|
* @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.
|
|
234
177
|
*/
|
|
235
|
-
|
|
178
|
+
function executeCircuitWithReturnWitness(program, initial_witness, foreign_call_handler) {
|
|
236
179
|
const ptr0 = passArray8ToWasm0(program, wasm.__wbindgen_malloc);
|
|
237
180
|
const len0 = WASM_VECTOR_LEN;
|
|
238
181
|
const ret = wasm.executeCircuitWithReturnWitness(ptr0, len0, initial_witness, foreign_call_handler);
|
|
239
182
|
return ret;
|
|
240
|
-
}
|
|
183
|
+
}
|
|
184
|
+
exports.executeCircuitWithReturnWitness = executeCircuitWithReturnWitness;
|
|
241
185
|
|
|
242
186
|
/**
|
|
243
187
|
* Executes an ACIR circuit to generate the solved witness from the initial witness.
|
|
@@ -247,51 +191,13 @@ module.exports.executeCircuitWithReturnWitness = function(program, initial_witne
|
|
|
247
191
|
* @param {ForeignCallHandler} foreign_call_handler - A callback to process any foreign calls from the program.
|
|
248
192
|
* @returns {WitnessStack} The solved witness calculated by executing the program on the provided inputs.
|
|
249
193
|
*/
|
|
250
|
-
|
|
194
|
+
function executeProgram(program, initial_witness, foreign_call_handler) {
|
|
251
195
|
const ptr0 = passArray8ToWasm0(program, wasm.__wbindgen_malloc);
|
|
252
196
|
const len0 = WASM_VECTOR_LEN;
|
|
253
197
|
const ret = wasm.executeProgram(ptr0, len0, initial_witness, foreign_call_handler);
|
|
254
198
|
return ret;
|
|
255
|
-
};
|
|
256
|
-
|
|
257
|
-
function takeFromExternrefTable0(idx) {
|
|
258
|
-
const value = wasm.__wbindgen_export_2.get(idx);
|
|
259
|
-
wasm.__externref_table_dealloc(idx);
|
|
260
|
-
return value;
|
|
261
199
|
}
|
|
262
|
-
|
|
263
|
-
* Sets the package's logging level.
|
|
264
|
-
*
|
|
265
|
-
* @param {LogLevel} level - The maximum level of logging to be emitted.
|
|
266
|
-
*/
|
|
267
|
-
module.exports.initLogLevel = function(filter) {
|
|
268
|
-
const ptr0 = passStringToWasm0(filter, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
269
|
-
const len0 = WASM_VECTOR_LEN;
|
|
270
|
-
const ret = wasm.initLogLevel(ptr0, len0);
|
|
271
|
-
if (ret[1]) {
|
|
272
|
-
throw takeFromExternrefTable0(ret[0]);
|
|
273
|
-
}
|
|
274
|
-
};
|
|
275
|
-
|
|
276
|
-
/**
|
|
277
|
-
* Extracts a `WitnessMap` containing the witness indices corresponding to the circuit's return values.
|
|
278
|
-
*
|
|
279
|
-
* @param {Uint8Array} circuit - A serialized representation of an ACIR circuit
|
|
280
|
-
* @param {WitnessMap} witness_map - The completed witness map after executing the circuit.
|
|
281
|
-
* @returns {WitnessMap} A witness map containing the circuit's return values.
|
|
282
|
-
* @param {Uint8Array} program
|
|
283
|
-
* @param {WitnessMap} witness_map
|
|
284
|
-
* @returns {WitnessMap}
|
|
285
|
-
*/
|
|
286
|
-
module.exports.getReturnWitness = function(program, witness_map) {
|
|
287
|
-
const ptr0 = passArray8ToWasm0(program, wasm.__wbindgen_malloc);
|
|
288
|
-
const len0 = WASM_VECTOR_LEN;
|
|
289
|
-
const ret = wasm.getReturnWitness(ptr0, len0, witness_map);
|
|
290
|
-
if (ret[2]) {
|
|
291
|
-
throw takeFromExternrefTable0(ret[1]);
|
|
292
|
-
}
|
|
293
|
-
return takeFromExternrefTable0(ret[0]);
|
|
294
|
-
};
|
|
200
|
+
exports.executeProgram = executeProgram;
|
|
295
201
|
|
|
296
202
|
/**
|
|
297
203
|
* Extracts a `WitnessMap` containing the witness indices corresponding to the circuit's public parameters.
|
|
@@ -303,7 +209,7 @@ module.exports.getReturnWitness = function(program, witness_map) {
|
|
|
303
209
|
* @param {WitnessMap} solved_witness
|
|
304
210
|
* @returns {WitnessMap}
|
|
305
211
|
*/
|
|
306
|
-
|
|
212
|
+
function getPublicParametersWitness(program, solved_witness) {
|
|
307
213
|
const ptr0 = passArray8ToWasm0(program, wasm.__wbindgen_malloc);
|
|
308
214
|
const len0 = WASM_VECTOR_LEN;
|
|
309
215
|
const ret = wasm.getPublicParametersWitness(ptr0, len0, solved_witness);
|
|
@@ -311,7 +217,8 @@ module.exports.getPublicParametersWitness = function(program, solved_witness) {
|
|
|
311
217
|
throw takeFromExternrefTable0(ret[1]);
|
|
312
218
|
}
|
|
313
219
|
return takeFromExternrefTable0(ret[0]);
|
|
314
|
-
}
|
|
220
|
+
}
|
|
221
|
+
exports.getPublicParametersWitness = getPublicParametersWitness;
|
|
315
222
|
|
|
316
223
|
/**
|
|
317
224
|
* Extracts a `WitnessMap` containing the witness indices corresponding to the circuit's public inputs.
|
|
@@ -323,7 +230,7 @@ module.exports.getPublicParametersWitness = function(program, solved_witness) {
|
|
|
323
230
|
* @param {WitnessMap} solved_witness
|
|
324
231
|
* @returns {WitnessMap}
|
|
325
232
|
*/
|
|
326
|
-
|
|
233
|
+
function getPublicWitness(program, solved_witness) {
|
|
327
234
|
const ptr0 = passArray8ToWasm0(program, wasm.__wbindgen_malloc);
|
|
328
235
|
const len0 = WASM_VECTOR_LEN;
|
|
329
236
|
const ret = wasm.getPublicWitness(ptr0, len0, solved_witness);
|
|
@@ -331,135 +238,52 @@ module.exports.getPublicWitness = function(program, solved_witness) {
|
|
|
331
238
|
throw takeFromExternrefTable0(ret[1]);
|
|
332
239
|
}
|
|
333
240
|
return takeFromExternrefTable0(ret[0]);
|
|
334
|
-
};
|
|
335
|
-
|
|
336
|
-
/**
|
|
337
|
-
* Returns the `BuildInfo` object containing information about how the installed package was built.
|
|
338
|
-
* @returns {BuildInfo} - Information on how the installed package was built.
|
|
339
|
-
*/
|
|
340
|
-
module.exports.buildInfo = function() {
|
|
341
|
-
const ret = wasm.buildInfo();
|
|
342
|
-
return ret;
|
|
343
|
-
};
|
|
344
|
-
|
|
345
|
-
function getArrayU8FromWasm0(ptr, len) {
|
|
346
|
-
ptr = ptr >>> 0;
|
|
347
|
-
return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
|
|
348
241
|
}
|
|
349
|
-
|
|
350
|
-
* Compresses a `WitnessMap` into the binary format outputted by Nargo.
|
|
351
|
-
*
|
|
352
|
-
* @param {WitnessMap} witness_map - A witness map.
|
|
353
|
-
* @returns {Uint8Array} A compressed witness map
|
|
354
|
-
*/
|
|
355
|
-
module.exports.compressWitness = function(witness_map) {
|
|
356
|
-
const ret = wasm.compressWitness(witness_map);
|
|
357
|
-
if (ret[3]) {
|
|
358
|
-
throw takeFromExternrefTable0(ret[2]);
|
|
359
|
-
}
|
|
360
|
-
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
361
|
-
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
362
|
-
return v1;
|
|
363
|
-
};
|
|
242
|
+
exports.getPublicWitness = getPublicWitness;
|
|
364
243
|
|
|
365
244
|
/**
|
|
366
|
-
*
|
|
367
|
-
* This should be used to only fetch the witness map for the main function.
|
|
245
|
+
* Extracts a `WitnessMap` containing the witness indices corresponding to the circuit's return values.
|
|
368
246
|
*
|
|
369
|
-
* @param {Uint8Array}
|
|
370
|
-
* @
|
|
247
|
+
* @param {Uint8Array} circuit - A serialized representation of an ACIR circuit
|
|
248
|
+
* @param {WitnessMap} witness_map - The completed witness map after executing the circuit.
|
|
249
|
+
* @returns {WitnessMap} A witness map containing the circuit's return values.
|
|
250
|
+
* @param {Uint8Array} program
|
|
251
|
+
* @param {WitnessMap} witness_map
|
|
252
|
+
* @returns {WitnessMap}
|
|
371
253
|
*/
|
|
372
|
-
|
|
373
|
-
const ptr0 = passArray8ToWasm0(
|
|
254
|
+
function getReturnWitness(program, witness_map) {
|
|
255
|
+
const ptr0 = passArray8ToWasm0(program, wasm.__wbindgen_malloc);
|
|
374
256
|
const len0 = WASM_VECTOR_LEN;
|
|
375
|
-
const ret = wasm.
|
|
257
|
+
const ret = wasm.getReturnWitness(ptr0, len0, witness_map);
|
|
376
258
|
if (ret[2]) {
|
|
377
259
|
throw takeFromExternrefTable0(ret[1]);
|
|
378
260
|
}
|
|
379
261
|
return takeFromExternrefTable0(ret[0]);
|
|
380
|
-
}
|
|
381
|
-
|
|
382
|
-
/**
|
|
383
|
-
* Compresses a `WitnessStack` into the binary format outputted by Nargo.
|
|
384
|
-
*
|
|
385
|
-
* @param {WitnessStack} witness_stack - A witness stack.
|
|
386
|
-
* @returns {Uint8Array} A compressed witness stack
|
|
387
|
-
*/
|
|
388
|
-
module.exports.compressWitnessStack = function(witness_stack) {
|
|
389
|
-
const ret = wasm.compressWitnessStack(witness_stack);
|
|
390
|
-
if (ret[3]) {
|
|
391
|
-
throw takeFromExternrefTable0(ret[2]);
|
|
392
|
-
}
|
|
393
|
-
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
394
|
-
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
395
|
-
return v1;
|
|
396
|
-
};
|
|
262
|
+
}
|
|
263
|
+
exports.getReturnWitness = getReturnWitness;
|
|
397
264
|
|
|
398
265
|
/**
|
|
399
|
-
*
|
|
266
|
+
* Sets the package's logging level.
|
|
400
267
|
*
|
|
401
|
-
* @param {
|
|
402
|
-
* @returns {WitnessStack} The decompressed witness stack.
|
|
268
|
+
* @param {LogLevel} level - The maximum level of logging to be emitted.
|
|
403
269
|
*/
|
|
404
|
-
|
|
405
|
-
const ptr0 =
|
|
270
|
+
function initLogLevel(filter) {
|
|
271
|
+
const ptr0 = passStringToWasm0(filter, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
406
272
|
const len0 = WASM_VECTOR_LEN;
|
|
407
|
-
const ret = wasm.
|
|
408
|
-
if (ret[
|
|
409
|
-
throw takeFromExternrefTable0(ret[
|
|
410
|
-
}
|
|
411
|
-
return takeFromExternrefTable0(ret[0]);
|
|
412
|
-
};
|
|
413
|
-
|
|
414
|
-
/**
|
|
415
|
-
* Performs a bitwise AND operation between `lhs` and `rhs`
|
|
416
|
-
* @param {string} lhs
|
|
417
|
-
* @param {string} rhs
|
|
418
|
-
* @returns {string}
|
|
419
|
-
*/
|
|
420
|
-
module.exports.and = function(lhs, rhs) {
|
|
421
|
-
const ret = wasm.and(lhs, rhs);
|
|
422
|
-
return ret;
|
|
423
|
-
};
|
|
424
|
-
|
|
425
|
-
/**
|
|
426
|
-
* Performs a bitwise XOR operation between `lhs` and `rhs`
|
|
427
|
-
* @param {string} lhs
|
|
428
|
-
* @param {string} rhs
|
|
429
|
-
* @returns {string}
|
|
430
|
-
*/
|
|
431
|
-
module.exports.xor = function(lhs, rhs) {
|
|
432
|
-
const ret = wasm.xor(lhs, rhs);
|
|
433
|
-
return ret;
|
|
434
|
-
};
|
|
435
|
-
|
|
436
|
-
let cachedUint32ArrayMemory0 = null;
|
|
437
|
-
|
|
438
|
-
function getUint32ArrayMemory0() {
|
|
439
|
-
if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
|
|
440
|
-
cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
|
|
273
|
+
const ret = wasm.initLogLevel(ptr0, len0);
|
|
274
|
+
if (ret[1]) {
|
|
275
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
441
276
|
}
|
|
442
|
-
return cachedUint32ArrayMemory0;
|
|
443
|
-
}
|
|
444
|
-
|
|
445
|
-
function passArray32ToWasm0(arg, malloc) {
|
|
446
|
-
const ptr = malloc(arg.length * 4, 4) >>> 0;
|
|
447
|
-
getUint32ArrayMemory0().set(arg, ptr / 4);
|
|
448
|
-
WASM_VECTOR_LEN = arg.length;
|
|
449
|
-
return ptr;
|
|
450
277
|
}
|
|
278
|
+
exports.initLogLevel = initLogLevel;
|
|
451
279
|
|
|
452
|
-
function getArrayU32FromWasm0(ptr, len) {
|
|
453
|
-
ptr = ptr >>> 0;
|
|
454
|
-
return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
|
|
455
|
-
}
|
|
456
280
|
/**
|
|
457
281
|
* Sha256 compression function
|
|
458
282
|
* @param {Uint32Array} inputs
|
|
459
283
|
* @param {Uint32Array} state
|
|
460
284
|
* @returns {Uint32Array}
|
|
461
285
|
*/
|
|
462
|
-
|
|
286
|
+
function sha256_compression(inputs, state) {
|
|
463
287
|
const ptr0 = passArray32ToWasm0(inputs, wasm.__wbindgen_malloc);
|
|
464
288
|
const len0 = WASM_VECTOR_LEN;
|
|
465
289
|
const ptr1 = passArray32ToWasm0(state, wasm.__wbindgen_malloc);
|
|
@@ -468,432 +292,568 @@ module.exports.sha256_compression = function(inputs, state) {
|
|
|
468
292
|
var v3 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
|
|
469
293
|
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
470
294
|
return v3;
|
|
471
|
-
};
|
|
472
|
-
|
|
473
|
-
/**
|
|
474
|
-
* Calculates the Blake2s256 hash of the input bytes
|
|
475
|
-
* @param {Uint8Array} inputs
|
|
476
|
-
* @returns {Uint8Array}
|
|
477
|
-
*/
|
|
478
|
-
module.exports.blake2s256 = function(inputs) {
|
|
479
|
-
const ptr0 = passArray8ToWasm0(inputs, wasm.__wbindgen_malloc);
|
|
480
|
-
const len0 = WASM_VECTOR_LEN;
|
|
481
|
-
const ret = wasm.blake2s256(ptr0, len0);
|
|
482
|
-
var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
483
|
-
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
484
|
-
return v2;
|
|
485
|
-
};
|
|
486
|
-
|
|
487
|
-
/**
|
|
488
|
-
* Verifies a ECDSA signature over the secp256k1 curve.
|
|
489
|
-
* @param {Uint8Array} hashed_msg
|
|
490
|
-
* @param {Uint8Array} public_key_x_bytes
|
|
491
|
-
* @param {Uint8Array} public_key_y_bytes
|
|
492
|
-
* @param {Uint8Array} signature
|
|
493
|
-
* @returns {boolean}
|
|
494
|
-
*/
|
|
495
|
-
module.exports.ecdsa_secp256k1_verify = function(hashed_msg, public_key_x_bytes, public_key_y_bytes, signature) {
|
|
496
|
-
const ptr0 = passArray8ToWasm0(hashed_msg, wasm.__wbindgen_malloc);
|
|
497
|
-
const len0 = WASM_VECTOR_LEN;
|
|
498
|
-
const ptr1 = passArray8ToWasm0(public_key_x_bytes, wasm.__wbindgen_malloc);
|
|
499
|
-
const len1 = WASM_VECTOR_LEN;
|
|
500
|
-
const ptr2 = passArray8ToWasm0(public_key_y_bytes, wasm.__wbindgen_malloc);
|
|
501
|
-
const len2 = WASM_VECTOR_LEN;
|
|
502
|
-
const ptr3 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
|
|
503
|
-
const len3 = WASM_VECTOR_LEN;
|
|
504
|
-
const ret = wasm.ecdsa_secp256k1_verify(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
|
|
505
|
-
return ret !== 0;
|
|
506
|
-
};
|
|
507
|
-
|
|
508
|
-
/**
|
|
509
|
-
* Verifies a ECDSA signature over the secp256r1 curve.
|
|
510
|
-
* @param {Uint8Array} hashed_msg
|
|
511
|
-
* @param {Uint8Array} public_key_x_bytes
|
|
512
|
-
* @param {Uint8Array} public_key_y_bytes
|
|
513
|
-
* @param {Uint8Array} signature
|
|
514
|
-
* @returns {boolean}
|
|
515
|
-
*/
|
|
516
|
-
module.exports.ecdsa_secp256r1_verify = function(hashed_msg, public_key_x_bytes, public_key_y_bytes, signature) {
|
|
517
|
-
const ptr0 = passArray8ToWasm0(hashed_msg, wasm.__wbindgen_malloc);
|
|
518
|
-
const len0 = WASM_VECTOR_LEN;
|
|
519
|
-
const ptr1 = passArray8ToWasm0(public_key_x_bytes, wasm.__wbindgen_malloc);
|
|
520
|
-
const len1 = WASM_VECTOR_LEN;
|
|
521
|
-
const ptr2 = passArray8ToWasm0(public_key_y_bytes, wasm.__wbindgen_malloc);
|
|
522
|
-
const len2 = WASM_VECTOR_LEN;
|
|
523
|
-
const ptr3 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
|
|
524
|
-
const len3 = WASM_VECTOR_LEN;
|
|
525
|
-
const ret = wasm.ecdsa_secp256r1_verify(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
|
|
526
|
-
return ret !== 0;
|
|
527
|
-
};
|
|
528
|
-
|
|
529
|
-
function __wbg_adapter_30(arg0, arg1, arg2) {
|
|
530
|
-
wasm.closure576_externref_shim(arg0, arg1, arg2);
|
|
531
|
-
}
|
|
532
|
-
|
|
533
|
-
function __wbg_adapter_89(arg0, arg1, arg2, arg3, arg4) {
|
|
534
|
-
wasm.closure1171_externref_shim(arg0, arg1, arg2, arg3, arg4);
|
|
535
295
|
}
|
|
296
|
+
exports.sha256_compression = sha256_compression;
|
|
536
297
|
|
|
537
|
-
|
|
538
|
-
|
|
539
|
-
}
|
|
540
|
-
|
|
541
|
-
|
|
542
|
-
|
|
543
|
-
|
|
544
|
-
|
|
545
|
-
|
|
546
|
-
|
|
547
|
-
|
|
548
|
-
|
|
549
|
-
|
|
550
|
-
|
|
551
|
-
|
|
552
|
-
|
|
553
|
-
|
|
554
|
-
|
|
555
|
-
|
|
556
|
-
|
|
557
|
-
|
|
558
|
-
|
|
559
|
-
|
|
560
|
-
|
|
561
|
-
|
|
562
|
-
|
|
563
|
-
|
|
564
|
-
|
|
565
|
-
|
|
566
|
-
|
|
567
|
-
|
|
568
|
-
|
|
569
|
-
|
|
570
|
-
|
|
571
|
-
|
|
572
|
-
|
|
573
|
-
|
|
574
|
-
|
|
575
|
-
|
|
576
|
-
}
|
|
577
|
-
|
|
578
|
-
|
|
579
|
-
|
|
580
|
-
|
|
581
|
-
|
|
582
|
-
|
|
583
|
-
|
|
584
|
-
|
|
585
|
-
|
|
586
|
-
|
|
587
|
-
|
|
588
|
-
|
|
589
|
-
|
|
590
|
-
|
|
591
|
-
|
|
592
|
-
|
|
593
|
-
|
|
594
|
-
|
|
595
|
-
|
|
596
|
-
|
|
597
|
-
|
|
598
|
-
|
|
599
|
-
|
|
298
|
+
/**
|
|
299
|
+
* Performs a bitwise XOR operation between `lhs` and `rhs`
|
|
300
|
+
* @param {string} lhs
|
|
301
|
+
* @param {string} rhs
|
|
302
|
+
* @returns {string}
|
|
303
|
+
*/
|
|
304
|
+
function xor(lhs, rhs) {
|
|
305
|
+
const ret = wasm.xor(lhs, rhs);
|
|
306
|
+
return ret;
|
|
307
|
+
}
|
|
308
|
+
exports.xor = xor;
|
|
309
|
+
|
|
310
|
+
function __wbg_get_imports() {
|
|
311
|
+
const import0 = {
|
|
312
|
+
__proto__: null,
|
|
313
|
+
__wbg___wbindgen_debug_string_ddde1867f49c2442: function(arg0, arg1) {
|
|
314
|
+
const ret = debugString(arg1);
|
|
315
|
+
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
316
|
+
const len1 = WASM_VECTOR_LEN;
|
|
317
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
318
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
319
|
+
},
|
|
320
|
+
__wbg___wbindgen_is_function_d633e708baf0d146: function(arg0) {
|
|
321
|
+
const ret = typeof(arg0) === 'function';
|
|
322
|
+
return ret;
|
|
323
|
+
},
|
|
324
|
+
__wbg___wbindgen_is_string_7debe47dc1e045c2: function(arg0) {
|
|
325
|
+
const ret = typeof(arg0) === 'string';
|
|
326
|
+
return ret;
|
|
327
|
+
},
|
|
328
|
+
__wbg___wbindgen_is_undefined_c18285b9fc34cb7d: function(arg0) {
|
|
329
|
+
const ret = arg0 === undefined;
|
|
330
|
+
return ret;
|
|
331
|
+
},
|
|
332
|
+
__wbg___wbindgen_number_get_5854912275df1894: function(arg0, arg1) {
|
|
333
|
+
const obj = arg1;
|
|
334
|
+
const ret = typeof(obj) === 'number' ? obj : undefined;
|
|
335
|
+
getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
|
|
336
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
|
|
337
|
+
},
|
|
338
|
+
__wbg___wbindgen_string_get_3e5751597f39a112: function(arg0, arg1) {
|
|
339
|
+
const obj = arg1;
|
|
340
|
+
const ret = typeof(obj) === 'string' ? obj : undefined;
|
|
341
|
+
var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
342
|
+
var len1 = WASM_VECTOR_LEN;
|
|
343
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
344
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
345
|
+
},
|
|
346
|
+
__wbg___wbindgen_throw_39bc967c0e5a9b58: function(arg0, arg1) {
|
|
347
|
+
throw new Error(getStringFromWasm0(arg0, arg1));
|
|
348
|
+
},
|
|
349
|
+
__wbg__wbg_cb_unref_b6d832240a919168: function(arg0) {
|
|
350
|
+
arg0._wbg_cb_unref();
|
|
351
|
+
},
|
|
352
|
+
__wbg_call_08ad0d89caa7cb79: function() { return handleError(function (arg0, arg1, arg2) {
|
|
353
|
+
const ret = arg0.call(arg1, arg2);
|
|
354
|
+
return ret;
|
|
355
|
+
}, arguments); },
|
|
356
|
+
__wbg_call_c974f0bf2231552e: function() { return handleError(function (arg0, arg1, arg2, arg3) {
|
|
357
|
+
const ret = arg0.call(arg1, arg2, arg3);
|
|
358
|
+
return ret;
|
|
359
|
+
}, arguments); },
|
|
360
|
+
__wbg_constructor_78e91522c0c3d715: function(arg0) {
|
|
361
|
+
const ret = new Error(arg0);
|
|
362
|
+
return ret;
|
|
363
|
+
},
|
|
364
|
+
__wbg_constructor_d2b676f9277a8e3c: function(arg0) {
|
|
365
|
+
const ret = new Error(arg0);
|
|
366
|
+
return ret;
|
|
367
|
+
},
|
|
368
|
+
__wbg_debug_8804c16f548276da: function(arg0, arg1, arg2, arg3) {
|
|
369
|
+
console.debug(arg0, arg1, arg2, arg3);
|
|
370
|
+
},
|
|
371
|
+
__wbg_debug_e69ad32e6af73f94: function(arg0) {
|
|
372
|
+
console.debug(arg0);
|
|
373
|
+
},
|
|
374
|
+
__wbg_error_91d10625a3b36a08: function(arg0, arg1, arg2, arg3) {
|
|
375
|
+
console.error(arg0, arg1, arg2, arg3);
|
|
376
|
+
},
|
|
377
|
+
__wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
|
|
378
|
+
let deferred0_0;
|
|
379
|
+
let deferred0_1;
|
|
600
380
|
try {
|
|
601
|
-
|
|
381
|
+
deferred0_0 = arg0;
|
|
382
|
+
deferred0_1 = arg1;
|
|
383
|
+
console.error(getStringFromWasm0(arg0, arg1));
|
|
602
384
|
} finally {
|
|
603
|
-
|
|
385
|
+
wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
|
|
604
386
|
}
|
|
605
|
-
}
|
|
606
|
-
arg0
|
|
607
|
-
|
|
608
|
-
|
|
609
|
-
|
|
610
|
-
};
|
|
611
|
-
|
|
612
|
-
module.exports.__wbg_forEach_e1cf6f7c8ecb7dae = function(arg0, arg1, arg2) {
|
|
613
|
-
try {
|
|
614
|
-
var state0 = {a: arg1, b: arg2};
|
|
615
|
-
var cb0 = (arg0, arg1) => {
|
|
616
|
-
const a = state0.a;
|
|
617
|
-
state0.a = 0;
|
|
387
|
+
},
|
|
388
|
+
__wbg_error_ad28debb48b5c6bb: function(arg0) {
|
|
389
|
+
console.error(arg0);
|
|
390
|
+
},
|
|
391
|
+
__wbg_forEach_9694464cb60ea370: function(arg0, arg1, arg2) {
|
|
618
392
|
try {
|
|
619
|
-
|
|
393
|
+
var state0 = {a: arg1, b: arg2};
|
|
394
|
+
var cb0 = (arg0, arg1) => {
|
|
395
|
+
const a = state0.a;
|
|
396
|
+
state0.a = 0;
|
|
397
|
+
try {
|
|
398
|
+
return wasm_bindgen__convert__closures_____invoke__h5a259cce50f322a2(a, state0.b, arg0, arg1);
|
|
399
|
+
} finally {
|
|
400
|
+
state0.a = a;
|
|
401
|
+
}
|
|
402
|
+
};
|
|
403
|
+
arg0.forEach(cb0);
|
|
620
404
|
} finally {
|
|
621
|
-
state0.a =
|
|
405
|
+
state0.a = state0.b = 0;
|
|
622
406
|
}
|
|
623
|
-
}
|
|
624
|
-
arg0
|
|
625
|
-
} finally {
|
|
626
|
-
state0.a = state0.b = 0;
|
|
627
|
-
}
|
|
628
|
-
};
|
|
629
|
-
|
|
630
|
-
module.exports.__wbg_fromEntries_524679eecb0bdc2e = function() { return handleError(function (arg0) {
|
|
631
|
-
const ret = Object.fromEntries(arg0);
|
|
632
|
-
return ret;
|
|
633
|
-
}, arguments) };
|
|
634
|
-
|
|
635
|
-
module.exports.__wbg_from_2a5d3e218e67aa85 = function(arg0) {
|
|
636
|
-
const ret = Array.from(arg0);
|
|
637
|
-
return ret;
|
|
638
|
-
};
|
|
639
|
-
|
|
640
|
-
module.exports.__wbg_get_b9b93047fe3cf45b = function(arg0, arg1) {
|
|
641
|
-
const ret = arg0[arg1 >>> 0];
|
|
642
|
-
return ret;
|
|
643
|
-
};
|
|
644
|
-
|
|
645
|
-
module.exports.__wbg_info_033d8b8a0838f1d3 = function(arg0, arg1, arg2, arg3) {
|
|
646
|
-
console.info(arg0, arg1, arg2, arg3);
|
|
647
|
-
};
|
|
648
|
-
|
|
649
|
-
module.exports.__wbg_info_3daf2e093e091b66 = function(arg0) {
|
|
650
|
-
console.info(arg0);
|
|
651
|
-
};
|
|
652
|
-
|
|
653
|
-
module.exports.__wbg_length_e2d2a49132c1b256 = function(arg0) {
|
|
654
|
-
const ret = arg0.length;
|
|
655
|
-
return ret;
|
|
656
|
-
};
|
|
657
|
-
|
|
658
|
-
module.exports.__wbg_new_23a2665fac83c611 = function(arg0, arg1) {
|
|
659
|
-
try {
|
|
660
|
-
var state0 = {a: arg0, b: arg1};
|
|
661
|
-
var cb0 = (arg0, arg1) => {
|
|
662
|
-
const a = state0.a;
|
|
663
|
-
state0.a = 0;
|
|
407
|
+
},
|
|
408
|
+
__wbg_forEach_f33e388a24ae7d4f: function(arg0, arg1, arg2) {
|
|
664
409
|
try {
|
|
665
|
-
|
|
410
|
+
var state0 = {a: arg1, b: arg2};
|
|
411
|
+
var cb0 = (arg0, arg1, arg2) => {
|
|
412
|
+
const a = state0.a;
|
|
413
|
+
state0.a = 0;
|
|
414
|
+
try {
|
|
415
|
+
return wasm_bindgen__convert__closures_____invoke__h149dcfc5e545a40e(a, state0.b, arg0, arg1, arg2);
|
|
416
|
+
} finally {
|
|
417
|
+
state0.a = a;
|
|
418
|
+
}
|
|
419
|
+
};
|
|
420
|
+
arg0.forEach(cb0);
|
|
666
421
|
} finally {
|
|
667
|
-
state0.a =
|
|
422
|
+
state0.a = state0.b = 0;
|
|
668
423
|
}
|
|
669
|
-
}
|
|
670
|
-
|
|
671
|
-
|
|
672
|
-
|
|
673
|
-
|
|
674
|
-
|
|
675
|
-
|
|
676
|
-
|
|
677
|
-
|
|
678
|
-
|
|
679
|
-
|
|
680
|
-
|
|
681
|
-
|
|
682
|
-
|
|
683
|
-
|
|
684
|
-
|
|
685
|
-
}
|
|
424
|
+
},
|
|
425
|
+
__wbg_fromEntries_2f51c4024e2a7aa3: function() { return handleError(function (arg0) {
|
|
426
|
+
const ret = Object.fromEntries(arg0);
|
|
427
|
+
return ret;
|
|
428
|
+
}, arguments); },
|
|
429
|
+
__wbg_from_d7e888a2e9063b32: function(arg0) {
|
|
430
|
+
const ret = Array.from(arg0);
|
|
431
|
+
return ret;
|
|
432
|
+
},
|
|
433
|
+
__wbg_get_f09c3a16f8848381: function(arg0, arg1) {
|
|
434
|
+
const ret = arg0[arg1 >>> 0];
|
|
435
|
+
return ret;
|
|
436
|
+
},
|
|
437
|
+
__wbg_get_unchecked_3d0f4b91c8eca4f0: function(arg0, arg1) {
|
|
438
|
+
const ret = arg0[arg1 >>> 0];
|
|
439
|
+
return ret;
|
|
440
|
+
},
|
|
441
|
+
__wbg_info_28d530adaabdab8c: function(arg0, arg1, arg2, arg3) {
|
|
442
|
+
console.info(arg0, arg1, arg2, arg3);
|
|
443
|
+
},
|
|
444
|
+
__wbg_info_72e7e65fa3fc8b25: function(arg0) {
|
|
445
|
+
console.info(arg0);
|
|
446
|
+
},
|
|
447
|
+
__wbg_isArray_581b02d0060c9728: function(arg0) {
|
|
448
|
+
const ret = Array.isArray(arg0);
|
|
449
|
+
return ret;
|
|
450
|
+
},
|
|
451
|
+
__wbg_length_a31e05262e09b7f8: function(arg0) {
|
|
452
|
+
const ret = arg0.length;
|
|
453
|
+
return ret;
|
|
454
|
+
},
|
|
455
|
+
__wbg_new_1213b57bccbdbb66: function(arg0, arg1) {
|
|
456
|
+
const ret = new Error(getStringFromWasm0(arg0, arg1));
|
|
457
|
+
return ret;
|
|
458
|
+
},
|
|
459
|
+
__wbg_new_1faa82fcea3a8b7d: function() {
|
|
460
|
+
const ret = new Map();
|
|
461
|
+
return ret;
|
|
462
|
+
},
|
|
463
|
+
__wbg_new_227d7c05414eb861: function() {
|
|
464
|
+
const ret = new Error();
|
|
465
|
+
return ret;
|
|
466
|
+
},
|
|
467
|
+
__wbg_new_92df58a8ec3bfb6b: function() {
|
|
468
|
+
const ret = new Map();
|
|
469
|
+
return ret;
|
|
470
|
+
},
|
|
471
|
+
__wbg_new_cb7a57a3ce49e647: function() {
|
|
472
|
+
const ret = new Array();
|
|
473
|
+
return ret;
|
|
474
|
+
},
|
|
475
|
+
__wbg_new_cbee8c0d5c479eac: function() {
|
|
476
|
+
const ret = new Array();
|
|
477
|
+
return ret;
|
|
478
|
+
},
|
|
479
|
+
__wbg_new_typed_8258a0d8488ef2a2: function(arg0, arg1) {
|
|
480
|
+
try {
|
|
481
|
+
var state0 = {a: arg0, b: arg1};
|
|
482
|
+
var cb0 = (arg0, arg1) => {
|
|
483
|
+
const a = state0.a;
|
|
484
|
+
state0.a = 0;
|
|
485
|
+
try {
|
|
486
|
+
return wasm_bindgen__convert__closures_____invoke__h5a259cce50f322a2_21(a, state0.b, arg0, arg1);
|
|
487
|
+
} finally {
|
|
488
|
+
state0.a = a;
|
|
489
|
+
}
|
|
490
|
+
};
|
|
491
|
+
const ret = new Promise(cb0);
|
|
492
|
+
return ret;
|
|
493
|
+
} finally {
|
|
494
|
+
state0.a = state0.b = 0;
|
|
495
|
+
}
|
|
496
|
+
},
|
|
497
|
+
__wbg_parse_6dfe891b5bafb5cd: function() { return handleError(function (arg0, arg1) {
|
|
498
|
+
const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
|
|
499
|
+
return ret;
|
|
500
|
+
}, arguments); },
|
|
501
|
+
__wbg_push_a6f9488ffd3fae3b: function(arg0, arg1) {
|
|
502
|
+
const ret = arg0.push(arg1);
|
|
503
|
+
return ret;
|
|
504
|
+
},
|
|
505
|
+
__wbg_queueMicrotask_2c8dfd1056f24fdc: function(arg0) {
|
|
506
|
+
const ret = arg0.queueMicrotask;
|
|
507
|
+
return ret;
|
|
508
|
+
},
|
|
509
|
+
__wbg_queueMicrotask_8985ad63815852e7: function(arg0) {
|
|
510
|
+
queueMicrotask(arg0);
|
|
511
|
+
},
|
|
512
|
+
__wbg_resolve_5d61e0d10c14730a: function(arg0) {
|
|
513
|
+
const ret = Promise.resolve(arg0);
|
|
514
|
+
return ret;
|
|
515
|
+
},
|
|
516
|
+
__wbg_reverse_fcf59127ee940f96: function(arg0) {
|
|
517
|
+
const ret = arg0.reverse();
|
|
518
|
+
return ret;
|
|
519
|
+
},
|
|
520
|
+
__wbg_set_bad5c505cc70b5f8: function() { return handleError(function (arg0, arg1, arg2) {
|
|
521
|
+
const ret = Reflect.set(arg0, arg1, arg2);
|
|
522
|
+
return ret;
|
|
523
|
+
}, arguments); },
|
|
524
|
+
__wbg_set_cause_7f44b7881bde2bb6: function(arg0, arg1) {
|
|
525
|
+
arg0.cause = arg1;
|
|
526
|
+
},
|
|
527
|
+
__wbg_set_cfc6de03f990decf: function(arg0, arg1, arg2) {
|
|
528
|
+
const ret = arg0.set(arg1, arg2);
|
|
529
|
+
return ret;
|
|
530
|
+
},
|
|
531
|
+
__wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
|
|
532
|
+
const ret = arg1.stack;
|
|
533
|
+
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
534
|
+
const len1 = WASM_VECTOR_LEN;
|
|
535
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
536
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
537
|
+
},
|
|
538
|
+
__wbg_static_accessor_GLOBAL_THIS_14325d8cca34bb77: function() {
|
|
539
|
+
const ret = typeof globalThis === 'undefined' ? null : globalThis;
|
|
540
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
541
|
+
},
|
|
542
|
+
__wbg_static_accessor_GLOBAL_f3a1e69f9c5a7e8e: function() {
|
|
543
|
+
const ret = typeof global === 'undefined' ? null : global;
|
|
544
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
545
|
+
},
|
|
546
|
+
__wbg_static_accessor_SELF_50cdb5b517789aca: function() {
|
|
547
|
+
const ret = typeof self === 'undefined' ? null : self;
|
|
548
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
549
|
+
},
|
|
550
|
+
__wbg_static_accessor_WINDOW_d6c4126e4c244380: function() {
|
|
551
|
+
const ret = typeof window === 'undefined' ? null : window;
|
|
552
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
553
|
+
},
|
|
554
|
+
__wbg_then_d4163530723f56f4: function(arg0, arg1, arg2) {
|
|
555
|
+
const ret = arg0.then(arg1, arg2);
|
|
556
|
+
return ret;
|
|
557
|
+
},
|
|
558
|
+
__wbg_then_f1c954fe00733701: function(arg0, arg1) {
|
|
559
|
+
const ret = arg0.then(arg1);
|
|
560
|
+
return ret;
|
|
561
|
+
},
|
|
562
|
+
__wbg_values_623449cff68c6e40: function(arg0) {
|
|
563
|
+
const ret = Object.values(arg0);
|
|
564
|
+
return ret;
|
|
565
|
+
},
|
|
566
|
+
__wbg_warn_2540fe736f19ad5c: function(arg0, arg1, arg2, arg3) {
|
|
567
|
+
console.warn(arg0, arg1, arg2, arg3);
|
|
568
|
+
},
|
|
569
|
+
__wbg_warn_3310c7343993c074: function(arg0) {
|
|
570
|
+
console.warn(arg0);
|
|
571
|
+
},
|
|
572
|
+
__wbindgen_cast_0000000000000001: function(arg0, arg1) {
|
|
573
|
+
// Cast intrinsic for `Closure(Closure { dtor_idx: 464, function: Function { arguments: [Externref], shim_idx: 465, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
|
|
574
|
+
const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h589cd82bcdcce84d, wasm_bindgen__convert__closures_____invoke__hd0bc2cf4f980f051);
|
|
575
|
+
return ret;
|
|
576
|
+
},
|
|
577
|
+
__wbindgen_cast_0000000000000002: function(arg0) {
|
|
578
|
+
// Cast intrinsic for `F64 -> Externref`.
|
|
579
|
+
const ret = arg0;
|
|
580
|
+
return ret;
|
|
581
|
+
},
|
|
582
|
+
__wbindgen_cast_0000000000000003: function(arg0, arg1) {
|
|
583
|
+
// Cast intrinsic for `Ref(String) -> Externref`.
|
|
584
|
+
const ret = getStringFromWasm0(arg0, arg1);
|
|
585
|
+
return ret;
|
|
586
|
+
},
|
|
587
|
+
__wbindgen_init_externref_table: function() {
|
|
588
|
+
const table = wasm.__wbindgen_externrefs;
|
|
589
|
+
const offset = table.grow(4);
|
|
590
|
+
table.set(0, undefined);
|
|
591
|
+
table.set(offset + 0, undefined);
|
|
592
|
+
table.set(offset + 1, null);
|
|
593
|
+
table.set(offset + 2, true);
|
|
594
|
+
table.set(offset + 3, false);
|
|
595
|
+
},
|
|
596
|
+
};
|
|
597
|
+
return {
|
|
598
|
+
__proto__: null,
|
|
599
|
+
"./acvm_js_bg.js": import0,
|
|
600
|
+
};
|
|
601
|
+
}
|
|
686
602
|
|
|
687
|
-
|
|
688
|
-
const ret =
|
|
689
|
-
|
|
690
|
-
|
|
603
|
+
function wasm_bindgen__convert__closures_____invoke__hd0bc2cf4f980f051(arg0, arg1, arg2) {
|
|
604
|
+
const ret = wasm.wasm_bindgen__convert__closures_____invoke__hd0bc2cf4f980f051(arg0, arg1, arg2);
|
|
605
|
+
if (ret[1]) {
|
|
606
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
607
|
+
}
|
|
608
|
+
}
|
|
691
609
|
|
|
692
|
-
|
|
693
|
-
|
|
694
|
-
|
|
695
|
-
};
|
|
610
|
+
function wasm_bindgen__convert__closures_____invoke__h5a259cce50f322a2(arg0, arg1, arg2, arg3) {
|
|
611
|
+
wasm.wasm_bindgen__convert__closures_____invoke__h5a259cce50f322a2(arg0, arg1, arg2, arg3);
|
|
612
|
+
}
|
|
696
613
|
|
|
697
|
-
|
|
698
|
-
|
|
699
|
-
|
|
700
|
-
};
|
|
614
|
+
function wasm_bindgen__convert__closures_____invoke__h5a259cce50f322a2_21(arg0, arg1, arg2, arg3) {
|
|
615
|
+
wasm.wasm_bindgen__convert__closures_____invoke__h5a259cce50f322a2_21(arg0, arg1, arg2, arg3);
|
|
616
|
+
}
|
|
701
617
|
|
|
702
|
-
|
|
703
|
-
|
|
704
|
-
|
|
705
|
-
};
|
|
618
|
+
function wasm_bindgen__convert__closures_____invoke__h149dcfc5e545a40e(arg0, arg1, arg2, arg3, arg4) {
|
|
619
|
+
wasm.wasm_bindgen__convert__closures_____invoke__h149dcfc5e545a40e(arg0, arg1, arg2, arg3, arg4);
|
|
620
|
+
}
|
|
706
621
|
|
|
707
|
-
|
|
708
|
-
const
|
|
709
|
-
|
|
710
|
-
|
|
622
|
+
function addToExternrefTable0(obj) {
|
|
623
|
+
const idx = wasm.__externref_table_alloc();
|
|
624
|
+
wasm.__wbindgen_externrefs.set(idx, obj);
|
|
625
|
+
return idx;
|
|
626
|
+
}
|
|
711
627
|
|
|
712
|
-
|
|
713
|
-
|
|
714
|
-
|
|
715
|
-
}, arguments) };
|
|
628
|
+
const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
|
|
629
|
+
? { register: () => {}, unregister: () => {} }
|
|
630
|
+
: new FinalizationRegistry(state => state.dtor(state.a, state.b));
|
|
716
631
|
|
|
717
|
-
|
|
718
|
-
|
|
719
|
-
|
|
720
|
-
|
|
632
|
+
function debugString(val) {
|
|
633
|
+
// primitive types
|
|
634
|
+
const type = typeof val;
|
|
635
|
+
if (type == 'number' || type == 'boolean' || val == null) {
|
|
636
|
+
return `${val}`;
|
|
637
|
+
}
|
|
638
|
+
if (type == 'string') {
|
|
639
|
+
return `"${val}"`;
|
|
640
|
+
}
|
|
641
|
+
if (type == 'symbol') {
|
|
642
|
+
const description = val.description;
|
|
643
|
+
if (description == null) {
|
|
644
|
+
return 'Symbol';
|
|
645
|
+
} else {
|
|
646
|
+
return `Symbol(${description})`;
|
|
647
|
+
}
|
|
648
|
+
}
|
|
649
|
+
if (type == 'function') {
|
|
650
|
+
const name = val.name;
|
|
651
|
+
if (typeof name == 'string' && name.length > 0) {
|
|
652
|
+
return `Function(${name})`;
|
|
653
|
+
} else {
|
|
654
|
+
return 'Function';
|
|
655
|
+
}
|
|
656
|
+
}
|
|
657
|
+
// objects
|
|
658
|
+
if (Array.isArray(val)) {
|
|
659
|
+
const length = val.length;
|
|
660
|
+
let debug = '[';
|
|
661
|
+
if (length > 0) {
|
|
662
|
+
debug += debugString(val[0]);
|
|
663
|
+
}
|
|
664
|
+
for(let i = 1; i < length; i++) {
|
|
665
|
+
debug += ', ' + debugString(val[i]);
|
|
666
|
+
}
|
|
667
|
+
debug += ']';
|
|
668
|
+
return debug;
|
|
669
|
+
}
|
|
670
|
+
// Test for built-in
|
|
671
|
+
const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
|
|
672
|
+
let className;
|
|
673
|
+
if (builtInMatches && builtInMatches.length > 1) {
|
|
674
|
+
className = builtInMatches[1];
|
|
675
|
+
} else {
|
|
676
|
+
// Failed to match the standard '[object ClassName]'
|
|
677
|
+
return toString.call(val);
|
|
678
|
+
}
|
|
679
|
+
if (className == 'Object') {
|
|
680
|
+
// we're a user defined class or Object
|
|
681
|
+
// JSON.stringify avoids problems with cycles, and is generally much
|
|
682
|
+
// easier than looping through ownProperties of `val`.
|
|
683
|
+
try {
|
|
684
|
+
return 'Object(' + JSON.stringify(val) + ')';
|
|
685
|
+
} catch (_) {
|
|
686
|
+
return 'Object';
|
|
687
|
+
}
|
|
688
|
+
}
|
|
689
|
+
// errors
|
|
690
|
+
if (val instanceof Error) {
|
|
691
|
+
return `${val.name}: ${val.message}\n${val.stack}`;
|
|
692
|
+
}
|
|
693
|
+
// TODO we could test for more things here, like `Set`s and `Map`s.
|
|
694
|
+
return className;
|
|
695
|
+
}
|
|
721
696
|
|
|
722
|
-
|
|
723
|
-
|
|
724
|
-
|
|
697
|
+
function getArrayU32FromWasm0(ptr, len) {
|
|
698
|
+
ptr = ptr >>> 0;
|
|
699
|
+
return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
|
|
700
|
+
}
|
|
725
701
|
|
|
726
|
-
|
|
727
|
-
|
|
728
|
-
return
|
|
729
|
-
}
|
|
702
|
+
function getArrayU8FromWasm0(ptr, len) {
|
|
703
|
+
ptr = ptr >>> 0;
|
|
704
|
+
return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
|
|
705
|
+
}
|
|
730
706
|
|
|
731
|
-
|
|
732
|
-
|
|
733
|
-
|
|
734
|
-
|
|
707
|
+
let cachedDataViewMemory0 = null;
|
|
708
|
+
function getDataViewMemory0() {
|
|
709
|
+
if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
|
|
710
|
+
cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
|
|
711
|
+
}
|
|
712
|
+
return cachedDataViewMemory0;
|
|
713
|
+
}
|
|
735
714
|
|
|
736
|
-
|
|
737
|
-
|
|
738
|
-
return
|
|
739
|
-
}
|
|
715
|
+
function getStringFromWasm0(ptr, len) {
|
|
716
|
+
ptr = ptr >>> 0;
|
|
717
|
+
return decodeText(ptr, len);
|
|
718
|
+
}
|
|
740
719
|
|
|
741
|
-
|
|
742
|
-
|
|
743
|
-
|
|
744
|
-
|
|
720
|
+
let cachedUint32ArrayMemory0 = null;
|
|
721
|
+
function getUint32ArrayMemory0() {
|
|
722
|
+
if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
|
|
723
|
+
cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
|
|
724
|
+
}
|
|
725
|
+
return cachedUint32ArrayMemory0;
|
|
726
|
+
}
|
|
745
727
|
|
|
746
|
-
|
|
747
|
-
|
|
748
|
-
|
|
749
|
-
|
|
728
|
+
let cachedUint8ArrayMemory0 = null;
|
|
729
|
+
function getUint8ArrayMemory0() {
|
|
730
|
+
if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
|
|
731
|
+
cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
|
|
732
|
+
}
|
|
733
|
+
return cachedUint8ArrayMemory0;
|
|
734
|
+
}
|
|
750
735
|
|
|
751
|
-
|
|
752
|
-
|
|
753
|
-
|
|
736
|
+
function handleError(f, args) {
|
|
737
|
+
try {
|
|
738
|
+
return f.apply(this, args);
|
|
739
|
+
} catch (e) {
|
|
740
|
+
const idx = addToExternrefTable0(e);
|
|
741
|
+
wasm.__wbindgen_exn_store(idx);
|
|
742
|
+
}
|
|
743
|
+
}
|
|
754
744
|
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
|
|
758
|
-
const len1 = WASM_VECTOR_LEN;
|
|
759
|
-
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
760
|
-
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
761
|
-
};
|
|
762
|
-
|
|
763
|
-
module.exports.__wbg_static_accessor_GLOBAL_88a902d13a557d07 = function() {
|
|
764
|
-
const ret = typeof global === 'undefined' ? null : global;
|
|
765
|
-
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
766
|
-
};
|
|
767
|
-
|
|
768
|
-
module.exports.__wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0 = function() {
|
|
769
|
-
const ret = typeof globalThis === 'undefined' ? null : globalThis;
|
|
770
|
-
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
771
|
-
};
|
|
772
|
-
|
|
773
|
-
module.exports.__wbg_static_accessor_SELF_37c5d418e4bf5819 = function() {
|
|
774
|
-
const ret = typeof self === 'undefined' ? null : self;
|
|
775
|
-
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
776
|
-
};
|
|
777
|
-
|
|
778
|
-
module.exports.__wbg_static_accessor_WINDOW_5de37043a91a9c40 = function() {
|
|
779
|
-
const ret = typeof window === 'undefined' ? null : window;
|
|
780
|
-
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
781
|
-
};
|
|
782
|
-
|
|
783
|
-
module.exports.__wbg_then_44b73946d2fb3e7d = function(arg0, arg1) {
|
|
784
|
-
const ret = arg0.then(arg1);
|
|
785
|
-
return ret;
|
|
786
|
-
};
|
|
745
|
+
function isLikeNone(x) {
|
|
746
|
+
return x === undefined || x === null;
|
|
747
|
+
}
|
|
787
748
|
|
|
788
|
-
|
|
789
|
-
const
|
|
790
|
-
|
|
791
|
-
};
|
|
749
|
+
function makeMutClosure(arg0, arg1, dtor, f) {
|
|
750
|
+
const state = { a: arg0, b: arg1, cnt: 1, dtor };
|
|
751
|
+
const real = (...args) => {
|
|
792
752
|
|
|
793
|
-
|
|
794
|
-
|
|
795
|
-
|
|
796
|
-
|
|
753
|
+
// First up with a closure we increment the internal reference
|
|
754
|
+
// count. This ensures that the Rust closure environment won't
|
|
755
|
+
// be deallocated while we're invoking it.
|
|
756
|
+
state.cnt++;
|
|
757
|
+
const a = state.a;
|
|
758
|
+
state.a = 0;
|
|
759
|
+
try {
|
|
760
|
+
return f(a, state.b, ...args);
|
|
761
|
+
} finally {
|
|
762
|
+
state.a = a;
|
|
763
|
+
real._wbg_cb_unref();
|
|
764
|
+
}
|
|
765
|
+
};
|
|
766
|
+
real._wbg_cb_unref = () => {
|
|
767
|
+
if (--state.cnt === 0) {
|
|
768
|
+
state.dtor(state.a, state.b);
|
|
769
|
+
state.a = 0;
|
|
770
|
+
CLOSURE_DTORS.unregister(state);
|
|
771
|
+
}
|
|
772
|
+
};
|
|
773
|
+
CLOSURE_DTORS.register(real, state, state);
|
|
774
|
+
return real;
|
|
775
|
+
}
|
|
797
776
|
|
|
798
|
-
|
|
799
|
-
|
|
800
|
-
|
|
777
|
+
function passArray32ToWasm0(arg, malloc) {
|
|
778
|
+
const ptr = malloc(arg.length * 4, 4) >>> 0;
|
|
779
|
+
getUint32ArrayMemory0().set(arg, ptr / 4);
|
|
780
|
+
WASM_VECTOR_LEN = arg.length;
|
|
781
|
+
return ptr;
|
|
782
|
+
}
|
|
801
783
|
|
|
802
|
-
|
|
803
|
-
|
|
804
|
-
|
|
784
|
+
function passArray8ToWasm0(arg, malloc) {
|
|
785
|
+
const ptr = malloc(arg.length * 1, 1) >>> 0;
|
|
786
|
+
getUint8ArrayMemory0().set(arg, ptr / 1);
|
|
787
|
+
WASM_VECTOR_LEN = arg.length;
|
|
788
|
+
return ptr;
|
|
789
|
+
}
|
|
805
790
|
|
|
806
|
-
|
|
807
|
-
|
|
808
|
-
|
|
809
|
-
|
|
810
|
-
|
|
791
|
+
function passStringToWasm0(arg, malloc, realloc) {
|
|
792
|
+
if (realloc === undefined) {
|
|
793
|
+
const buf = cachedTextEncoder.encode(arg);
|
|
794
|
+
const ptr = malloc(buf.length, 1) >>> 0;
|
|
795
|
+
getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
|
|
796
|
+
WASM_VECTOR_LEN = buf.length;
|
|
797
|
+
return ptr;
|
|
811
798
|
}
|
|
812
|
-
const ret = false;
|
|
813
|
-
return ret;
|
|
814
|
-
};
|
|
815
799
|
|
|
816
|
-
|
|
817
|
-
|
|
818
|
-
return ret;
|
|
819
|
-
};
|
|
800
|
+
let len = arg.length;
|
|
801
|
+
let ptr = malloc(len, 1) >>> 0;
|
|
820
802
|
|
|
821
|
-
|
|
822
|
-
const ret = debugString(arg1);
|
|
823
|
-
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
824
|
-
const len1 = WASM_VECTOR_LEN;
|
|
825
|
-
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
826
|
-
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
827
|
-
};
|
|
828
|
-
|
|
829
|
-
module.exports.__wbindgen_init_externref_table = function() {
|
|
830
|
-
const table = wasm.__wbindgen_export_2;
|
|
831
|
-
const offset = table.grow(4);
|
|
832
|
-
table.set(0, undefined);
|
|
833
|
-
table.set(offset + 0, undefined);
|
|
834
|
-
table.set(offset + 1, null);
|
|
835
|
-
table.set(offset + 2, true);
|
|
836
|
-
table.set(offset + 3, false);
|
|
837
|
-
;
|
|
838
|
-
};
|
|
839
|
-
|
|
840
|
-
module.exports.__wbindgen_is_array = function(arg0) {
|
|
841
|
-
const ret = Array.isArray(arg0);
|
|
842
|
-
return ret;
|
|
843
|
-
};
|
|
803
|
+
const mem = getUint8ArrayMemory0();
|
|
844
804
|
|
|
845
|
-
|
|
846
|
-
const ret = typeof(arg0) === 'function';
|
|
847
|
-
return ret;
|
|
848
|
-
};
|
|
805
|
+
let offset = 0;
|
|
849
806
|
|
|
850
|
-
|
|
851
|
-
|
|
852
|
-
|
|
853
|
-
|
|
807
|
+
for (; offset < len; offset++) {
|
|
808
|
+
const code = arg.charCodeAt(offset);
|
|
809
|
+
if (code > 0x7F) break;
|
|
810
|
+
mem[ptr + offset] = code;
|
|
811
|
+
}
|
|
812
|
+
if (offset !== len) {
|
|
813
|
+
if (offset !== 0) {
|
|
814
|
+
arg = arg.slice(offset);
|
|
815
|
+
}
|
|
816
|
+
ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
|
|
817
|
+
const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
|
|
818
|
+
const ret = cachedTextEncoder.encodeInto(arg, view);
|
|
854
819
|
|
|
855
|
-
|
|
856
|
-
|
|
857
|
-
|
|
858
|
-
};
|
|
820
|
+
offset += ret.written;
|
|
821
|
+
ptr = realloc(ptr, len, offset, 1) >>> 0;
|
|
822
|
+
}
|
|
859
823
|
|
|
860
|
-
|
|
861
|
-
|
|
862
|
-
|
|
863
|
-
getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
|
|
864
|
-
getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
|
|
865
|
-
};
|
|
824
|
+
WASM_VECTOR_LEN = offset;
|
|
825
|
+
return ptr;
|
|
826
|
+
}
|
|
866
827
|
|
|
867
|
-
|
|
868
|
-
const
|
|
869
|
-
|
|
870
|
-
|
|
871
|
-
|
|
872
|
-
|
|
873
|
-
|
|
874
|
-
|
|
875
|
-
|
|
876
|
-
|
|
877
|
-
|
|
878
|
-
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
879
|
-
};
|
|
880
|
-
|
|
881
|
-
module.exports.__wbindgen_string_new = function(arg0, arg1) {
|
|
882
|
-
const ret = getStringFromWasm0(arg0, arg1);
|
|
883
|
-
return ret;
|
|
884
|
-
};
|
|
828
|
+
function takeFromExternrefTable0(idx) {
|
|
829
|
+
const value = wasm.__wbindgen_externrefs.get(idx);
|
|
830
|
+
wasm.__externref_table_dealloc(idx);
|
|
831
|
+
return value;
|
|
832
|
+
}
|
|
833
|
+
|
|
834
|
+
let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
|
|
835
|
+
cachedTextDecoder.decode();
|
|
836
|
+
function decodeText(ptr, len) {
|
|
837
|
+
return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
|
|
838
|
+
}
|
|
885
839
|
|
|
886
|
-
|
|
887
|
-
throw new Error(getStringFromWasm0(arg0, arg1));
|
|
888
|
-
};
|
|
840
|
+
const cachedTextEncoder = new TextEncoder();
|
|
889
841
|
|
|
890
|
-
|
|
891
|
-
|
|
842
|
+
if (!('encodeInto' in cachedTextEncoder)) {
|
|
843
|
+
cachedTextEncoder.encodeInto = function (arg, view) {
|
|
844
|
+
const buf = cachedTextEncoder.encode(arg);
|
|
845
|
+
view.set(buf);
|
|
846
|
+
return {
|
|
847
|
+
read: arg.length,
|
|
848
|
+
written: buf.length
|
|
849
|
+
};
|
|
850
|
+
};
|
|
851
|
+
}
|
|
892
852
|
|
|
893
|
-
|
|
894
|
-
const wasmInstance = new WebAssembly.Instance(wasmModule, imports);
|
|
895
|
-
wasm = wasmInstance.exports;
|
|
896
|
-
module.exports.__wasm = wasm;
|
|
853
|
+
let WASM_VECTOR_LEN = 0;
|
|
897
854
|
|
|
855
|
+
const wasmPath = `${__dirname}/acvm_js_bg.wasm`;
|
|
856
|
+
const wasmBytes = require('fs').readFileSync(wasmPath);
|
|
857
|
+
const wasmModule = new WebAssembly.Module(wasmBytes);
|
|
858
|
+
let wasm = new WebAssembly.Instance(wasmModule, __wbg_get_imports()).exports;
|
|
898
859
|
wasm.__wbindgen_start();
|
|
899
|
-
|