@wireapp/core-crypto 0.6.0-rc.4 → 0.6.0-rc.6

Sign up to get free protection for your applications and to get access to all the features.
Files changed (5) hide show
  1. package/package.json +64 -62
  2. package/platforms/web/assets/core_crypto_ffi-fb64c1f7.wasm +0 -0
  3. package/platforms/web/corecrypto.d.ts +42 -11
  4. package/platforms/web/corecrypto.js +1447 -1251
  5. package/platforms/web/assets/core_crypto_ffi-7a5675cc.wasm +0 -0
package/platforms/web/corecrypto.js CHANGED
@@ -1,98 +1,85 @@
1
- /******************************************************************************
2
- Copyright (c) Microsoft Corporation.
3
-
4
- Permission to use, copy, modify, and/or distribute this software for any
5
- purpose with or without fee is hereby granted.
6
-
7
- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
8
- REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
9
- AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
10
- INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
11
- LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
12
- OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
13
- PERFORMANCE OF THIS SOFTWARE.
14
- ***************************************************************************** */
15
-
16
- function __classPrivateFieldGet(receiver, state, kind, f) {
17
- if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
18
- if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
19
- return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
20
- }
21
-
22
- function __classPrivateFieldSet(receiver, state, value, kind, f) {
23
- if (kind === "m") throw new TypeError("Private method is not writable");
24
- if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
25
- if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
26
- return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
1
+ /******************************************************************************
2
+ Copyright (c) Microsoft Corporation.
3
+
4
+ Permission to use, copy, modify, and/or distribute this software for any
5
+ purpose with or without fee is hereby granted.
6
+
7
+ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
8
+ REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
9
+ AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
10
+ INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
11
+ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
12
+ OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
13
+ PERFORMANCE OF THIS SOFTWARE.
14
+ ***************************************************************************** */
15
+ function __classPrivateFieldGet(receiver, state, kind, f) {
16
+ if (kind === "a" && !f)
17
+ throw new TypeError("Private accessor was defined without a getter");
18
+ if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
19
+ throw new TypeError("Cannot read private member from an object whose class did not declare it");
20
+ return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
21
+ }
22
+ function __classPrivateFieldSet(receiver, state, value, kind, f) {
23
+ if (kind === "m")
24
+ throw new TypeError("Private method is not writable");
25
+ if (kind === "a" && !f)
26
+ throw new TypeError("Private accessor was defined without a setter");
27
+ if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
28
+ throw new TypeError("Cannot write private member to an object whose class did not declare it");
29
+ return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
27
30
  }
28
31
 
29
32
  let wasm$1;
30
-
31
- const heap = new Array(32).fill(undefined);
32
-
33
+ const heap = new Array(128).fill(undefined);
33
34
  heap.push(undefined, null, true, false);
34
-
35
35
  function getObject(idx) { return heap[idx]; }
36
-
37
36
  let heap_next = heap.length;
38
-
39
- function addHeapObject(obj) {
40
- if (heap_next === heap.length) heap.push(heap.length + 1);
41
- const idx = heap_next;
42
- heap_next = heap[idx];
43
-
44
- heap[idx] = obj;
45
- return idx;
46
- }
47
-
48
37
  function dropObject(idx) {
49
- if (idx < 36) return;
38
+ if (idx < 132)
39
+ return;
50
40
  heap[idx] = heap_next;
51
41
  heap_next = idx;
52
42
  }
53
-
54
43
  function takeObject(idx) {
55
44
  const ret = getObject(idx);
56
45
  dropObject(idx);
57
46
  return ret;
58
47
  }
59
-
48
+ function addHeapObject(obj) {
49
+ if (heap_next === heap.length)
50
+ heap.push(heap.length + 1);
51
+ const idx = heap_next;
52
+ heap_next = heap[idx];
53
+ heap[idx] = obj;
54
+ return idx;
55
+ }
60
56
  const cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
61
-
62
57
  cachedTextDecoder.decode();
63
-
64
- let cachedUint8Memory0 = new Uint8Array();
65
-
58
+ let cachedUint8Memory0 = null;
66
59
  function getUint8Memory0() {
67
- if (cachedUint8Memory0.byteLength === 0) {
60
+ if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
68
61
  cachedUint8Memory0 = new Uint8Array(wasm$1.memory.buffer);
69
62
  }
70
63
  return cachedUint8Memory0;
71
64
  }
72
-
73
65
  function getStringFromWasm0(ptr, len) {
74
66
  return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
75
67
  }
76
-
77
68
  let WASM_VECTOR_LEN = 0;
78
-
79
69
  const cachedTextEncoder = new TextEncoder('utf-8');
80
-
81
70
  const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
82
71
  ? function (arg, view) {
83
- return cachedTextEncoder.encodeInto(arg, view);
84
- }
72
+ return cachedTextEncoder.encodeInto(arg, view);
73
+ }
85
74
  : function (arg, view) {
86
- const buf = cachedTextEncoder.encode(arg);
87
- view.set(buf);
88
- return {
89
- read: arg.length,
90
- written: buf.length
91
- };
92
- });
93
-
75
+ const buf = cachedTextEncoder.encode(arg);
76
+ view.set(buf);
77
+ return {
78
+ read: arg.length,
79
+ written: buf.length
80
+ };
81
+ });
94
82
  function passStringToWasm0(arg, malloc, realloc) {
95
-
96
83
  if (realloc === undefined) {
97
84
  const buf = cachedTextEncoder.encode(arg);
98
85
  const ptr = malloc(buf.length);
@@ -100,20 +87,16 @@ function passStringToWasm0(arg, malloc, realloc) {
100
87
  WASM_VECTOR_LEN = buf.length;
101
88
  return ptr;
102
89
  }
103
-
104
90
  let len = arg.length;
105
91
  let ptr = malloc(len);
106
-
107
92
  const mem = getUint8Memory0();
108
-
109
93
  let offset = 0;
110
-
111
94
  for (; offset < len; offset++) {
112
95
  const code = arg.charCodeAt(offset);
113
- if (code > 0x7F) break;
96
+ if (code > 0x7F)
97
+ break;
114
98
  mem[ptr + offset] = code;
115
99
  }
116
-
117
100
  if (offset !== len) {
118
101
  if (offset !== 0) {
119
102
  arg = arg.slice(offset);
@@ -121,50 +104,40 @@ function passStringToWasm0(arg, malloc, realloc) {
121
104
  ptr = realloc(ptr, len, len = offset + arg.length * 3);
122
105
  const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
123
106
  const ret = encodeString(arg, view);
124
-
125
107
  offset += ret.written;
126
108
  }
127
-
128
109
  WASM_VECTOR_LEN = offset;
129
110
  return ptr;
130
111
  }
131
-
132
112
  function isLikeNone(x) {
133
113
  return x === undefined || x === null;
134
114
  }
135
-
136
- let cachedInt32Memory0 = new Int32Array();
137
-
115
+ let cachedInt32Memory0 = null;
138
116
  function getInt32Memory0() {
139
- if (cachedInt32Memory0.byteLength === 0) {
117
+ if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
140
118
  cachedInt32Memory0 = new Int32Array(wasm$1.memory.buffer);
141
119
  }
142
120
  return cachedInt32Memory0;
143
121
  }
144
-
145
- let cachedFloat64Memory0 = new Float64Array();
146
-
122
+ let cachedFloat64Memory0 = null;
147
123
  function getFloat64Memory0() {
148
- if (cachedFloat64Memory0.byteLength === 0) {
124
+ if (cachedFloat64Memory0 === null || cachedFloat64Memory0.byteLength === 0) {
149
125
  cachedFloat64Memory0 = new Float64Array(wasm$1.memory.buffer);
150
126
  }
151
127
  return cachedFloat64Memory0;
152
128
  }
153
-
154
- let cachedBigInt64Memory0 = new BigInt64Array();
155
-
129
+ let cachedBigInt64Memory0 = null;
156
130
  function getBigInt64Memory0() {
157
- if (cachedBigInt64Memory0.byteLength === 0) {
131
+ if (cachedBigInt64Memory0 === null || cachedBigInt64Memory0.byteLength === 0) {
158
132
  cachedBigInt64Memory0 = new BigInt64Array(wasm$1.memory.buffer);
159
133
  }
160
134
  return cachedBigInt64Memory0;
161
135
  }
162
-
163
136
  function debugString(val) {
164
137
  // primitive types
165
138
  const type = typeof val;
166
139
  if (type == 'number' || type == 'boolean' || val == null) {
167
- return `${val}`;
140
+ return `${val}`;
168
141
  }
169
142
  if (type == 'string') {
170
143
  return `"${val}"`;
@@ -173,7 +146,8 @@ function debugString(val) {
173
146
  const description = val.description;
174
147
  if (description == null) {
175
148
  return 'Symbol';
176
- } else {
149
+ }
150
+ else {
177
151
  return `Symbol(${description})`;
178
152
  }
179
153
  }
@@ -181,7 +155,8 @@ function debugString(val) {
181
155
  const name = val.name;
182
156
  if (typeof name == 'string' && name.length > 0) {
183
157
  return `Function(${name})`;
184
- } else {
158
+ }
159
+ else {
185
160
  return 'Function';
186
161
  }
187
162
  }
@@ -192,7 +167,7 @@ function debugString(val) {
192
167
  if (length > 0) {
193
168
  debug += debugString(val[0]);
194
169
  }
195
- for(let i = 1; i < length; i++) {
170
+ for (let i = 1; i < length; i++) {
196
171
  debug += ', ' + debugString(val[i]);
197
172
  }
198
173
  debug += ']';
@@ -203,7 +178,8 @@ function debugString(val) {
203
178
  let className;
204
179
  if (builtInMatches.length > 1) {
205
180
  className = builtInMatches[1];
206
- } else {
181
+ }
182
+ else {
207
183
  // Failed to match the standard '[object ClassName]'
208
184
  return toString.call(val);
209
185
  }
@@ -213,7 +189,8 @@ function debugString(val) {
213
189
  // easier than looping through ownProperties of `val`.
214
190
  try {
215
191
  return 'Object(' + JSON.stringify(val) + ')';
216
- } catch (_) {
192
+ }
193
+ catch (_) {
217
194
  return 'Object';
218
195
  }
219
196
  }
@@ -224,7 +201,6 @@ function debugString(val) {
224
201
  // TODO we could test for more things here, like `Set`s and `Map`s.
225
202
  return className;
226
203
  }
227
-
228
204
  function makeMutClosure(arg0, arg1, dtor, f) {
229
205
  const state = { a: arg0, b: arg1, cnt: 1, dtor };
230
206
  const real = (...args) => {
@@ -236,53 +212,49 @@ function makeMutClosure(arg0, arg1, dtor, f) {
236
212
  state.a = 0;
237
213
  try {
238
214
  return f(a, state.b, ...args);
239
- } finally {
215
+ }
216
+ finally {
240
217
  if (--state.cnt === 0) {
241
218
  wasm$1.__wbindgen_export_2.get(state.dtor)(a, state.b);
242
-
243
- } else {
219
+ }
220
+ else {
244
221
  state.a = a;
245
222
  }
246
223
  }
247
224
  };
248
225
  real.original = state;
249
-
250
226
  return real;
251
227
  }
252
228
  function __wbg_adapter_52(arg0, arg1, arg2) {
253
229
  try {
254
230
  const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
255
- wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h577395c5a39b7036(retptr, arg0, arg1, addHeapObject(arg2));
231
+ wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h017e8b5914b4ce6e(retptr, arg0, arg1, addHeapObject(arg2));
256
232
  var r0 = getInt32Memory0()[retptr / 4 + 0];
257
233
  var r1 = getInt32Memory0()[retptr / 4 + 1];
258
234
  if (r1) {
259
235
  throw takeObject(r0);
260
236
  }
261
- } finally {
237
+ }
238
+ finally {
262
239
  wasm$1.__wbindgen_add_to_stack_pointer(16);
263
240
  }
264
241
  }
265
-
266
242
  function __wbg_adapter_55(arg0, arg1, arg2) {
267
- wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h6fecff61d3f85de1(arg0, arg1, addHeapObject(arg2));
243
+ wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h2cd85c49913904d9(arg0, arg1, addHeapObject(arg2));
268
244
  }
269
-
270
245
  function _assertClass(instance, klass) {
271
246
  if (!(instance instanceof klass)) {
272
247
  throw new Error(`expected instance of ${klass.name}`);
273
248
  }
274
249
  return instance.ptr;
275
250
  }
276
-
277
- let cachedUint32Memory0 = new Uint32Array();
278
-
251
+ let cachedUint32Memory0 = null;
279
252
  function getUint32Memory0() {
280
- if (cachedUint32Memory0.byteLength === 0) {
253
+ if (cachedUint32Memory0 === null || cachedUint32Memory0.byteLength === 0) {
281
254
  cachedUint32Memory0 = new Uint32Array(wasm$1.memory.buffer);
282
255
  }
283
256
  return cachedUint32Memory0;
284
257
  }
285
-
286
258
  function passArrayJsValueToWasm0(array, malloc) {
287
259
  const ptr = malloc(array.length * 4);
288
260
  const mem = getUint32Memory0();
@@ -292,14 +264,12 @@ function passArrayJsValueToWasm0(array, malloc) {
292
264
  WASM_VECTOR_LEN = array.length;
293
265
  return ptr;
294
266
  }
295
-
296
267
  function passArray8ToWasm0(arg, malloc) {
297
268
  const ptr = malloc(arg.length * 1);
298
269
  getUint8Memory0().set(arg, ptr / 1);
299
270
  WASM_VECTOR_LEN = arg.length;
300
271
  return ptr;
301
272
  }
302
-
303
273
  function getArrayJsValueFromWasm0(ptr, len) {
304
274
  const mem = getUint32Memory0();
305
275
  const slice = mem.subarray(ptr / 4, ptr / 4 + len);
@@ -320,90 +290,86 @@ function version() {
320
290
  var r0 = getInt32Memory0()[retptr / 4 + 0];
321
291
  var r1 = getInt32Memory0()[retptr / 4 + 1];
322
292
  return getStringFromWasm0(r0, r1);
323
- } finally {
293
+ }
294
+ finally {
324
295
  wasm$1.__wbindgen_add_to_stack_pointer(16);
325
296
  wasm$1.__wbindgen_free(r0, r1);
326
297
  }
327
298
  }
328
-
329
299
  function handleError(f, args) {
330
300
  try {
331
301
  return f.apply(this, args);
332
- } catch (e) {
302
+ }
303
+ catch (e) {
333
304
  wasm$1.__wbindgen_exn_store(addHeapObject(e));
334
305
  }
335
306
  }
336
-
337
307
  function getArrayU8FromWasm0(ptr, len) {
338
308
  return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
339
309
  }
340
- function __wbg_adapter_260(arg0, arg1, arg2, arg3) {
341
- wasm$1.wasm_bindgen__convert__closures__invoke2_mut__ha446eb95921e2107(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
310
+ function __wbg_adapter_263(arg0, arg1, arg2, arg3) {
311
+ wasm$1.wasm_bindgen__convert__closures__invoke2_mut__h8cd39efe380c2d83(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
342
312
  }
343
-
344
313
  /**
345
314
  * see [core_crypto::prelude::MlsWirePolicy]
346
315
  */
347
316
  const WirePolicy$1 = Object.freeze({
348
- /**
349
- * Handshake messages are never encrypted
350
- */
351
- Plaintext:1,"1":"Plaintext",
352
- /**
353
- * Handshake messages are always encrypted
354
- */
355
- Ciphertext:2,"2":"Ciphertext", });
317
+ /**
318
+ * Handshake messages are never encrypted
319
+ */
320
+ Plaintext: 1, "1": "Plaintext",
321
+ /**
322
+ * Handshake messages are always encrypted
323
+ */
324
+ Ciphertext: 2, "2": "Ciphertext",
325
+ });
356
326
  /**
357
327
  * see [core_crypto::prelude::CiphersuiteName]
358
328
  */
359
329
  const Ciphersuite$1 = Object.freeze({
360
- /**
361
- * DH KEM x25519 | AES-GCM 128 | SHA2-256 | Ed25519
362
- */
363
- MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519:1,"1":"MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519",
364
- /**
365
- * DH KEM P256 | AES-GCM 128 | SHA2-256 | EcDSA P256
366
- */
367
- MLS_128_DHKEMP256_AES128GCM_SHA256_P256:2,"2":"MLS_128_DHKEMP256_AES128GCM_SHA256_P256",
368
- /**
369
- * DH KEM x25519 | Chacha20Poly1305 | SHA2-256 | Ed25519
370
- */
371
- MLS_128_DHKEMX25519_CHACHA20POLY1305_SHA256_Ed25519:3,"3":"MLS_128_DHKEMX25519_CHACHA20POLY1305_SHA256_Ed25519",
372
- /**
373
- * DH KEM x448 | AES-GCM 256 | SHA2-512 | Ed448
374
- */
375
- MLS_256_DHKEMX448_AES256GCM_SHA512_Ed448:4,"4":"MLS_256_DHKEMX448_AES256GCM_SHA512_Ed448",
376
- /**
377
- * DH KEM P521 | AES-GCM 256 | SHA2-512 | EcDSA P521
378
- */
379
- MLS_256_DHKEMP521_AES256GCM_SHA512_P521:5,"5":"MLS_256_DHKEMP521_AES256GCM_SHA512_P521",
380
- /**
381
- * DH KEM x448 | Chacha20Poly1305 | SHA2-512 | Ed448
382
- */
383
- MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448:6,"6":"MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448",
384
- /**
385
- * DH KEM P384 | AES-GCM 256 | SHA2-384 | EcDSA P384
386
- */
387
- MLS_256_DHKEMP384_AES256GCM_SHA384_P384:7,"7":"MLS_256_DHKEMP384_AES256GCM_SHA384_P384", });
330
+ /**
331
+ * DH KEM x25519 | AES-GCM 128 | SHA2-256 | Ed25519
332
+ */
333
+ MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519: 1, "1": "MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519",
334
+ /**
335
+ * DH KEM P256 | AES-GCM 128 | SHA2-256 | EcDSA P256
336
+ */
337
+ MLS_128_DHKEMP256_AES128GCM_SHA256_P256: 2, "2": "MLS_128_DHKEMP256_AES128GCM_SHA256_P256",
338
+ /**
339
+ * DH KEM x25519 | Chacha20Poly1305 | SHA2-256 | Ed25519
340
+ */
341
+ MLS_128_DHKEMX25519_CHACHA20POLY1305_SHA256_Ed25519: 3, "3": "MLS_128_DHKEMX25519_CHACHA20POLY1305_SHA256_Ed25519",
342
+ /**
343
+ * DH KEM x448 | AES-GCM 256 | SHA2-512 | Ed448
344
+ */
345
+ MLS_256_DHKEMX448_AES256GCM_SHA512_Ed448: 4, "4": "MLS_256_DHKEMX448_AES256GCM_SHA512_Ed448",
346
+ /**
347
+ * DH KEM P521 | AES-GCM 256 | SHA2-512 | EcDSA P521
348
+ */
349
+ MLS_256_DHKEMP521_AES256GCM_SHA512_P521: 5, "5": "MLS_256_DHKEMP521_AES256GCM_SHA512_P521",
350
+ /**
351
+ * DH KEM x448 | Chacha20Poly1305 | SHA2-512 | Ed448
352
+ */
353
+ MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448: 6, "6": "MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448",
354
+ /**
355
+ * DH KEM P384 | AES-GCM 256 | SHA2-384 | EcDSA P384
356
+ */
357
+ MLS_256_DHKEMP384_AES256GCM_SHA384_P384: 7, "7": "MLS_256_DHKEMP384_AES256GCM_SHA384_P384",
358
+ });
388
359
  /**
389
360
  * See [core_crypto::e2e_identity::types::E2eiAcmeChallenge]
390
361
  */
391
362
  class AcmeChallenge {
392
-
393
363
  static __wrap(ptr) {
394
364
  const obj = Object.create(AcmeChallenge.prototype);
395
365
  obj.ptr = ptr;
396
-
397
366
  return obj;
398
367
  }
399
-
400
368
  __destroy_into_raw() {
401
369
  const ptr = this.ptr;
402
370
  this.ptr = 0;
403
-
404
371
  return ptr;
405
372
  }
406
-
407
373
  free() {
408
374
  const ptr = this.__destroy_into_raw();
409
375
  wasm$1.__wbg_acmechallenge_free(ptr);
@@ -435,7 +401,8 @@ class AcmeChallenge {
435
401
  var r0 = getInt32Memory0()[retptr / 4 + 0];
436
402
  var r1 = getInt32Memory0()[retptr / 4 + 1];
437
403
  return getStringFromWasm0(r0, r1);
438
- } finally {
404
+ }
405
+ finally {
439
406
  wasm$1.__wbindgen_add_to_stack_pointer(16);
440
407
  wasm$1.__wbindgen_free(r0, r1);
441
408
  }
@@ -445,21 +412,16 @@ class AcmeChallenge {
445
412
  * See [core_crypto::e2e_identity::types::E2eiAcmeDirectory]
446
413
  */
447
414
  class AcmeDirectory {
448
-
449
415
  static __wrap(ptr) {
450
416
  const obj = Object.create(AcmeDirectory.prototype);
451
417
  obj.ptr = ptr;
452
-
453
418
  return obj;
454
419
  }
455
-
456
420
  __destroy_into_raw() {
457
421
  const ptr = this.ptr;
458
422
  this.ptr = 0;
459
-
460
423
  return ptr;
461
424
  }
462
-
463
425
  free() {
464
426
  const ptr = this.__destroy_into_raw();
465
427
  wasm$1.__wbg_acmedirectory_free(ptr);
@@ -489,7 +451,8 @@ class AcmeDirectory {
489
451
  var r0 = getInt32Memory0()[retptr / 4 + 0];
490
452
  var r1 = getInt32Memory0()[retptr / 4 + 1];
491
453
  return getStringFromWasm0(r0, r1);
492
- } finally {
454
+ }
455
+ finally {
493
456
  wasm$1.__wbindgen_add_to_stack_pointer(16);
494
457
  wasm$1.__wbindgen_free(r0, r1);
495
458
  }
@@ -504,7 +467,8 @@ class AcmeDirectory {
504
467
  var r0 = getInt32Memory0()[retptr / 4 + 0];
505
468
  var r1 = getInt32Memory0()[retptr / 4 + 1];
506
469
  return getStringFromWasm0(r0, r1);
507
- } finally {
470
+ }
471
+ finally {
508
472
  wasm$1.__wbindgen_add_to_stack_pointer(16);
509
473
  wasm$1.__wbindgen_free(r0, r1);
510
474
  }
@@ -519,7 +483,8 @@ class AcmeDirectory {
519
483
  var r0 = getInt32Memory0()[retptr / 4 + 0];
520
484
  var r1 = getInt32Memory0()[retptr / 4 + 1];
521
485
  return getStringFromWasm0(r0, r1);
522
- } finally {
486
+ }
487
+ finally {
523
488
  wasm$1.__wbindgen_add_to_stack_pointer(16);
524
489
  wasm$1.__wbindgen_free(r0, r1);
525
490
  }
@@ -529,21 +494,16 @@ class AcmeDirectory {
529
494
  * See [core_crypto::e2e_identity::types::E2eiAcmeFinalize]
530
495
  */
531
496
  class AcmeFinalize {
532
-
533
497
  static __wrap(ptr) {
534
498
  const obj = Object.create(AcmeFinalize.prototype);
535
499
  obj.ptr = ptr;
536
-
537
500
  return obj;
538
501
  }
539
-
540
502
  __destroy_into_raw() {
541
503
  const ptr = this.ptr;
542
504
  this.ptr = 0;
543
-
544
505
  return ptr;
545
506
  }
546
-
547
507
  free() {
548
508
  const ptr = this.__destroy_into_raw();
549
509
  wasm$1.__wbg_acmefinalize_free(ptr);
@@ -575,7 +535,8 @@ class AcmeFinalize {
575
535
  var r0 = getInt32Memory0()[retptr / 4 + 0];
576
536
  var r1 = getInt32Memory0()[retptr / 4 + 1];
577
537
  return getStringFromWasm0(r0, r1);
578
- } finally {
538
+ }
539
+ finally {
579
540
  wasm$1.__wbindgen_add_to_stack_pointer(16);
580
541
  wasm$1.__wbindgen_free(r0, r1);
581
542
  }
@@ -584,14 +545,11 @@ class AcmeFinalize {
584
545
  /**
585
546
  */
586
547
  class CommitBundle {
587
-
588
548
  __destroy_into_raw() {
589
549
  const ptr = this.ptr;
590
550
  this.ptr = 0;
591
-
592
551
  return ptr;
593
552
  }
594
-
595
553
  free() {
596
554
  const ptr = this.__destroy_into_raw();
597
555
  wasm$1.__wbg_commitbundle_free(ptr);
@@ -622,21 +580,16 @@ class CommitBundle {
622
580
  * see [core_crypto::prelude::MlsConversationConfiguration]
623
581
  */
624
582
  class ConversationConfiguration {
625
-
626
583
  static __wrap(ptr) {
627
584
  const obj = Object.create(ConversationConfiguration.prototype);
628
585
  obj.ptr = ptr;
629
-
630
586
  return obj;
631
587
  }
632
-
633
588
  __destroy_into_raw() {
634
589
  const ptr = this.ptr;
635
590
  this.ptr = 0;
636
-
637
591
  return ptr;
638
592
  }
639
-
640
593
  free() {
641
594
  const ptr = this.__destroy_into_raw();
642
595
  wasm$1.__wbg_conversationconfiguration_free(ptr);
@@ -657,14 +610,11 @@ class ConversationConfiguration {
657
610
  /**
658
611
  */
659
612
  class ConversationInitBundle {
660
-
661
613
  __destroy_into_raw() {
662
614
  const ptr = this.ptr;
663
615
  this.ptr = 0;
664
-
665
616
  return ptr;
666
617
  }
667
-
668
618
  free() {
669
619
  const ptr = this.__destroy_into_raw();
670
620
  wasm$1.__wbg_conversationinitbundle_free(ptr);
@@ -673,14 +623,14 @@ class ConversationInitBundle {
673
623
  * @returns {Uint8Array}
674
624
  */
675
625
  get conversation_id() {
676
- const ret = wasm$1.commitbundle_commit(this.ptr);
626
+ const ret = wasm$1.conversationinitbundle_conversation_id(this.ptr);
677
627
  return takeObject(ret);
678
628
  }
679
629
  /**
680
630
  * @returns {Uint8Array}
681
631
  */
682
632
  get commit() {
683
- const ret = wasm$1.conversationinitbundle_commit(this.ptr);
633
+ const ret = wasm$1.commitbundle_commit(this.ptr);
684
634
  return takeObject(ret);
685
635
  }
686
636
  /**
@@ -693,22 +643,17 @@ class ConversationInitBundle {
693
643
  }
694
644
  /**
695
645
  */
696
- class CoreCrypto$1 {
697
-
646
+ let CoreCrypto$1 = class CoreCrypto {
698
647
  static __wrap(ptr) {
699
- const obj = Object.create(CoreCrypto$1.prototype);
648
+ const obj = Object.create(CoreCrypto.prototype);
700
649
  obj.ptr = ptr;
701
-
702
650
  return obj;
703
651
  }
704
-
705
652
  __destroy_into_raw() {
706
653
  const ptr = this.ptr;
707
654
  this.ptr = 0;
708
-
709
655
  return ptr;
710
656
  }
711
-
712
657
  free() {
713
658
  const ptr = this.__destroy_into_raw();
714
659
  wasm$1.__wbg_corecrypto_free(ptr);
@@ -792,8 +737,7 @@ class CoreCrypto$1 {
792
737
  */
793
738
  set_callbacks(callbacks) {
794
739
  _assertClass(callbacks, CoreCryptoWasmCallbacks);
795
- var ptr0 = callbacks.ptr;
796
- callbacks.ptr = 0;
740
+ var ptr0 = callbacks.__destroy_into_raw();
797
741
  const ret = wasm$1.corecrypto_set_callbacks(this.ptr, ptr0);
798
742
  return takeObject(ret);
799
743
  }
@@ -840,8 +784,7 @@ class CoreCrypto$1 {
840
784
  const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
841
785
  const len0 = WASM_VECTOR_LEN;
842
786
  _assertClass(config, ConversationConfiguration);
843
- var ptr1 = config.ptr;
844
- config.ptr = 0;
787
+ var ptr1 = config.__destroy_into_raw();
845
788
  const ret = wasm$1.corecrypto_create_conversation(this.ptr, ptr0, len0, ptr1);
846
789
  return takeObject(ret);
847
790
  }
@@ -883,8 +826,7 @@ class CoreCrypto$1 {
883
826
  const ptr0 = passArray8ToWasm0(welcome_message, wasm$1.__wbindgen_malloc);
884
827
  const len0 = WASM_VECTOR_LEN;
885
828
  _assertClass(custom_configuration, CustomConfiguration);
886
- var ptr1 = custom_configuration.ptr;
887
- custom_configuration.ptr = 0;
829
+ var ptr1 = custom_configuration.__destroy_into_raw();
888
830
  const ret = wasm$1.corecrypto_process_welcome_message(this.ptr, ptr0, len0, ptr1);
889
831
  return takeObject(ret);
890
832
  }
@@ -1090,8 +1032,7 @@ class CoreCrypto$1 {
1090
1032
  const ptr0 = passArray8ToWasm0(public_group_state, wasm$1.__wbindgen_malloc);
1091
1033
  const len0 = WASM_VECTOR_LEN;
1092
1034
  _assertClass(custom_configuration, CustomConfiguration);
1093
- var ptr1 = custom_configuration.ptr;
1094
- custom_configuration.ptr = 0;
1035
+ var ptr1 = custom_configuration.__destroy_into_raw();
1095
1036
  const ret = wasm$1.corecrypto_join_by_external_commit(this.ptr, ptr0, len0, ptr1);
1096
1037
  return takeObject(ret);
1097
1038
  }
@@ -1389,11 +1330,13 @@ class CoreCrypto$1 {
1389
1330
  var ptr1 = r0;
1390
1331
  var len1 = r1;
1391
1332
  if (r3) {
1392
- ptr1 = 0; len1 = 0;
1333
+ ptr1 = 0;
1334
+ len1 = 0;
1393
1335
  throw takeObject(r2);
1394
1336
  }
1395
1337
  return getStringFromWasm0(ptr1, len1);
1396
- } finally {
1338
+ }
1339
+ finally {
1397
1340
  wasm$1.__wbindgen_add_to_stack_pointer(16);
1398
1341
  wasm$1.__wbindgen_free(ptr1, len1);
1399
1342
  }
@@ -1412,6 +1355,14 @@ class CoreCrypto$1 {
1412
1355
  return takeObject(ret);
1413
1356
  }
1414
1357
  /**
1358
+ * Returns: [`WasmCryptoResult<u32>`]
1359
+ * @returns {Promise<any>}
1360
+ */
1361
+ proteus_last_error_code() {
1362
+ const ret = wasm$1.corecrypto_proteus_last_error_code(this.ptr);
1363
+ return takeObject(ret);
1364
+ }
1365
+ /**
1415
1366
  * Returns: [`WasmCryptoResult<Vec<u8>>`]
1416
1367
  *
1417
1368
  * see [core_crypto::MlsCentral::export_secret_key]
@@ -1441,32 +1392,27 @@ class CoreCrypto$1 {
1441
1392
  /**
1442
1393
  * see [core_crypto::MlsCentral::new_acme_enrollment]
1443
1394
  * @param {number} ciphersuite
1444
- * @returns {Promise<WireE2eIdentity>}
1395
+ * @returns {Promise<FfiWireE2EIdentity>}
1445
1396
  */
1446
1397
  new_acme_enrollment(ciphersuite) {
1447
1398
  const ret = wasm$1.corecrypto_new_acme_enrollment(this.ptr, ciphersuite);
1448
1399
  return takeObject(ret);
1449
1400
  }
1450
- }
1401
+ };
1451
1402
  /**
1452
1403
  * see [core_crypto::prelude::CoreCryptoCallbacks]
1453
1404
  */
1454
1405
  class CoreCryptoWasmCallbacks {
1455
-
1456
1406
  static __wrap(ptr) {
1457
1407
  const obj = Object.create(CoreCryptoWasmCallbacks.prototype);
1458
1408
  obj.ptr = ptr;
1459
-
1460
1409
  return obj;
1461
1410
  }
1462
-
1463
1411
  __destroy_into_raw() {
1464
1412
  const ptr = this.ptr;
1465
1413
  this.ptr = 0;
1466
-
1467
1414
  return ptr;
1468
1415
  }
1469
-
1470
1416
  free() {
1471
1417
  const ptr = this.__destroy_into_raw();
1472
1418
  wasm$1.__wbg_corecryptowasmcallbacks_free(ptr);
@@ -1485,21 +1431,16 @@ class CoreCryptoWasmCallbacks {
1485
1431
  * see [core_crypto::prelude::MlsCustomConfiguration]
1486
1432
  */
1487
1433
  class CustomConfiguration {
1488
-
1489
1434
  static __wrap(ptr) {
1490
1435
  const obj = Object.create(CustomConfiguration.prototype);
1491
1436
  obj.ptr = ptr;
1492
-
1493
1437
  return obj;
1494
1438
  }
1495
-
1496
1439
  __destroy_into_raw() {
1497
1440
  const ptr = this.ptr;
1498
1441
  this.ptr = 0;
1499
-
1500
1442
  return ptr;
1501
1443
  }
1502
-
1503
1444
  free() {
1504
1445
  const ptr = this.__destroy_into_raw();
1505
1446
  wasm$1.__wbg_customconfiguration_free(ptr);
@@ -1517,14 +1458,11 @@ class CustomConfiguration {
1517
1458
  * see [core_crypto::prelude::decrypt::MlsConversationDecryptMessage]
1518
1459
  */
1519
1460
  class DecryptedMessage {
1520
-
1521
1461
  __destroy_into_raw() {
1522
1462
  const ptr = this.ptr;
1523
1463
  this.ptr = 0;
1524
-
1525
1464
  return ptr;
1526
1465
  }
1527
-
1528
1466
  free() {
1529
1467
  const ptr = this.__destroy_into_raw();
1530
1468
  wasm$1.__wbg_decryptedmessage_free(ptr);
@@ -1560,7 +1498,8 @@ class DecryptedMessage {
1560
1498
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1561
1499
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1562
1500
  return r0 === 0 ? undefined : r1 >>> 0;
1563
- } finally {
1501
+ }
1502
+ finally {
1564
1503
  wasm$1.__wbindgen_add_to_stack_pointer(16);
1565
1504
  }
1566
1505
  }
@@ -1580,346 +1519,131 @@ class DecryptedMessage {
1580
1519
  }
1581
1520
  }
1582
1521
  /**
1583
- * see [core_crypto::prelude::ConversationMember]
1584
1522
  */
1585
- class Invitee {
1586
-
1523
+ class FfiWireE2EIdentity {
1587
1524
  static __wrap(ptr) {
1588
- const obj = Object.create(Invitee.prototype);
1525
+ const obj = Object.create(FfiWireE2EIdentity.prototype);
1589
1526
  obj.ptr = ptr;
1590
-
1591
1527
  return obj;
1592
1528
  }
1593
-
1594
1529
  __destroy_into_raw() {
1595
1530
  const ptr = this.ptr;
1596
1531
  this.ptr = 0;
1597
-
1598
1532
  return ptr;
1599
1533
  }
1600
-
1601
1534
  free() {
1602
1535
  const ptr = this.__destroy_into_raw();
1603
- wasm$1.__wbg_invitee_free(ptr);
1536
+ wasm$1.__wbg_ffiwiree2eidentity_free(ptr);
1604
1537
  }
1605
1538
  /**
1606
- * @param {Uint8Array} id
1607
- * @param {Uint8Array} kp
1539
+ * See [core_crypto::e2e_identity::WireE2eIdentity::directory_response]
1540
+ * @param {Uint8Array} directory
1541
+ * @returns {any}
1608
1542
  */
1609
- constructor(id, kp) {
1610
- const ret = wasm$1.invitee_new(addHeapObject(id), addHeapObject(kp));
1611
- return Invitee.__wrap(ret);
1543
+ directory_response(directory) {
1544
+ try {
1545
+ const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
1546
+ const ptr0 = passArray8ToWasm0(directory, wasm$1.__wbindgen_malloc);
1547
+ const len0 = WASM_VECTOR_LEN;
1548
+ wasm$1.ffiwiree2eidentity_directory_response(retptr, this.ptr, ptr0, len0);
1549
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
1550
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
1551
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
1552
+ if (r2) {
1553
+ throw takeObject(r1);
1554
+ }
1555
+ return takeObject(r0);
1556
+ }
1557
+ finally {
1558
+ wasm$1.__wbindgen_add_to_stack_pointer(16);
1559
+ }
1612
1560
  }
1613
1561
  /**
1562
+ * See [core_crypto::e2e_identity::WireE2eIdentity::new_account_request]
1563
+ * @param {any} directory
1564
+ * @param {string} previous_nonce
1614
1565
  * @returns {Uint8Array}
1615
1566
  */
1616
- get id() {
1617
- const ret = wasm$1.commitbundle_commit(this.ptr);
1618
- return takeObject(ret);
1567
+ new_account_request(directory, previous_nonce) {
1568
+ try {
1569
+ const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
1570
+ const ptr0 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
1571
+ const len0 = WASM_VECTOR_LEN;
1572
+ wasm$1.ffiwiree2eidentity_new_account_request(retptr, this.ptr, addHeapObject(directory), ptr0, len0);
1573
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
1574
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
1575
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
1576
+ if (r2) {
1577
+ throw takeObject(r1);
1578
+ }
1579
+ return takeObject(r0);
1580
+ }
1581
+ finally {
1582
+ wasm$1.__wbindgen_add_to_stack_pointer(16);
1583
+ }
1619
1584
  }
1620
1585
  /**
1586
+ * See [core_crypto::e2e_identity::WireE2eIdentity::new_account_response]
1587
+ * @param {Uint8Array} account
1621
1588
  * @returns {Uint8Array}
1622
1589
  */
1623
- get kp() {
1624
- const ret = wasm$1.conversationinitbundle_commit(this.ptr);
1625
- return takeObject(ret);
1626
- }
1627
- }
1628
- /**
1629
- * see [core_crypto::prelude::MlsConversationCreationMessage]
1630
- */
1631
- class MemberAddedMessages {
1632
-
1633
- static __wrap(ptr) {
1634
- const obj = Object.create(MemberAddedMessages.prototype);
1635
- obj.ptr = ptr;
1636
-
1637
- return obj;
1638
- }
1639
-
1640
- __destroy_into_raw() {
1641
- const ptr = this.ptr;
1642
- this.ptr = 0;
1643
-
1644
- return ptr;
1645
- }
1646
-
1647
- free() {
1648
- const ptr = this.__destroy_into_raw();
1649
- wasm$1.__wbg_memberaddedmessages_free(ptr);
1650
- }
1651
- /**
1652
- * @param {Uint8Array} welcome
1653
- * @param {Uint8Array} commit
1654
- * @param {PublicGroupStateBundle} public_group_state
1655
- */
1656
- constructor(welcome, commit, public_group_state) {
1657
- _assertClass(public_group_state, PublicGroupStateBundle);
1658
- var ptr0 = public_group_state.ptr;
1659
- public_group_state.ptr = 0;
1660
- const ret = wasm$1.memberaddedmessages_new(addHeapObject(welcome), addHeapObject(commit), ptr0);
1661
- return MemberAddedMessages.__wrap(ret);
1662
- }
1663
- /**
1664
- * @returns {Uint8Array}
1665
- */
1666
- get welcome() {
1667
- const ret = wasm$1.commitbundle_commit(this.ptr);
1668
- return takeObject(ret);
1590
+ new_account_response(account) {
1591
+ try {
1592
+ const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
1593
+ wasm$1.ffiwiree2eidentity_new_account_response(retptr, this.ptr, addHeapObject(account));
1594
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
1595
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
1596
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
1597
+ if (r2) {
1598
+ throw takeObject(r1);
1599
+ }
1600
+ return takeObject(r0);
1601
+ }
1602
+ finally {
1603
+ wasm$1.__wbindgen_add_to_stack_pointer(16);
1604
+ }
1669
1605
  }
1670
1606
  /**
1607
+ * See [core_crypto::e2e_identity::WireE2eIdentity::new_order_request]
1608
+ * @param {string} handle
1609
+ * @param {string} client_id
1610
+ * @param {number} expiry_days
1611
+ * @param {any} directory
1612
+ * @param {Uint8Array} account
1613
+ * @param {string} previous_nonce
1671
1614
  * @returns {Uint8Array}
1672
1615
  */
1673
- get commit() {
1674
- const ret = wasm$1.conversationinitbundle_commit(this.ptr);
1675
- return takeObject(ret);
1676
- }
1677
- /**
1678
- * @returns {PublicGroupStateBundle}
1679
- */
1680
- get public_group_state() {
1681
- const ret = wasm$1.commitbundle_public_group_state(this.ptr);
1682
- return PublicGroupStateBundle.__wrap(ret);
1683
- }
1684
- }
1685
- /**
1686
- * See [core_crypto::e2e_identity::types::E2eiNewAcmeAuthz]
1687
- */
1688
- class NewAcmeAuthz {
1689
-
1690
- static __wrap(ptr) {
1691
- const obj = Object.create(NewAcmeAuthz.prototype);
1692
- obj.ptr = ptr;
1693
-
1694
- return obj;
1695
- }
1696
-
1697
- __destroy_into_raw() {
1698
- const ptr = this.ptr;
1699
- this.ptr = 0;
1700
-
1701
- return ptr;
1702
- }
1703
-
1704
- free() {
1705
- const ptr = this.__destroy_into_raw();
1706
- wasm$1.__wbg_newacmeauthz_free(ptr);
1707
- }
1708
- /**
1709
- * @param {string} identifier
1710
- * @param {AcmeChallenge | undefined} wire_http_challenge
1711
- * @param {AcmeChallenge | undefined} wire_oidc_challenge
1712
- */
1713
- constructor(identifier, wire_http_challenge, wire_oidc_challenge) {
1714
- const ptr0 = passStringToWasm0(identifier, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
1715
- const len0 = WASM_VECTOR_LEN;
1716
- let ptr1 = 0;
1717
- if (!isLikeNone(wire_http_challenge)) {
1718
- _assertClass(wire_http_challenge, AcmeChallenge);
1719
- ptr1 = wire_http_challenge.ptr;
1720
- wire_http_challenge.ptr = 0;
1721
- }
1722
- let ptr2 = 0;
1723
- if (!isLikeNone(wire_oidc_challenge)) {
1724
- _assertClass(wire_oidc_challenge, AcmeChallenge);
1725
- ptr2 = wire_oidc_challenge.ptr;
1726
- wire_oidc_challenge.ptr = 0;
1727
- }
1728
- const ret = wasm$1.newacmeauthz_new(ptr0, len0, ptr1, ptr2);
1729
- return NewAcmeAuthz.__wrap(ret);
1730
- }
1731
- /**
1732
- * @returns {string}
1733
- */
1734
- get identifier() {
1616
+ new_order_request(handle, client_id, expiry_days, directory, account, previous_nonce) {
1735
1617
  try {
1736
1618
  const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
1737
- wasm$1.acmedirectory_new_nonce(retptr, this.ptr);
1619
+ const ptr0 = passStringToWasm0(handle, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
1620
+ const len0 = WASM_VECTOR_LEN;
1621
+ const ptr1 = passStringToWasm0(client_id, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
1622
+ const len1 = WASM_VECTOR_LEN;
1623
+ const ptr2 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
1624
+ const len2 = WASM_VECTOR_LEN;
1625
+ wasm$1.ffiwiree2eidentity_new_order_request(retptr, this.ptr, ptr0, len0, ptr1, len1, expiry_days, addHeapObject(directory), addHeapObject(account), ptr2, len2);
1738
1626
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1739
1627
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1740
- return getStringFromWasm0(r0, r1);
1741
- } finally {
1628
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
1629
+ if (r2) {
1630
+ throw takeObject(r1);
1631
+ }
1632
+ return takeObject(r0);
1633
+ }
1634
+ finally {
1742
1635
  wasm$1.__wbindgen_add_to_stack_pointer(16);
1743
- wasm$1.__wbindgen_free(r0, r1);
1744
1636
  }
1745
1637
  }
1746
1638
  /**
1747
- * @returns {AcmeChallenge | undefined}
1748
- */
1749
- get wire_http_challenge() {
1750
- const ret = wasm$1.newacmeauthz_wire_http_challenge(this.ptr);
1751
- return ret === 0 ? undefined : AcmeChallenge.__wrap(ret);
1752
- }
1753
- /**
1754
- * @returns {AcmeChallenge | undefined}
1755
- */
1756
- get wire_oidc_challenge() {
1757
- const ret = wasm$1.newacmeauthz_wire_oidc_challenge(this.ptr);
1758
- return ret === 0 ? undefined : AcmeChallenge.__wrap(ret);
1759
- }
1760
- }
1761
- /**
1762
- * See [core_crypto::e2e_identity::types::E2eiNewAcmeOrder]
1763
- */
1764
- class NewAcmeOrder {
1765
-
1766
- static __wrap(ptr) {
1767
- const obj = Object.create(NewAcmeOrder.prototype);
1768
- obj.ptr = ptr;
1769
-
1770
- return obj;
1771
- }
1772
-
1773
- __destroy_into_raw() {
1774
- const ptr = this.ptr;
1775
- this.ptr = 0;
1776
-
1777
- return ptr;
1778
- }
1779
-
1780
- free() {
1781
- const ptr = this.__destroy_into_raw();
1782
- wasm$1.__wbg_newacmeorder_free(ptr);
1783
- }
1784
- /**
1785
- * @param {Uint8Array} delegate
1786
- * @param {(Uint8Array)[]} authorizations
1787
- */
1788
- constructor(delegate, authorizations) {
1789
- const ptr0 = passArrayJsValueToWasm0(authorizations, wasm$1.__wbindgen_malloc);
1790
- const len0 = WASM_VECTOR_LEN;
1791
- const ret = wasm$1.newacmeorder_new(addHeapObject(delegate), ptr0, len0);
1792
- return NewAcmeOrder.__wrap(ret);
1793
- }
1794
- /**
1795
- * @returns {Uint8Array}
1796
- */
1797
- get delegate() {
1798
- const ret = wasm$1.acmechallenge_delegate(this.ptr);
1799
- return takeObject(ret);
1800
- }
1801
- /**
1802
- * @returns {Array<any>}
1803
- */
1804
- get authorizations() {
1805
- const ret = wasm$1.newacmeorder_authorizations(this.ptr);
1806
- return takeObject(ret);
1807
- }
1808
- }
1809
- /**
1810
- */
1811
- class ProposalBundle {
1812
-
1813
- static __wrap(ptr) {
1814
- const obj = Object.create(ProposalBundle.prototype);
1815
- obj.ptr = ptr;
1816
-
1817
- return obj;
1818
- }
1819
-
1820
- __destroy_into_raw() {
1821
- const ptr = this.ptr;
1822
- this.ptr = 0;
1823
-
1824
- return ptr;
1825
- }
1826
-
1827
- free() {
1828
- const ptr = this.__destroy_into_raw();
1829
- wasm$1.__wbg_proposalbundle_free(ptr);
1830
- }
1831
- /**
1832
- * @returns {Uint8Array}
1833
- */
1834
- get proposal() {
1835
- const ret = wasm$1.commitbundle_commit(this.ptr);
1836
- return takeObject(ret);
1837
- }
1838
- /**
1839
- * @returns {Uint8Array}
1840
- */
1841
- get proposal_ref() {
1842
- const ret = wasm$1.conversationinitbundle_commit(this.ptr);
1843
- return takeObject(ret);
1844
- }
1845
- }
1846
- /**
1847
- */
1848
- class PublicGroupStateBundle {
1849
-
1850
- static __wrap(ptr) {
1851
- const obj = Object.create(PublicGroupStateBundle.prototype);
1852
- obj.ptr = ptr;
1853
-
1854
- return obj;
1855
- }
1856
-
1857
- __destroy_into_raw() {
1858
- const ptr = this.ptr;
1859
- this.ptr = 0;
1860
-
1861
- return ptr;
1862
- }
1863
-
1864
- free() {
1865
- const ptr = this.__destroy_into_raw();
1866
- wasm$1.__wbg_publicgroupstatebundle_free(ptr);
1867
- }
1868
- /**
1869
- * @returns {number}
1870
- */
1871
- get encryption_type() {
1872
- const ret = wasm$1.publicgroupstatebundle_encryption_type(this.ptr);
1873
- return ret;
1874
- }
1875
- /**
1876
- * @returns {number}
1877
- */
1878
- get ratchet_tree_type() {
1879
- const ret = wasm$1.publicgroupstatebundle_ratchet_tree_type(this.ptr);
1880
- return ret;
1881
- }
1882
- /**
1883
- * @returns {Uint8Array}
1884
- */
1885
- get payload() {
1886
- const ret = wasm$1.commitbundle_commit(this.ptr);
1887
- return takeObject(ret);
1888
- }
1889
- }
1890
- /**
1891
- */
1892
- class WireE2eIdentity$1 {
1893
-
1894
- static __wrap(ptr) {
1895
- const obj = Object.create(WireE2eIdentity$1.prototype);
1896
- obj.ptr = ptr;
1897
-
1898
- return obj;
1899
- }
1900
-
1901
- __destroy_into_raw() {
1902
- const ptr = this.ptr;
1903
- this.ptr = 0;
1904
-
1905
- return ptr;
1906
- }
1907
-
1908
- free() {
1909
- const ptr = this.__destroy_into_raw();
1910
- wasm$1.__wbg_wiree2eidentity_free(ptr);
1911
- }
1912
- /**
1913
- * See [core_crypto::e2e_identity::WireE2eIdentity::directory_response]
1914
- * @param {Uint8Array} directory
1639
+ * See [core_crypto::e2e_identity::WireE2eIdentity::new_order_response]
1640
+ * @param {Uint8Array} order
1915
1641
  * @returns {any}
1916
1642
  */
1917
- directory_response(directory) {
1643
+ new_order_response(order) {
1918
1644
  try {
1919
1645
  const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
1920
- const ptr0 = passArray8ToWasm0(directory, wasm$1.__wbindgen_malloc);
1921
- const len0 = WASM_VECTOR_LEN;
1922
- wasm$1.wiree2eidentity_directory_response(retptr, this.ptr, ptr0, len0);
1646
+ wasm$1.ffiwiree2eidentity_new_order_response(retptr, this.ptr, addHeapObject(order));
1923
1647
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1924
1648
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1925
1649
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1927,22 +1651,26 @@ class WireE2eIdentity$1 {
1927
1651
  throw takeObject(r1);
1928
1652
  }
1929
1653
  return takeObject(r0);
1930
- } finally {
1654
+ }
1655
+ finally {
1931
1656
  wasm$1.__wbindgen_add_to_stack_pointer(16);
1932
1657
  }
1933
1658
  }
1934
1659
  /**
1935
- * See [core_crypto::e2e_identity::WireE2eIdentity::new_account_request]
1936
- * @param {any} directory
1660
+ * See [core_crypto::e2e_identity::WireE2eIdentity::new_authz_request]
1661
+ * @param {string} url
1662
+ * @param {Uint8Array} account
1937
1663
  * @param {string} previous_nonce
1938
1664
  * @returns {Uint8Array}
1939
1665
  */
1940
- new_account_request(directory, previous_nonce) {
1666
+ new_authz_request(url, account, previous_nonce) {
1941
1667
  try {
1942
1668
  const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
1943
- const ptr0 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
1669
+ const ptr0 = passStringToWasm0(url, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
1944
1670
  const len0 = WASM_VECTOR_LEN;
1945
- wasm$1.wiree2eidentity_new_account_request(retptr, this.ptr, addHeapObject(directory), ptr0, len0);
1671
+ const ptr1 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
1672
+ const len1 = WASM_VECTOR_LEN;
1673
+ wasm$1.ffiwiree2eidentity_new_authz_request(retptr, this.ptr, ptr0, len0, addHeapObject(account), ptr1, len1);
1946
1674
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1947
1675
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1948
1676
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1950,19 +1678,20 @@ class WireE2eIdentity$1 {
1950
1678
  throw takeObject(r1);
1951
1679
  }
1952
1680
  return takeObject(r0);
1953
- } finally {
1681
+ }
1682
+ finally {
1954
1683
  wasm$1.__wbindgen_add_to_stack_pointer(16);
1955
1684
  }
1956
1685
  }
1957
1686
  /**
1958
- * See [core_crypto::e2e_identity::WireE2eIdentity::new_account_response]
1959
- * @param {Uint8Array} account
1960
- * @returns {Uint8Array}
1687
+ * See [core_crypto::e2e_identity::WireE2eIdentity::new_authz_response]
1688
+ * @param {Uint8Array} authz
1689
+ * @returns {any}
1961
1690
  */
1962
- new_account_response(account) {
1691
+ new_authz_response(authz) {
1963
1692
  try {
1964
1693
  const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
1965
- wasm$1.wiree2eidentity_new_account_response(retptr, this.ptr, addHeapObject(account));
1694
+ wasm$1.ffiwiree2eidentity_new_authz_response(retptr, this.ptr, addHeapObject(authz));
1966
1695
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1967
1696
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1968
1697
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1970,50 +1699,65 @@ class WireE2eIdentity$1 {
1970
1699
  throw takeObject(r1);
1971
1700
  }
1972
1701
  return takeObject(r0);
1973
- } finally {
1702
+ }
1703
+ finally {
1974
1704
  wasm$1.__wbindgen_add_to_stack_pointer(16);
1975
1705
  }
1976
1706
  }
1977
1707
  /**
1978
- * See [core_crypto::e2e_identity::WireE2eIdentity::new_order_request]
1979
- * @param {string} handle
1980
- * @param {string} client_id
1708
+ * See [core_crypto::e2e_identity::WireE2eIdentity::create_dpop_token]
1709
+ * @param {string} access_token_url
1710
+ * @param {string} user_id
1711
+ * @param {bigint} client_id
1712
+ * @param {string} domain
1713
+ * @param {any} client_id_challenge
1714
+ * @param {string} backend_nonce
1981
1715
  * @param {number} expiry_days
1982
- * @param {any} directory
1983
- * @param {Uint8Array} account
1984
- * @param {string} previous_nonce
1985
- * @returns {Uint8Array}
1716
+ * @returns {string}
1986
1717
  */
1987
- new_order_request(handle, client_id, expiry_days, directory, account, previous_nonce) {
1718
+ create_dpop_token(access_token_url, user_id, client_id, domain, client_id_challenge, backend_nonce, expiry_days) {
1988
1719
  try {
1989
1720
  const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
1990
- const ptr0 = passStringToWasm0(handle, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
1721
+ const ptr0 = passStringToWasm0(access_token_url, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
1991
1722
  const len0 = WASM_VECTOR_LEN;
1992
- const ptr1 = passStringToWasm0(client_id, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
1723
+ const ptr1 = passStringToWasm0(user_id, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
1993
1724
  const len1 = WASM_VECTOR_LEN;
1994
- const ptr2 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
1725
+ const ptr2 = passStringToWasm0(domain, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
1995
1726
  const len2 = WASM_VECTOR_LEN;
1996
- wasm$1.wiree2eidentity_new_order_request(retptr, this.ptr, ptr0, len0, ptr1, len1, expiry_days, addHeapObject(directory), addHeapObject(account), ptr2, len2);
1727
+ const ptr3 = passStringToWasm0(backend_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
1728
+ const len3 = WASM_VECTOR_LEN;
1729
+ wasm$1.ffiwiree2eidentity_create_dpop_token(retptr, this.ptr, ptr0, len0, ptr1, len1, client_id, ptr2, len2, addHeapObject(client_id_challenge), ptr3, len3, expiry_days);
1997
1730
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1998
1731
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1999
1732
  var r2 = getInt32Memory0()[retptr / 4 + 2];
2000
- if (r2) {
2001
- throw takeObject(r1);
1733
+ var r3 = getInt32Memory0()[retptr / 4 + 3];
1734
+ var ptr4 = r0;
1735
+ var len4 = r1;
1736
+ if (r3) {
1737
+ ptr4 = 0;
1738
+ len4 = 0;
1739
+ throw takeObject(r2);
2002
1740
  }
2003
- return takeObject(r0);
2004
- } finally {
1741
+ return getStringFromWasm0(ptr4, len4);
1742
+ }
1743
+ finally {
2005
1744
  wasm$1.__wbindgen_add_to_stack_pointer(16);
1745
+ wasm$1.__wbindgen_free(ptr4, len4);
2006
1746
  }
2007
1747
  }
2008
1748
  /**
2009
- * See [core_crypto::e2e_identity::WireE2eIdentity::new_order_response]
2010
- * @param {Uint8Array} order
2011
- * @returns {any}
1749
+ * See [core_crypto::e2e_identity::WireE2eIdentity::new_challenge_request]
1750
+ * @param {any} handle_challenge
1751
+ * @param {Uint8Array} account
1752
+ * @param {string} previous_nonce
1753
+ * @returns {Uint8Array}
2012
1754
  */
2013
- new_order_response(order) {
1755
+ new_challenge_request(handle_challenge, account, previous_nonce) {
2014
1756
  try {
2015
1757
  const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
2016
- wasm$1.wiree2eidentity_new_order_response(retptr, this.ptr, addHeapObject(order));
1758
+ const ptr0 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
1759
+ const len0 = WASM_VECTOR_LEN;
1760
+ wasm$1.ffiwiree2eidentity_new_challenge_request(retptr, this.ptr, addHeapObject(handle_challenge), addHeapObject(account), ptr0, len0);
2017
1761
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2018
1762
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2019
1763
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -2021,25 +1765,44 @@ class WireE2eIdentity$1 {
2021
1765
  throw takeObject(r1);
2022
1766
  }
2023
1767
  return takeObject(r0);
2024
- } finally {
1768
+ }
1769
+ finally {
2025
1770
  wasm$1.__wbindgen_add_to_stack_pointer(16);
2026
1771
  }
2027
1772
  }
2028
1773
  /**
2029
- * See [core_crypto::e2e_identity::WireE2eIdentity::new_authz_request]
2030
- * @param {string} url
1774
+ * See [core_crypto::e2e_identity::WireE2eIdentity::new_challenge_response]
1775
+ * @param {Uint8Array} challenge
1776
+ */
1777
+ new_challenge_response(challenge) {
1778
+ try {
1779
+ const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
1780
+ wasm$1.ffiwiree2eidentity_new_challenge_response(retptr, this.ptr, addHeapObject(challenge));
1781
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
1782
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
1783
+ if (r1) {
1784
+ throw takeObject(r0);
1785
+ }
1786
+ }
1787
+ finally {
1788
+ wasm$1.__wbindgen_add_to_stack_pointer(16);
1789
+ }
1790
+ }
1791
+ /**
1792
+ * See [core_crypto::e2e_identity::WireE2eIdentity::check_order_request]
1793
+ * @param {string} order_url
2031
1794
  * @param {Uint8Array} account
2032
1795
  * @param {string} previous_nonce
2033
1796
  * @returns {Uint8Array}
2034
1797
  */
2035
- new_authz_request(url, account, previous_nonce) {
1798
+ check_order_request(order_url, account, previous_nonce) {
2036
1799
  try {
2037
1800
  const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
2038
- const ptr0 = passStringToWasm0(url, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
1801
+ const ptr0 = passStringToWasm0(order_url, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
2039
1802
  const len0 = WASM_VECTOR_LEN;
2040
1803
  const ptr1 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
2041
1804
  const len1 = WASM_VECTOR_LEN;
2042
- wasm$1.wiree2eidentity_new_authz_request(retptr, this.ptr, ptr0, len0, addHeapObject(account), ptr1, len1);
1805
+ wasm$1.ffiwiree2eidentity_check_order_request(retptr, this.ptr, ptr0, len0, addHeapObject(account), ptr1, len1);
2043
1806
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2044
1807
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2045
1808
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -2047,19 +1810,20 @@ class WireE2eIdentity$1 {
2047
1810
  throw takeObject(r1);
2048
1811
  }
2049
1812
  return takeObject(r0);
2050
- } finally {
1813
+ }
1814
+ finally {
2051
1815
  wasm$1.__wbindgen_add_to_stack_pointer(16);
2052
1816
  }
2053
1817
  }
2054
1818
  /**
2055
- * See [core_crypto::e2e_identity::WireE2eIdentity::new_authz_response]
2056
- * @param {Uint8Array} authz
2057
- * @returns {any}
1819
+ * See [core_crypto::e2e_identity::WireE2eIdentity::check_order_response]
1820
+ * @param {Uint8Array} order
1821
+ * @returns {Uint8Array}
2058
1822
  */
2059
- new_authz_response(authz) {
1823
+ check_order_response(order) {
2060
1824
  try {
2061
1825
  const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
2062
- wasm$1.wiree2eidentity_new_authz_response(retptr, this.ptr, addHeapObject(authz));
1826
+ wasm$1.ffiwiree2eidentity_check_order_response(retptr, this.ptr, addHeapObject(order));
2063
1827
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2064
1828
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2065
1829
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -2067,62 +1831,73 @@ class WireE2eIdentity$1 {
2067
1831
  throw takeObject(r1);
2068
1832
  }
2069
1833
  return takeObject(r0);
2070
- } finally {
1834
+ }
1835
+ finally {
2071
1836
  wasm$1.__wbindgen_add_to_stack_pointer(16);
2072
1837
  }
2073
1838
  }
2074
1839
  /**
2075
- * See [core_crypto::e2e_identity::WireE2eIdentity::create_dpop_token]
2076
- * @param {string} access_token_url
2077
- * @param {string} user_id
2078
- * @param {bigint} client_id
2079
- * @param {string} domain
2080
- * @param {any} client_id_challenge
2081
- * @param {string} backend_nonce
2082
- * @param {number} expiry_days
2083
- * @returns {string}
1840
+ * See [core_crypto::e2e_identity::WireE2eIdentity::finalize_request]
1841
+ * @param {(Uint8Array)[]} domains
1842
+ * @param {Uint8Array} order
1843
+ * @param {Uint8Array} account
1844
+ * @param {string} previous_nonce
1845
+ * @returns {Uint8Array}
1846
+ */
1847
+ finalize_request(domains, order, account, previous_nonce) {
1848
+ try {
1849
+ const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
1850
+ const ptr0 = passArrayJsValueToWasm0(domains, wasm$1.__wbindgen_malloc);
1851
+ const len0 = WASM_VECTOR_LEN;
1852
+ const ptr1 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
1853
+ const len1 = WASM_VECTOR_LEN;
1854
+ wasm$1.ffiwiree2eidentity_finalize_request(retptr, this.ptr, ptr0, len0, addHeapObject(order), addHeapObject(account), ptr1, len1);
1855
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
1856
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
1857
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
1858
+ if (r2) {
1859
+ throw takeObject(r1);
1860
+ }
1861
+ return takeObject(r0);
1862
+ }
1863
+ finally {
1864
+ wasm$1.__wbindgen_add_to_stack_pointer(16);
1865
+ }
1866
+ }
1867
+ /**
1868
+ * See [core_crypto::e2e_identity::WireE2eIdentity::finalize_response]
1869
+ * @param {Uint8Array} finalize
1870
+ * @returns {any}
2084
1871
  */
2085
- create_dpop_token(access_token_url, user_id, client_id, domain, client_id_challenge, backend_nonce, expiry_days) {
1872
+ finalize_response(finalize) {
2086
1873
  try {
2087
1874
  const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
2088
- const ptr0 = passStringToWasm0(access_token_url, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
2089
- const len0 = WASM_VECTOR_LEN;
2090
- const ptr1 = passStringToWasm0(user_id, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
2091
- const len1 = WASM_VECTOR_LEN;
2092
- const ptr2 = passStringToWasm0(domain, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
2093
- const len2 = WASM_VECTOR_LEN;
2094
- const ptr3 = passStringToWasm0(backend_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
2095
- const len3 = WASM_VECTOR_LEN;
2096
- wasm$1.wiree2eidentity_create_dpop_token(retptr, this.ptr, ptr0, len0, ptr1, len1, client_id, ptr2, len2, addHeapObject(client_id_challenge), ptr3, len3, expiry_days);
1875
+ wasm$1.ffiwiree2eidentity_finalize_response(retptr, this.ptr, addHeapObject(finalize));
2097
1876
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2098
1877
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2099
1878
  var r2 = getInt32Memory0()[retptr / 4 + 2];
2100
- var r3 = getInt32Memory0()[retptr / 4 + 3];
2101
- var ptr4 = r0;
2102
- var len4 = r1;
2103
- if (r3) {
2104
- ptr4 = 0; len4 = 0;
2105
- throw takeObject(r2);
1879
+ if (r2) {
1880
+ throw takeObject(r1);
2106
1881
  }
2107
- return getStringFromWasm0(ptr4, len4);
2108
- } finally {
1882
+ return takeObject(r0);
1883
+ }
1884
+ finally {
2109
1885
  wasm$1.__wbindgen_add_to_stack_pointer(16);
2110
- wasm$1.__wbindgen_free(ptr4, len4);
2111
1886
  }
2112
1887
  }
2113
1888
  /**
2114
- * See [core_crypto::e2e_identity::WireE2eIdentity::new_challenge_request]
2115
- * @param {any} handle_challenge
1889
+ * See [core_crypto::e2e_identity::WireE2eIdentity::certificate_request]
1890
+ * @param {any} finalize
2116
1891
  * @param {Uint8Array} account
2117
1892
  * @param {string} previous_nonce
2118
1893
  * @returns {Uint8Array}
2119
1894
  */
2120
- new_challenge_request(handle_challenge, account, previous_nonce) {
1895
+ certificate_request(finalize, account, previous_nonce) {
2121
1896
  try {
2122
1897
  const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
2123
1898
  const ptr0 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
2124
1899
  const len0 = WASM_VECTOR_LEN;
2125
- wasm$1.wiree2eidentity_new_challenge_request(retptr, this.ptr, addHeapObject(handle_challenge), addHeapObject(account), ptr0, len0);
1900
+ wasm$1.ffiwiree2eidentity_certificate_request(retptr, this.ptr, addHeapObject(finalize), addHeapObject(account), ptr0, len0);
2126
1901
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2127
1902
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2128
1903
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -2130,449 +1905,612 @@ class WireE2eIdentity$1 {
2130
1905
  throw takeObject(r1);
2131
1906
  }
2132
1907
  return takeObject(r0);
2133
- } finally {
1908
+ }
1909
+ finally {
2134
1910
  wasm$1.__wbindgen_add_to_stack_pointer(16);
2135
1911
  }
2136
1912
  }
2137
1913
  /**
2138
- * See [core_crypto::e2e_identity::WireE2eIdentity::new_challenge_response]
2139
- * @param {Uint8Array} challenge
1914
+ * See [core_crypto::e2e_identity::WireE2eIdentity::certificate_response]
1915
+ * @param {string} certificate_chain
1916
+ * @returns {(Uint8Array)[]}
2140
1917
  */
2141
- new_challenge_response(challenge) {
1918
+ certificate_response(certificate_chain) {
2142
1919
  try {
2143
1920
  const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
2144
- wasm$1.wiree2eidentity_new_challenge_response(retptr, this.ptr, addHeapObject(challenge));
1921
+ const ptr0 = passStringToWasm0(certificate_chain, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
1922
+ const len0 = WASM_VECTOR_LEN;
1923
+ wasm$1.ffiwiree2eidentity_certificate_response(retptr, this.ptr, ptr0, len0);
2145
1924
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2146
1925
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2147
- if (r1) {
2148
- throw takeObject(r0);
1926
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
1927
+ var r3 = getInt32Memory0()[retptr / 4 + 3];
1928
+ if (r3) {
1929
+ throw takeObject(r2);
2149
1930
  }
2150
- } finally {
1931
+ var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
1932
+ wasm$1.__wbindgen_free(r0, r1 * 4);
1933
+ return v1;
1934
+ }
1935
+ finally {
2151
1936
  wasm$1.__wbindgen_add_to_stack_pointer(16);
2152
1937
  }
2153
1938
  }
1939
+ }
1940
+ /**
1941
+ * see [core_crypto::prelude::ConversationMember]
1942
+ */
1943
+ class Invitee {
1944
+ static __wrap(ptr) {
1945
+ const obj = Object.create(Invitee.prototype);
1946
+ obj.ptr = ptr;
1947
+ return obj;
1948
+ }
1949
+ __destroy_into_raw() {
1950
+ const ptr = this.ptr;
1951
+ this.ptr = 0;
1952
+ return ptr;
1953
+ }
1954
+ free() {
1955
+ const ptr = this.__destroy_into_raw();
1956
+ wasm$1.__wbg_invitee_free(ptr);
1957
+ }
1958
+ /**
1959
+ * @param {Uint8Array} id
1960
+ * @param {Uint8Array} kp
1961
+ */
1962
+ constructor(id, kp) {
1963
+ const ret = wasm$1.invitee_new(addHeapObject(id), addHeapObject(kp));
1964
+ return Invitee.__wrap(ret);
1965
+ }
2154
1966
  /**
2155
- * See [core_crypto::e2e_identity::WireE2eIdentity::check_order_request]
2156
- * @param {string} order_url
2157
- * @param {Uint8Array} account
2158
- * @param {string} previous_nonce
2159
1967
  * @returns {Uint8Array}
2160
1968
  */
2161
- check_order_request(order_url, account, previous_nonce) {
1969
+ get id() {
1970
+ const ret = wasm$1.invitee_id(this.ptr);
1971
+ return takeObject(ret);
1972
+ }
1973
+ /**
1974
+ * @returns {Uint8Array}
1975
+ */
1976
+ get kp() {
1977
+ const ret = wasm$1.invitee_kp(this.ptr);
1978
+ return takeObject(ret);
1979
+ }
1980
+ }
1981
+ /**
1982
+ * see [core_crypto::prelude::MlsConversationCreationMessage]
1983
+ */
1984
+ class MemberAddedMessages {
1985
+ static __wrap(ptr) {
1986
+ const obj = Object.create(MemberAddedMessages.prototype);
1987
+ obj.ptr = ptr;
1988
+ return obj;
1989
+ }
1990
+ __destroy_into_raw() {
1991
+ const ptr = this.ptr;
1992
+ this.ptr = 0;
1993
+ return ptr;
1994
+ }
1995
+ free() {
1996
+ const ptr = this.__destroy_into_raw();
1997
+ wasm$1.__wbg_memberaddedmessages_free(ptr);
1998
+ }
1999
+ /**
2000
+ * @param {Uint8Array} welcome
2001
+ * @param {Uint8Array} commit
2002
+ * @param {PublicGroupStateBundle} public_group_state
2003
+ */
2004
+ constructor(welcome, commit, public_group_state) {
2005
+ _assertClass(public_group_state, PublicGroupStateBundle);
2006
+ var ptr0 = public_group_state.__destroy_into_raw();
2007
+ const ret = wasm$1.memberaddedmessages_new(addHeapObject(welcome), addHeapObject(commit), ptr0);
2008
+ return MemberAddedMessages.__wrap(ret);
2009
+ }
2010
+ /**
2011
+ * @returns {Uint8Array}
2012
+ */
2013
+ get welcome() {
2014
+ const ret = wasm$1.conversationinitbundle_conversation_id(this.ptr);
2015
+ return takeObject(ret);
2016
+ }
2017
+ /**
2018
+ * @returns {Uint8Array}
2019
+ */
2020
+ get commit() {
2021
+ const ret = wasm$1.commitbundle_commit(this.ptr);
2022
+ return takeObject(ret);
2023
+ }
2024
+ /**
2025
+ * @returns {PublicGroupStateBundle}
2026
+ */
2027
+ get public_group_state() {
2028
+ const ret = wasm$1.commitbundle_public_group_state(this.ptr);
2029
+ return PublicGroupStateBundle.__wrap(ret);
2030
+ }
2031
+ }
2032
+ /**
2033
+ * See [core_crypto::e2e_identity::types::E2eiNewAcmeAuthz]
2034
+ */
2035
+ class NewAcmeAuthz {
2036
+ static __wrap(ptr) {
2037
+ const obj = Object.create(NewAcmeAuthz.prototype);
2038
+ obj.ptr = ptr;
2039
+ return obj;
2040
+ }
2041
+ __destroy_into_raw() {
2042
+ const ptr = this.ptr;
2043
+ this.ptr = 0;
2044
+ return ptr;
2045
+ }
2046
+ free() {
2047
+ const ptr = this.__destroy_into_raw();
2048
+ wasm$1.__wbg_newacmeauthz_free(ptr);
2049
+ }
2050
+ /**
2051
+ * @param {string} identifier
2052
+ * @param {AcmeChallenge | undefined} wire_http_challenge
2053
+ * @param {AcmeChallenge | undefined} wire_oidc_challenge
2054
+ */
2055
+ constructor(identifier, wire_http_challenge, wire_oidc_challenge) {
2056
+ const ptr0 = passStringToWasm0(identifier, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
2057
+ const len0 = WASM_VECTOR_LEN;
2058
+ let ptr1 = 0;
2059
+ if (!isLikeNone(wire_http_challenge)) {
2060
+ _assertClass(wire_http_challenge, AcmeChallenge);
2061
+ ptr1 = wire_http_challenge.__destroy_into_raw();
2062
+ }
2063
+ let ptr2 = 0;
2064
+ if (!isLikeNone(wire_oidc_challenge)) {
2065
+ _assertClass(wire_oidc_challenge, AcmeChallenge);
2066
+ ptr2 = wire_oidc_challenge.__destroy_into_raw();
2067
+ }
2068
+ const ret = wasm$1.newacmeauthz_new(ptr0, len0, ptr1, ptr2);
2069
+ return NewAcmeAuthz.__wrap(ret);
2070
+ }
2071
+ /**
2072
+ * @returns {string}
2073
+ */
2074
+ get identifier() {
2162
2075
  try {
2163
2076
  const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
2164
- const ptr0 = passStringToWasm0(order_url, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
2165
- const len0 = WASM_VECTOR_LEN;
2166
- const ptr1 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
2167
- const len1 = WASM_VECTOR_LEN;
2168
- wasm$1.wiree2eidentity_check_order_request(retptr, this.ptr, ptr0, len0, addHeapObject(account), ptr1, len1);
2077
+ wasm$1.newacmeauthz_identifier(retptr, this.ptr);
2169
2078
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2170
2079
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2171
- var r2 = getInt32Memory0()[retptr / 4 + 2];
2172
- if (r2) {
2173
- throw takeObject(r1);
2174
- }
2175
- return takeObject(r0);
2176
- } finally {
2080
+ return getStringFromWasm0(r0, r1);
2081
+ }
2082
+ finally {
2177
2083
  wasm$1.__wbindgen_add_to_stack_pointer(16);
2084
+ wasm$1.__wbindgen_free(r0, r1);
2178
2085
  }
2179
2086
  }
2180
2087
  /**
2181
- * See [core_crypto::e2e_identity::WireE2eIdentity::check_order_response]
2182
- * @param {Uint8Array} order
2088
+ * @returns {AcmeChallenge | undefined}
2089
+ */
2090
+ get wire_http_challenge() {
2091
+ const ret = wasm$1.newacmeauthz_wire_http_challenge(this.ptr);
2092
+ return ret === 0 ? undefined : AcmeChallenge.__wrap(ret);
2093
+ }
2094
+ /**
2095
+ * @returns {AcmeChallenge | undefined}
2096
+ */
2097
+ get wire_oidc_challenge() {
2098
+ const ret = wasm$1.newacmeauthz_wire_oidc_challenge(this.ptr);
2099
+ return ret === 0 ? undefined : AcmeChallenge.__wrap(ret);
2100
+ }
2101
+ }
2102
+ /**
2103
+ * See [core_crypto::e2e_identity::types::E2eiNewAcmeOrder]
2104
+ */
2105
+ class NewAcmeOrder {
2106
+ static __wrap(ptr) {
2107
+ const obj = Object.create(NewAcmeOrder.prototype);
2108
+ obj.ptr = ptr;
2109
+ return obj;
2110
+ }
2111
+ __destroy_into_raw() {
2112
+ const ptr = this.ptr;
2113
+ this.ptr = 0;
2114
+ return ptr;
2115
+ }
2116
+ free() {
2117
+ const ptr = this.__destroy_into_raw();
2118
+ wasm$1.__wbg_newacmeorder_free(ptr);
2119
+ }
2120
+ /**
2121
+ * @param {Uint8Array} delegate
2122
+ * @param {(Uint8Array)[]} authorizations
2123
+ */
2124
+ constructor(delegate, authorizations) {
2125
+ const ptr0 = passArrayJsValueToWasm0(authorizations, wasm$1.__wbindgen_malloc);
2126
+ const len0 = WASM_VECTOR_LEN;
2127
+ const ret = wasm$1.newacmeorder_new(addHeapObject(delegate), ptr0, len0);
2128
+ return NewAcmeOrder.__wrap(ret);
2129
+ }
2130
+ /**
2131
+ * @returns {Uint8Array}
2132
+ */
2133
+ get delegate() {
2134
+ const ret = wasm$1.acmechallenge_delegate(this.ptr);
2135
+ return takeObject(ret);
2136
+ }
2137
+ /**
2138
+ * @returns {Array<any>}
2139
+ */
2140
+ get authorizations() {
2141
+ const ret = wasm$1.newacmeorder_authorizations(this.ptr);
2142
+ return takeObject(ret);
2143
+ }
2144
+ }
2145
+ /**
2146
+ */
2147
+ class ProposalBundle {
2148
+ static __wrap(ptr) {
2149
+ const obj = Object.create(ProposalBundle.prototype);
2150
+ obj.ptr = ptr;
2151
+ return obj;
2152
+ }
2153
+ __destroy_into_raw() {
2154
+ const ptr = this.ptr;
2155
+ this.ptr = 0;
2156
+ return ptr;
2157
+ }
2158
+ free() {
2159
+ const ptr = this.__destroy_into_raw();
2160
+ wasm$1.__wbg_proposalbundle_free(ptr);
2161
+ }
2162
+ /**
2183
2163
  * @returns {Uint8Array}
2184
2164
  */
2185
- check_order_response(order) {
2186
- try {
2187
- const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
2188
- wasm$1.wiree2eidentity_check_order_response(retptr, this.ptr, addHeapObject(order));
2189
- var r0 = getInt32Memory0()[retptr / 4 + 0];
2190
- var r1 = getInt32Memory0()[retptr / 4 + 1];
2191
- var r2 = getInt32Memory0()[retptr / 4 + 2];
2192
- if (r2) {
2193
- throw takeObject(r1);
2194
- }
2195
- return takeObject(r0);
2196
- } finally {
2197
- wasm$1.__wbindgen_add_to_stack_pointer(16);
2198
- }
2165
+ get proposal() {
2166
+ const ret = wasm$1.invitee_id(this.ptr);
2167
+ return takeObject(ret);
2199
2168
  }
2200
2169
  /**
2201
- * See [core_crypto::e2e_identity::WireE2eIdentity::finalize_request]
2202
- * @param {(Uint8Array)[]} domains
2203
- * @param {Uint8Array} order
2204
- * @param {Uint8Array} account
2205
- * @param {string} previous_nonce
2206
2170
  * @returns {Uint8Array}
2207
2171
  */
2208
- finalize_request(domains, order, account, previous_nonce) {
2209
- try {
2210
- const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
2211
- const ptr0 = passArrayJsValueToWasm0(domains, wasm$1.__wbindgen_malloc);
2212
- const len0 = WASM_VECTOR_LEN;
2213
- const ptr1 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
2214
- const len1 = WASM_VECTOR_LEN;
2215
- wasm$1.wiree2eidentity_finalize_request(retptr, this.ptr, ptr0, len0, addHeapObject(order), addHeapObject(account), ptr1, len1);
2216
- var r0 = getInt32Memory0()[retptr / 4 + 0];
2217
- var r1 = getInt32Memory0()[retptr / 4 + 1];
2218
- var r2 = getInt32Memory0()[retptr / 4 + 2];
2219
- if (r2) {
2220
- throw takeObject(r1);
2221
- }
2222
- return takeObject(r0);
2223
- } finally {
2224
- wasm$1.__wbindgen_add_to_stack_pointer(16);
2225
- }
2172
+ get proposal_ref() {
2173
+ const ret = wasm$1.invitee_kp(this.ptr);
2174
+ return takeObject(ret);
2175
+ }
2176
+ }
2177
+ /**
2178
+ */
2179
+ class PublicGroupStateBundle {
2180
+ static __wrap(ptr) {
2181
+ const obj = Object.create(PublicGroupStateBundle.prototype);
2182
+ obj.ptr = ptr;
2183
+ return obj;
2184
+ }
2185
+ __destroy_into_raw() {
2186
+ const ptr = this.ptr;
2187
+ this.ptr = 0;
2188
+ return ptr;
2189
+ }
2190
+ free() {
2191
+ const ptr = this.__destroy_into_raw();
2192
+ wasm$1.__wbg_publicgroupstatebundle_free(ptr);
2226
2193
  }
2227
2194
  /**
2228
- * See [core_crypto::e2e_identity::WireE2eIdentity::finalize_response]
2229
- * @param {Uint8Array} finalize
2230
- * @returns {any}
2195
+ * @returns {number}
2231
2196
  */
2232
- finalize_response(finalize) {
2233
- try {
2234
- const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
2235
- wasm$1.wiree2eidentity_finalize_response(retptr, this.ptr, addHeapObject(finalize));
2236
- var r0 = getInt32Memory0()[retptr / 4 + 0];
2237
- var r1 = getInt32Memory0()[retptr / 4 + 1];
2238
- var r2 = getInt32Memory0()[retptr / 4 + 2];
2239
- if (r2) {
2240
- throw takeObject(r1);
2241
- }
2242
- return takeObject(r0);
2243
- } finally {
2244
- wasm$1.__wbindgen_add_to_stack_pointer(16);
2245
- }
2197
+ get encryption_type() {
2198
+ const ret = wasm$1.publicgroupstatebundle_encryption_type(this.ptr);
2199
+ return ret;
2246
2200
  }
2247
2201
  /**
2248
- * See [core_crypto::e2e_identity::WireE2eIdentity::certificate_request]
2249
- * @param {any} finalize
2250
- * @param {Uint8Array} account
2251
- * @param {string} previous_nonce
2252
- * @returns {Uint8Array}
2202
+ * @returns {number}
2253
2203
  */
2254
- certificate_request(finalize, account, previous_nonce) {
2255
- try {
2256
- const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
2257
- const ptr0 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
2258
- const len0 = WASM_VECTOR_LEN;
2259
- wasm$1.wiree2eidentity_certificate_request(retptr, this.ptr, addHeapObject(finalize), addHeapObject(account), ptr0, len0);
2260
- var r0 = getInt32Memory0()[retptr / 4 + 0];
2261
- var r1 = getInt32Memory0()[retptr / 4 + 1];
2262
- var r2 = getInt32Memory0()[retptr / 4 + 2];
2263
- if (r2) {
2264
- throw takeObject(r1);
2265
- }
2266
- return takeObject(r0);
2267
- } finally {
2268
- wasm$1.__wbindgen_add_to_stack_pointer(16);
2269
- }
2204
+ get ratchet_tree_type() {
2205
+ const ret = wasm$1.publicgroupstatebundle_ratchet_tree_type(this.ptr);
2206
+ return ret;
2270
2207
  }
2271
2208
  /**
2272
- * See [core_crypto::e2e_identity::WireE2eIdentity::certificate_response]
2273
- * @param {string} certificate_chain
2274
- * @returns {(Uint8Array)[]}
2209
+ * @returns {Uint8Array}
2275
2210
  */
2276
- certificate_response(certificate_chain) {
2277
- try {
2278
- const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
2279
- const ptr0 = passStringToWasm0(certificate_chain, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
2280
- const len0 = WASM_VECTOR_LEN;
2281
- wasm$1.wiree2eidentity_certificate_response(retptr, this.ptr, ptr0, len0);
2282
- var r0 = getInt32Memory0()[retptr / 4 + 0];
2283
- var r1 = getInt32Memory0()[retptr / 4 + 1];
2284
- var r2 = getInt32Memory0()[retptr / 4 + 2];
2285
- var r3 = getInt32Memory0()[retptr / 4 + 3];
2286
- if (r3) {
2287
- throw takeObject(r2);
2288
- }
2289
- var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
2290
- wasm$1.__wbindgen_free(r0, r1 * 4);
2291
- return v1;
2292
- } finally {
2293
- wasm$1.__wbindgen_add_to_stack_pointer(16);
2294
- }
2211
+ get payload() {
2212
+ const ret = wasm$1.invitee_id(this.ptr);
2213
+ return takeObject(ret);
2295
2214
  }
2296
2215
  }
2297
-
2298
2216
  async function load(module, imports) {
2299
2217
  if (typeof Response === 'function' && module instanceof Response) {
2300
2218
  if (typeof WebAssembly.instantiateStreaming === 'function') {
2301
2219
  try {
2302
2220
  return await WebAssembly.instantiateStreaming(module, imports);
2303
-
2304
- } catch (e) {
2221
+ }
2222
+ catch (e) {
2305
2223
  if (module.headers.get('Content-Type') != 'application/wasm') {
2306
2224
  console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
2307
-
2308
- } else {
2225
+ }
2226
+ else {
2309
2227
  throw e;
2310
2228
  }
2311
2229
  }
2312
2230
  }
2313
-
2314
2231
  const bytes = await module.arrayBuffer();
2315
2232
  return await WebAssembly.instantiate(bytes, imports);
2316
-
2317
- } else {
2233
+ }
2234
+ else {
2318
2235
  const instance = await WebAssembly.instantiate(module, imports);
2319
-
2320
2236
  if (instance instanceof WebAssembly.Instance) {
2321
2237
  return { instance, module };
2322
-
2323
- } else {
2238
+ }
2239
+ else {
2324
2240
  return instance;
2325
2241
  }
2326
2242
  }
2327
2243
  }
2328
-
2329
2244
  function getImports() {
2330
2245
  const imports = {};
2331
2246
  imports.wbg = {};
2332
- imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
2247
+ imports.wbg.__wbindgen_object_drop_ref = function (arg0) {
2248
+ takeObject(arg0);
2249
+ };
2250
+ imports.wbg.__wbindgen_object_clone_ref = function (arg0) {
2333
2251
  const ret = getObject(arg0);
2334
2252
  return addHeapObject(ret);
2335
2253
  };
2336
- imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
2337
- takeObject(arg0);
2338
- };
2339
- imports.wbg.__wbindgen_is_object = function(arg0) {
2254
+ imports.wbg.__wbindgen_is_object = function (arg0) {
2340
2255
  const val = getObject(arg0);
2341
- const ret = typeof(val) === 'object' && val !== null;
2256
+ const ret = typeof (val) === 'object' && val !== null;
2342
2257
  return ret;
2343
2258
  };
2344
- imports.wbg.__wbg_getwithrefkey_15c62c2b8546208d = function(arg0, arg1) {
2259
+ imports.wbg.__wbg_getwithrefkey_15c62c2b8546208d = function (arg0, arg1) {
2345
2260
  const ret = getObject(arg0)[getObject(arg1)];
2346
2261
  return addHeapObject(ret);
2347
2262
  };
2348
- imports.wbg.__wbindgen_is_undefined = function(arg0) {
2263
+ imports.wbg.__wbindgen_is_undefined = function (arg0) {
2349
2264
  const ret = getObject(arg0) === undefined;
2350
2265
  return ret;
2351
2266
  };
2352
- imports.wbg.__wbindgen_in = function(arg0, arg1) {
2267
+ imports.wbg.__wbindgen_in = function (arg0, arg1) {
2353
2268
  const ret = getObject(arg0) in getObject(arg1);
2354
2269
  return ret;
2355
2270
  };
2356
- imports.wbg.__wbg_objectStoreNames_8c06c40d2b05141c = function(arg0) {
2271
+ imports.wbg.__wbg_objectStoreNames_f0884fed45ebc81c = function (arg0) {
2357
2272
  const ret = getObject(arg0).objectStoreNames;
2358
2273
  return addHeapObject(ret);
2359
2274
  };
2360
- imports.wbg.__wbg_length_b59f358f797fd9f4 = function(arg0) {
2275
+ imports.wbg.__wbg_length_36c8debf8d623fc6 = function (arg0) {
2361
2276
  const ret = getObject(arg0).length;
2362
2277
  return ret;
2363
2278
  };
2364
- imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
2279
+ imports.wbg.__wbindgen_string_new = function (arg0, arg1) {
2365
2280
  const ret = getStringFromWasm0(arg0, arg1);
2366
2281
  return addHeapObject(ret);
2367
2282
  };
2368
- imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
2283
+ imports.wbg.__wbindgen_is_null = function (arg0) {
2284
+ const ret = getObject(arg0) === null;
2285
+ return ret;
2286
+ };
2287
+ imports.wbg.__wbindgen_string_get = function (arg0, arg1) {
2369
2288
  const obj = getObject(arg1);
2370
- const ret = typeof(obj) === 'string' ? obj : undefined;
2289
+ const ret = typeof (obj) === 'string' ? obj : undefined;
2371
2290
  var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
2372
2291
  var len0 = WASM_VECTOR_LEN;
2373
2292
  getInt32Memory0()[arg0 / 4 + 1] = len0;
2374
2293
  getInt32Memory0()[arg0 / 4 + 0] = ptr0;
2375
2294
  };
2376
- imports.wbg.__wbg_length_6e3bbe7c8bd4dbd8 = function(arg0) {
2295
+ imports.wbg.__wbg_length_e498fbc24f9c1d4f = function (arg0) {
2377
2296
  const ret = getObject(arg0).length;
2378
2297
  return ret;
2379
2298
  };
2380
- imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
2381
- const ret = new Error(getStringFromWasm0(arg0, arg1));
2299
+ imports.wbg.__wbg_new_537b7341ce90bb31 = function (arg0) {
2300
+ const ret = new Uint8Array(getObject(arg0));
2301
+ return addHeapObject(ret);
2302
+ };
2303
+ imports.wbg.__wbg_call_9495de66fdbe016b = function () {
2304
+ return handleError(function (arg0, arg1, arg2) {
2305
+ const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
2306
+ return addHeapObject(ret);
2307
+ }, arguments);
2308
+ };
2309
+ imports.wbg.__wbg_new_f9876326328f45ed = function () {
2310
+ const ret = new Object();
2311
+ return addHeapObject(ret);
2312
+ };
2313
+ imports.wbg.__wbg_new_f841cc6f2098f4b5 = function () {
2314
+ const ret = new Map();
2315
+ return addHeapObject(ret);
2316
+ };
2317
+ imports.wbg.__wbg_set_388c4c6422704173 = function (arg0, arg1, arg2) {
2318
+ const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
2319
+ return addHeapObject(ret);
2320
+ };
2321
+ imports.wbg.__wbindgen_bigint_from_u64 = function (arg0) {
2322
+ const ret = BigInt.asUintN(64, arg0);
2323
+ return addHeapObject(ret);
2324
+ };
2325
+ imports.wbg.__wbg_ffiwiree2eidentity_new = function (arg0) {
2326
+ const ret = FfiWireE2EIdentity.__wrap(arg0);
2327
+ return addHeapObject(ret);
2328
+ };
2329
+ imports.wbg.__wbg_new_b525de17f44a8943 = function () {
2330
+ const ret = new Array();
2331
+ return addHeapObject(ret);
2332
+ };
2333
+ imports.wbg.__wbg_set_17224bc548dd1d7b = function (arg0, arg1, arg2) {
2334
+ getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
2335
+ };
2336
+ imports.wbg.__wbg_set_20cbc34131e76824 = function (arg0, arg1, arg2) {
2337
+ getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
2338
+ };
2339
+ imports.wbg.__wbindgen_number_new = function (arg0) {
2340
+ const ret = arg0;
2382
2341
  return addHeapObject(ret);
2383
2342
  };
2384
- imports.wbg.__wbg_new0_a57059d72c5b7aee = function() {
2343
+ imports.wbg.__wbg_push_49c286f04dd3bf59 = function (arg0, arg1) {
2344
+ const ret = getObject(arg0).push(getObject(arg1));
2345
+ return ret;
2346
+ };
2347
+ imports.wbg.__wbg_new_9d3a9ce4282a18a8 = function (arg0, arg1) {
2348
+ try {
2349
+ var state0 = { a: arg0, b: arg1 };
2350
+ var cb0 = (arg0, arg1) => {
2351
+ const a = state0.a;
2352
+ state0.a = 0;
2353
+ try {
2354
+ return __wbg_adapter_263(a, state0.b, arg0, arg1);
2355
+ }
2356
+ finally {
2357
+ state0.a = a;
2358
+ }
2359
+ };
2360
+ const ret = new Promise(cb0);
2361
+ return addHeapObject(ret);
2362
+ }
2363
+ finally {
2364
+ state0.a = state0.b = 0;
2365
+ }
2366
+ };
2367
+ imports.wbg.__wbg_setonsuccess_925a7718d3f62bc1 = function (arg0, arg1) {
2368
+ getObject(arg0).onsuccess = getObject(arg1);
2369
+ };
2370
+ imports.wbg.__wbg_new0_25059e40b1c02766 = function () {
2385
2371
  const ret = new Date();
2386
2372
  return addHeapObject(ret);
2387
2373
  };
2388
- imports.wbg.__wbg_getTime_cb82adb2556ed13e = function(arg0) {
2374
+ imports.wbg.__wbg_getTime_7c59072d1651a3cf = function (arg0) {
2389
2375
  const ret = getObject(arg0).getTime();
2390
2376
  return ret;
2391
2377
  };
2392
- imports.wbg.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
2378
+ imports.wbg.__wbindgen_jsval_loose_eq = function (arg0, arg1) {
2393
2379
  const ret = getObject(arg0) == getObject(arg1);
2394
2380
  return ret;
2395
2381
  };
2396
- imports.wbg.__wbindgen_boolean_get = function(arg0) {
2382
+ imports.wbg.__wbindgen_boolean_get = function (arg0) {
2397
2383
  const v = getObject(arg0);
2398
- const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
2384
+ const ret = typeof (v) === 'boolean' ? (v ? 1 : 0) : 2;
2399
2385
  return ret;
2400
2386
  };
2401
- imports.wbg.__wbindgen_is_bigint = function(arg0) {
2402
- const ret = typeof(getObject(arg0)) === 'bigint';
2387
+ imports.wbg.__wbindgen_is_bigint = function (arg0) {
2388
+ const ret = typeof (getObject(arg0)) === 'bigint';
2403
2389
  return ret;
2404
2390
  };
2405
- imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
2391
+ imports.wbg.__wbindgen_number_get = function (arg0, arg1) {
2406
2392
  const obj = getObject(arg1);
2407
- const ret = typeof(obj) === 'number' ? obj : undefined;
2393
+ const ret = typeof (obj) === 'number' ? obj : undefined;
2408
2394
  getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
2409
2395
  getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
2410
2396
  };
2411
- imports.wbg.__wbg_isSafeInteger_dfa0593e8d7ac35a = function(arg0) {
2397
+ imports.wbg.__wbg_isSafeInteger_8c4789029e885159 = function (arg0) {
2412
2398
  const ret = Number.isSafeInteger(getObject(arg0));
2413
2399
  return ret;
2414
2400
  };
2415
- imports.wbg.__wbindgen_bigint_get_as_i64 = function(arg0, arg1) {
2401
+ imports.wbg.__wbindgen_bigint_get_as_i64 = function (arg0, arg1) {
2416
2402
  const v = getObject(arg1);
2417
- const ret = typeof(v) === 'bigint' ? v : undefined;
2418
- getBigInt64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0n : ret;
2403
+ const ret = typeof (v) === 'bigint' ? v : undefined;
2404
+ getBigInt64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? BigInt(0) : ret;
2419
2405
  getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
2420
2406
  };
2421
- imports.wbg.__wbindgen_bigint_from_i64 = function(arg0) {
2407
+ imports.wbg.__wbindgen_bigint_from_i64 = function (arg0) {
2422
2408
  const ret = arg0;
2423
2409
  return addHeapObject(ret);
2424
2410
  };
2425
- imports.wbg.__wbindgen_jsval_eq = function(arg0, arg1) {
2411
+ imports.wbg.__wbindgen_jsval_eq = function (arg0, arg1) {
2426
2412
  const ret = getObject(arg0) === getObject(arg1);
2427
2413
  return ret;
2428
2414
  };
2429
- imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
2430
- const ret = BigInt.asUintN(64, arg0);
2415
+ imports.wbg.__wbindgen_error_new = function (arg0, arg1) {
2416
+ const ret = new Error(getStringFromWasm0(arg0, arg1));
2431
2417
  return addHeapObject(ret);
2432
2418
  };
2433
- imports.wbg.__wbg_isArray_27c46c67f498e15d = function(arg0) {
2419
+ imports.wbg.__wbg_isArray_39d28997bf6b96b4 = function (arg0) {
2434
2420
  const ret = Array.isArray(getObject(arg0));
2435
2421
  return ret;
2436
2422
  };
2437
- imports.wbg.__wbg_iterator_6f9d4f28845f426c = function() {
2423
+ imports.wbg.__wbg_iterator_55f114446221aa5a = function () {
2438
2424
  const ret = Symbol.iterator;
2439
2425
  return addHeapObject(ret);
2440
2426
  };
2441
- imports.wbg.__wbg_get_57245cc7d7c7619d = function(arg0, arg1) {
2427
+ imports.wbg.__wbg_get_27fe3dac1c4d0224 = function (arg0, arg1) {
2442
2428
  const ret = getObject(arg0)[arg1 >>> 0];
2443
2429
  return addHeapObject(ret);
2444
2430
  };
2445
- imports.wbg.__wbg_corecrypto_new = function(arg0) {
2431
+ imports.wbg.__wbg_corecrypto_new = function (arg0) {
2446
2432
  const ret = CoreCrypto$1.__wrap(arg0);
2447
2433
  return addHeapObject(ret);
2448
2434
  };
2449
- imports.wbg.__wbg_new_0b9bfdd97583284e = function() {
2450
- const ret = new Object();
2451
- return addHeapObject(ret);
2452
- };
2453
- imports.wbg.__wbg_set_20cbc34131e76824 = function(arg0, arg1, arg2) {
2454
- getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
2455
- };
2456
- imports.wbg.__wbindgen_number_new = function(arg0) {
2457
- const ret = arg0;
2458
- return addHeapObject(ret);
2459
- };
2460
- imports.wbg.__wbg_wiree2eidentity_new = function(arg0) {
2461
- const ret = WireE2eIdentity$1.__wrap(arg0);
2462
- return addHeapObject(ret);
2463
- };
2464
- imports.wbg.__wbg_call_168da88779e35f61 = function() { return handleError(function (arg0, arg1, arg2) {
2465
- const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
2466
- return addHeapObject(ret);
2467
- }, arguments) };
2468
- imports.wbg.__wbg_new_8c3f0052272a457a = function(arg0) {
2469
- const ret = new Uint8Array(getObject(arg0));
2435
+ imports.wbg.__wbg_new_15d3966e9981a196 = function (arg0, arg1) {
2436
+ const ret = new Error(getStringFromWasm0(arg0, arg1));
2470
2437
  return addHeapObject(ret);
2471
2438
  };
2472
- imports.wbg.__wbg_new_9962f939219f1820 = function(arg0, arg1) {
2473
- try {
2474
- var state0 = {a: arg0, b: arg1};
2475
- var cb0 = (arg0, arg1) => {
2476
- const a = state0.a;
2477
- state0.a = 0;
2478
- try {
2479
- return __wbg_adapter_260(a, state0.b, arg0, arg1);
2480
- } finally {
2481
- state0.a = a;
2482
- }
2483
- };
2484
- const ret = new Promise(cb0);
2439
+ imports.wbg.__wbg_call_96878afb7a8201ca = function () {
2440
+ return handleError(function (arg0, arg1, arg2, arg3) {
2441
+ const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
2485
2442
  return addHeapObject(ret);
2486
- } finally {
2487
- state0.a = state0.b = 0;
2488
- }
2489
- };
2490
- imports.wbg.__wbg_new_1d9a920c6bfc44a8 = function() {
2491
- const ret = new Array();
2492
- return addHeapObject(ret);
2493
- };
2494
- imports.wbg.__wbg_push_740e4b286702d964 = function(arg0, arg1) {
2495
- const ret = getObject(arg0).push(getObject(arg1));
2496
- return ret;
2497
- };
2498
- imports.wbg.__wbg_new_268f7b7dd3430798 = function() {
2499
- const ret = new Map();
2500
- return addHeapObject(ret);
2443
+ }, arguments);
2501
2444
  };
2502
- imports.wbg.__wbg_set_933729cf5b66ac11 = function(arg0, arg1, arg2) {
2503
- const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
2504
- return addHeapObject(ret);
2505
- };
2506
- imports.wbg.__wbg_set_a68214f35c417fa9 = function(arg0, arg1, arg2) {
2507
- getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
2445
+ imports.wbg.__wbg_call_99043a1e2a9e5916 = function () {
2446
+ return handleError(function (arg0, arg1, arg2, arg3, arg4) {
2447
+ const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3), getObject(arg4));
2448
+ return addHeapObject(ret);
2449
+ }, arguments);
2508
2450
  };
2509
- imports.wbg.__wbg_call_3999bee59e9f7719 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
2510
- const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
2511
- return addHeapObject(ret);
2512
- }, arguments) };
2513
- imports.wbg.__wbg_call_e1f72c051cdab859 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
2514
- const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3), getObject(arg4));
2515
- return addHeapObject(ret);
2516
- }, arguments) };
2517
- imports.wbg.__wbg_reject_72477563edad55b7 = function(arg0) {
2451
+ imports.wbg.__wbg_reject_57029f54148d79c3 = function (arg0) {
2518
2452
  const ret = Promise.reject(getObject(arg0));
2519
2453
  return addHeapObject(ret);
2520
2454
  };
2521
- imports.wbg.__wbg_proposalbundle_new = function(arg0) {
2455
+ imports.wbg.__wbg_proposalbundle_new = function (arg0) {
2522
2456
  const ret = ProposalBundle.__wrap(arg0);
2523
2457
  return addHeapObject(ret);
2524
2458
  };
2525
- imports.wbg.__wbg_now_4d4a1d65c7a8c0ba = function() {
2459
+ imports.wbg.__wbg_now_4d4a1d65c7a8c0ba = function () {
2526
2460
  const ret = Date.now();
2527
2461
  return ret;
2528
2462
  };
2529
- imports.wbg.__wbg_now_78244d2ced74c026 = function() {
2463
+ imports.wbg.__wbg_now_78244d2ced74c026 = function () {
2530
2464
  const ret = performance.now();
2531
2465
  return ret;
2532
2466
  };
2533
- imports.wbg.__wbg_new_abda76e883ba8a5f = function() {
2467
+ imports.wbg.__wbg_new_abda76e883ba8a5f = function () {
2534
2468
  const ret = new Error();
2535
2469
  return addHeapObject(ret);
2536
2470
  };
2537
- imports.wbg.__wbg_stack_658279fe44541cf6 = function(arg0, arg1) {
2471
+ imports.wbg.__wbg_stack_658279fe44541cf6 = function (arg0, arg1) {
2538
2472
  const ret = getObject(arg1).stack;
2539
2473
  const ptr0 = passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
2540
2474
  const len0 = WASM_VECTOR_LEN;
2541
2475
  getInt32Memory0()[arg0 / 4 + 1] = len0;
2542
2476
  getInt32Memory0()[arg0 / 4 + 0] = ptr0;
2543
2477
  };
2544
- imports.wbg.__wbg_error_f851667af71bcfc6 = function(arg0, arg1) {
2478
+ imports.wbg.__wbg_error_f851667af71bcfc6 = function (arg0, arg1) {
2545
2479
  try {
2546
2480
  console.error(getStringFromWasm0(arg0, arg1));
2547
- } finally {
2481
+ }
2482
+ finally {
2548
2483
  wasm$1.__wbindgen_free(arg0, arg1);
2549
2484
  }
2550
2485
  };
2551
- imports.wbg.__wbg_commit_73ecc83e291e455b = function() { return handleError(function (arg0) {
2552
- getObject(arg0).commit();
2553
- }, arguments) };
2554
- imports.wbg.__wbg_setoncomplete_3e57a8cec8327f66 = function(arg0, arg1) {
2486
+ imports.wbg.__wbg_commit_7f934e1d9fffde34 = function () {
2487
+ return handleError(function (arg0) {
2488
+ getObject(arg0).commit();
2489
+ }, arguments);
2490
+ };
2491
+ imports.wbg.__wbg_setoncomplete_f32167d3f84be687 = function (arg0, arg1) {
2555
2492
  getObject(arg0).oncomplete = getObject(arg1);
2556
2493
  };
2557
- imports.wbg.__wbg_setonerror_00051c0213f27b2c = function(arg0, arg1) {
2494
+ imports.wbg.__wbg_setonerror_7cbe775a0abc7a8e = function (arg0, arg1) {
2558
2495
  getObject(arg0).onerror = getObject(arg1);
2559
2496
  };
2560
- imports.wbg.__wbindgen_is_null = function(arg0) {
2561
- const ret = getObject(arg0) === null;
2562
- return ret;
2563
- };
2564
- imports.wbg.__wbg_name_ebb75bfad2bf6938 = function(arg0, arg1) {
2497
+ imports.wbg.__wbg_name_31ef05f12c1d72c6 = function (arg0, arg1) {
2565
2498
  const ret = getObject(arg1).name;
2566
2499
  const ptr0 = passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
2567
2500
  const len0 = WASM_VECTOR_LEN;
2568
2501
  getInt32Memory0()[arg0 / 4 + 1] = len0;
2569
2502
  getInt32Memory0()[arg0 / 4 + 0] = ptr0;
2570
2503
  };
2571
- imports.wbg.__wbg_transaction_83b53b72aa710599 = function() { return handleError(function (arg0, arg1, arg2) {
2572
- const ret = getObject(arg0).transaction(getObject(arg1), takeObject(arg2));
2573
- return addHeapObject(ret);
2574
- }, arguments) };
2575
- imports.wbg.__wbindgen_cb_drop = function(arg0) {
2504
+ imports.wbg.__wbg_transaction_a31cc90bd4f34364 = function () {
2505
+ return handleError(function (arg0, arg1, arg2) {
2506
+ const ret = getObject(arg0).transaction(getObject(arg1), takeObject(arg2));
2507
+ return addHeapObject(ret);
2508
+ }, arguments);
2509
+ };
2510
+ imports.wbg.__wbg_setonerror_019196fbce756cc0 = function (arg0, arg1) {
2511
+ getObject(arg0).onerror = getObject(arg1);
2512
+ };
2513
+ imports.wbg.__wbindgen_cb_drop = function (arg0) {
2576
2514
  const obj = takeObject(arg0).original;
2577
2515
  if (obj.cnt-- == 1) {
2578
2516
  obj.a = 0;
@@ -2581,409 +2519,474 @@ function getImports() {
2581
2519
  const ret = false;
2582
2520
  return ret;
2583
2521
  };
2584
- imports.wbg.__wbg_openCursor_e036069f0e326708 = function() { return handleError(function (arg0, arg1) {
2585
- const ret = getObject(arg0).openCursor(getObject(arg1));
2586
- return addHeapObject(ret);
2587
- }, arguments) };
2588
- imports.wbg.__wbg_openCursor_f055654a98eeab7f = function() { return handleError(function (arg0) {
2589
- const ret = getObject(arg0).openCursor();
2590
- return addHeapObject(ret);
2591
- }, arguments) };
2592
- imports.wbg.__wbg_setonsuccess_5f71593bc51653a3 = function(arg0, arg1) {
2593
- getObject(arg0).onsuccess = getObject(arg1);
2522
+ imports.wbg.__wbg_close_98f3a5ab91060b8b = function (arg0) {
2523
+ getObject(arg0).close();
2594
2524
  };
2595
- imports.wbg.__wbg_setonerror_d5771cc5bf9ea74c = function(arg0, arg1) {
2596
- getObject(arg0).onerror = getObject(arg1);
2525
+ imports.wbg.__wbg_deleteDatabase_f360deb7283ea232 = function () {
2526
+ return handleError(function (arg0, arg1, arg2) {
2527
+ const ret = getObject(arg0).deleteDatabase(getStringFromWasm0(arg1, arg2));
2528
+ return addHeapObject(ret);
2529
+ }, arguments);
2597
2530
  };
2598
- imports.wbg.__wbg_get_6285bf458a1ee758 = function() { return handleError(function (arg0, arg1) {
2599
- const ret = getObject(arg0).get(getObject(arg1));
2600
- return addHeapObject(ret);
2601
- }, arguments) };
2602
- imports.wbg.__wbg_count_b0e88953a0ea909c = function() { return handleError(function (arg0) {
2603
- const ret = getObject(arg0).count();
2604
- return addHeapObject(ret);
2605
- }, arguments) };
2606
- imports.wbg.__wbg_count_46eda68a16dbe30e = function() { return handleError(function (arg0, arg1) {
2607
- const ret = getObject(arg0).count(getObject(arg1));
2608
- return addHeapObject(ret);
2609
- }, arguments) };
2610
- imports.wbg.__wbg_delete_8abedd1043b4105d = function() { return handleError(function (arg0, arg1) {
2611
- const ret = getObject(arg0).delete(getObject(arg1));
2612
- return addHeapObject(ret);
2613
- }, arguments) };
2614
- imports.wbg.__wbg_put_84e7fc93eee27b28 = function() { return handleError(function (arg0, arg1, arg2) {
2615
- const ret = getObject(arg0).put(getObject(arg1), getObject(arg2));
2616
- return addHeapObject(ret);
2617
- }, arguments) };
2618
- imports.wbg.__wbg_put_f2763b05a07f3233 = function() { return handleError(function (arg0, arg1) {
2619
- const ret = getObject(arg0).put(getObject(arg1));
2620
- return addHeapObject(ret);
2621
- }, arguments) };
2622
- imports.wbg.__wbg_open_a31c3fe1fdc244eb = function() { return handleError(function (arg0, arg1, arg2) {
2623
- const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2));
2624
- return addHeapObject(ret);
2625
- }, arguments) };
2626
- imports.wbg.__wbg_open_c5d5fb2df44b9d10 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
2627
- const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
2628
- return addHeapObject(ret);
2629
- }, arguments) };
2630
- imports.wbg.__wbg_setonupgradeneeded_17d0b9530f1e0cac = function(arg0, arg1) {
2631
- getObject(arg0).onupgradeneeded = getObject(arg1);
2531
+ imports.wbg.__wbg_put_fdcda25ee2a99b60 = function () {
2532
+ return handleError(function (arg0, arg1, arg2) {
2533
+ const ret = getObject(arg0).put(getObject(arg1), getObject(arg2));
2534
+ return addHeapObject(ret);
2535
+ }, arguments);
2632
2536
  };
2633
- imports.wbg.__wbg_index_86861edf1478f49c = function() { return handleError(function (arg0, arg1, arg2) {
2634
- const ret = getObject(arg0).index(getStringFromWasm0(arg1, arg2));
2635
- return addHeapObject(ret);
2636
- }, arguments) };
2637
- imports.wbg.__wbg_get_765201544a2b6869 = function() { return handleError(function (arg0, arg1) {
2638
- const ret = Reflect.get(getObject(arg0), getObject(arg1));
2639
- return addHeapObject(ret);
2640
- }, arguments) };
2641
- imports.wbg.__wbg_get_3c3e41997e95952c = function() { return handleError(function (arg0, arg1) {
2642
- const ret = getObject(arg0).get(getObject(arg1));
2643
- return addHeapObject(ret);
2644
- }, arguments) };
2645
- imports.wbg.__wbg_openCursor_2262d905dc81d11b = function() { return handleError(function (arg0) {
2646
- const ret = getObject(arg0).openCursor();
2647
- return addHeapObject(ret);
2648
- }, arguments) };
2649
- imports.wbg.__wbg_openCursor_e1660ef8b1f4662f = function() { return handleError(function (arg0, arg1) {
2650
- const ret = getObject(arg0).openCursor(getObject(arg1));
2651
- return addHeapObject(ret);
2652
- }, arguments) };
2653
- imports.wbg.__wbg_deleteDatabase_f6454de6a88aebde = function() { return handleError(function (arg0, arg1, arg2) {
2654
- const ret = getObject(arg0).deleteDatabase(getStringFromWasm0(arg1, arg2));
2655
- return addHeapObject(ret);
2656
- }, arguments) };
2657
- imports.wbg.__wbg_close_5a04b9ce11dade22 = function(arg0) {
2658
- getObject(arg0).close();
2537
+ imports.wbg.__wbg_put_e078356619886001 = function () {
2538
+ return handleError(function (arg0, arg1) {
2539
+ const ret = getObject(arg0).put(getObject(arg1));
2540
+ return addHeapObject(ret);
2541
+ }, arguments);
2542
+ };
2543
+ imports.wbg.__wbg_count_5e2074144ab4e23d = function () {
2544
+ return handleError(function (arg0) {
2545
+ const ret = getObject(arg0).count();
2546
+ return addHeapObject(ret);
2547
+ }, arguments);
2548
+ };
2549
+ imports.wbg.__wbg_count_ca4ab5c7bcf928fa = function () {
2550
+ return handleError(function (arg0, arg1) {
2551
+ const ret = getObject(arg0).count(getObject(arg1));
2552
+ return addHeapObject(ret);
2553
+ }, arguments);
2554
+ };
2555
+ imports.wbg.__wbg_delete_d2905418845867ae = function () {
2556
+ return handleError(function (arg0, arg1) {
2557
+ const ret = getObject(arg0).delete(getObject(arg1));
2558
+ return addHeapObject(ret);
2559
+ }, arguments);
2560
+ };
2561
+ imports.wbg.__wbg_index_009fbb0b7b595020 = function () {
2562
+ return handleError(function (arg0, arg1, arg2) {
2563
+ const ret = getObject(arg0).index(getStringFromWasm0(arg1, arg2));
2564
+ return addHeapObject(ret);
2565
+ }, arguments);
2566
+ };
2567
+ imports.wbg.__wbg_get_baf4855f9a986186 = function () {
2568
+ return handleError(function (arg0, arg1) {
2569
+ const ret = Reflect.get(getObject(arg0), getObject(arg1));
2570
+ return addHeapObject(ret);
2571
+ }, arguments);
2572
+ };
2573
+ imports.wbg.__wbg_get_6b22d93eabf073bc = function () {
2574
+ return handleError(function (arg0, arg1) {
2575
+ const ret = getObject(arg0).get(getObject(arg1));
2576
+ return addHeapObject(ret);
2577
+ }, arguments);
2578
+ };
2579
+ imports.wbg.__wbg_openCursor_54d7936e873b5120 = function () {
2580
+ return handleError(function (arg0, arg1) {
2581
+ const ret = getObject(arg0).openCursor(getObject(arg1));
2582
+ return addHeapObject(ret);
2583
+ }, arguments);
2584
+ };
2585
+ imports.wbg.__wbg_randomFillSync_6894564c2c334c42 = function () {
2586
+ return handleError(function (arg0, arg1, arg2) {
2587
+ getObject(arg0).randomFillSync(getArrayU8FromWasm0(arg1, arg2));
2588
+ }, arguments);
2659
2589
  };
2660
- imports.wbg.__wbg_randomFillSync_6894564c2c334c42 = function() { return handleError(function (arg0, arg1, arg2) {
2661
- getObject(arg0).randomFillSync(getArrayU8FromWasm0(arg1, arg2));
2662
- }, arguments) };
2663
- imports.wbg.__wbg_subarray_58ad4efbb5bcb886 = function(arg0, arg1, arg2) {
2590
+ imports.wbg.__wbg_subarray_7526649b91a252a6 = function (arg0, arg1, arg2) {
2664
2591
  const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
2665
2592
  return addHeapObject(ret);
2666
2593
  };
2667
- imports.wbg.__wbg_getRandomValues_805f1c3d65988a5a = function() { return handleError(function (arg0, arg1) {
2668
- getObject(arg0).getRandomValues(getObject(arg1));
2669
- }, arguments) };
2670
- imports.wbg.__wbg_length_9e1ae1900cb0fbd5 = function(arg0) {
2594
+ imports.wbg.__wbg_getRandomValues_805f1c3d65988a5a = function () {
2595
+ return handleError(function (arg0, arg1) {
2596
+ getObject(arg0).getRandomValues(getObject(arg1));
2597
+ }, arguments);
2598
+ };
2599
+ imports.wbg.__wbg_length_27a2afe8ab42b09f = function (arg0) {
2671
2600
  const ret = getObject(arg0).length;
2672
2601
  return ret;
2673
2602
  };
2674
- imports.wbg.__wbg_crypto_e1d53a1d73fb10b8 = function(arg0) {
2603
+ imports.wbg.__wbg_crypto_e1d53a1d73fb10b8 = function (arg0) {
2675
2604
  const ret = getObject(arg0).crypto;
2676
2605
  return addHeapObject(ret);
2677
2606
  };
2678
- imports.wbg.__wbg_process_038c26bf42b093f8 = function(arg0) {
2607
+ imports.wbg.__wbg_process_038c26bf42b093f8 = function (arg0) {
2679
2608
  const ret = getObject(arg0).process;
2680
2609
  return addHeapObject(ret);
2681
2610
  };
2682
- imports.wbg.__wbg_versions_ab37218d2f0b24a8 = function(arg0) {
2611
+ imports.wbg.__wbg_versions_ab37218d2f0b24a8 = function (arg0) {
2683
2612
  const ret = getObject(arg0).versions;
2684
2613
  return addHeapObject(ret);
2685
2614
  };
2686
- imports.wbg.__wbg_node_080f4b19d15bc1fe = function(arg0) {
2615
+ imports.wbg.__wbg_node_080f4b19d15bc1fe = function (arg0) {
2687
2616
  const ret = getObject(arg0).node;
2688
2617
  return addHeapObject(ret);
2689
2618
  };
2690
- imports.wbg.__wbindgen_is_string = function(arg0) {
2691
- const ret = typeof(getObject(arg0)) === 'string';
2619
+ imports.wbg.__wbindgen_is_string = function (arg0) {
2620
+ const ret = typeof (getObject(arg0)) === 'string';
2692
2621
  return ret;
2693
2622
  };
2694
- imports.wbg.__wbg_require_78a3dcfbdba9cbce = function() { return handleError(function () {
2695
- const ret = module.require;
2696
- return addHeapObject(ret);
2697
- }, arguments) };
2698
- imports.wbg.__wbindgen_is_function = function(arg0) {
2699
- const ret = typeof(getObject(arg0)) === 'function';
2623
+ imports.wbg.__wbg_require_78a3dcfbdba9cbce = function () {
2624
+ return handleError(function () {
2625
+ const ret = module.require;
2626
+ return addHeapObject(ret);
2627
+ }, arguments);
2628
+ };
2629
+ imports.wbg.__wbindgen_is_function = function (arg0) {
2630
+ const ret = typeof (getObject(arg0)) === 'function';
2700
2631
  return ret;
2701
2632
  };
2702
- imports.wbg.__wbg_msCrypto_6e7d3e1f92610cbb = function(arg0) {
2633
+ imports.wbg.__wbg_msCrypto_6e7d3e1f92610cbb = function (arg0) {
2703
2634
  const ret = getObject(arg0).msCrypto;
2704
2635
  return addHeapObject(ret);
2705
2636
  };
2706
- imports.wbg.__wbg_newwithlength_f5933855e4f48a19 = function(arg0) {
2637
+ imports.wbg.__wbg_newwithlength_b56c882b57805732 = function (arg0) {
2707
2638
  const ret = new Uint8Array(arg0 >>> 0);
2708
2639
  return addHeapObject(ret);
2709
2640
  };
2710
- imports.wbg.__wbg_next_aaef7c8aa5e212ac = function() { return handleError(function (arg0) {
2711
- const ret = getObject(arg0).next();
2712
- return addHeapObject(ret);
2713
- }, arguments) };
2714
- imports.wbg.__wbg_done_1b73b0672e15f234 = function(arg0) {
2641
+ imports.wbg.__wbg_next_88560ec06a094dea = function () {
2642
+ return handleError(function (arg0) {
2643
+ const ret = getObject(arg0).next();
2644
+ return addHeapObject(ret);
2645
+ }, arguments);
2646
+ };
2647
+ imports.wbg.__wbg_done_1ebec03bbd919843 = function (arg0) {
2715
2648
  const ret = getObject(arg0).done;
2716
2649
  return ret;
2717
2650
  };
2718
- imports.wbg.__wbg_value_1ccc36bc03462d71 = function(arg0) {
2651
+ imports.wbg.__wbg_value_6ac8da5cc5b3efda = function (arg0) {
2719
2652
  const ret = getObject(arg0).value;
2720
2653
  return addHeapObject(ret);
2721
2654
  };
2722
- imports.wbg.__wbg_call_97ae9d8645dc388b = function() { return handleError(function (arg0, arg1) {
2723
- const ret = getObject(arg0).call(getObject(arg1));
2724
- return addHeapObject(ret);
2725
- }, arguments) };
2726
- imports.wbg.__wbg_next_579e583d33566a86 = function(arg0) {
2655
+ imports.wbg.__wbg_call_95d1ea488d03e4e8 = function () {
2656
+ return handleError(function (arg0, arg1) {
2657
+ const ret = getObject(arg0).call(getObject(arg1));
2658
+ return addHeapObject(ret);
2659
+ }, arguments);
2660
+ };
2661
+ imports.wbg.__wbg_next_b7d530c04fd8b217 = function (arg0) {
2727
2662
  const ret = getObject(arg0).next;
2728
2663
  return addHeapObject(ret);
2729
2664
  };
2730
- imports.wbg.__wbg_self_6d479506f72c6a71 = function() { return handleError(function () {
2731
- const ret = self.self;
2732
- return addHeapObject(ret);
2733
- }, arguments) };
2734
- imports.wbg.__wbg_window_f2557cc78490aceb = function() { return handleError(function () {
2735
- const ret = window.window;
2736
- return addHeapObject(ret);
2737
- }, arguments) };
2738
- imports.wbg.__wbg_globalThis_7f206bda628d5286 = function() { return handleError(function () {
2739
- const ret = globalThis.globalThis;
2740
- return addHeapObject(ret);
2741
- }, arguments) };
2742
- imports.wbg.__wbg_global_ba75c50d1cf384f4 = function() { return handleError(function () {
2743
- const ret = global.global;
2744
- return addHeapObject(ret);
2745
- }, arguments) };
2746
- imports.wbg.__wbg_newnoargs_b5b063fc6c2f0376 = function(arg0, arg1) {
2665
+ imports.wbg.__wbg_self_e7c1f827057f6584 = function () {
2666
+ return handleError(function () {
2667
+ const ret = self.self;
2668
+ return addHeapObject(ret);
2669
+ }, arguments);
2670
+ };
2671
+ imports.wbg.__wbg_window_a09ec664e14b1b81 = function () {
2672
+ return handleError(function () {
2673
+ const ret = window.window;
2674
+ return addHeapObject(ret);
2675
+ }, arguments);
2676
+ };
2677
+ imports.wbg.__wbg_globalThis_87cbb8506fecf3a9 = function () {
2678
+ return handleError(function () {
2679
+ const ret = globalThis.globalThis;
2680
+ return addHeapObject(ret);
2681
+ }, arguments);
2682
+ };
2683
+ imports.wbg.__wbg_global_c85a9259e621f3db = function () {
2684
+ return handleError(function () {
2685
+ const ret = global.global;
2686
+ return addHeapObject(ret);
2687
+ }, arguments);
2688
+ };
2689
+ imports.wbg.__wbg_newnoargs_2b8b6bd7753c76ba = function (arg0, arg1) {
2747
2690
  const ret = new Function(getStringFromWasm0(arg0, arg1));
2748
2691
  return addHeapObject(ret);
2749
2692
  };
2750
- imports.wbg.__wbg_set_bf3f89b92d5a34bf = function() { return handleError(function (arg0, arg1, arg2) {
2751
- const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
2752
- return ret;
2753
- }, arguments) };
2754
- imports.wbg.__wbindgen_memory = function() {
2693
+ imports.wbg.__wbg_set_6aa458a4ebdb65cb = function () {
2694
+ return handleError(function (arg0, arg1, arg2) {
2695
+ const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
2696
+ return ret;
2697
+ }, arguments);
2698
+ };
2699
+ imports.wbg.__wbindgen_memory = function () {
2755
2700
  const ret = wasm$1.memory;
2756
2701
  return addHeapObject(ret);
2757
2702
  };
2758
- imports.wbg.__wbg_buffer_3f3d764d4747d564 = function(arg0) {
2703
+ imports.wbg.__wbg_buffer_cf65c07de34b9a08 = function (arg0) {
2759
2704
  const ret = getObject(arg0).buffer;
2760
2705
  return addHeapObject(ret);
2761
2706
  };
2762
- imports.wbg.__wbg_newwithbyteoffsetandlength_d9aa266703cb98be = function(arg0, arg1, arg2) {
2707
+ imports.wbg.__wbg_newwithbyteoffsetandlength_9fb2f11355ecadf5 = function (arg0, arg1, arg2) {
2763
2708
  const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
2764
2709
  return addHeapObject(ret);
2765
2710
  };
2766
- imports.wbg.__wbg_set_83db9690f9353e79 = function(arg0, arg1, arg2) {
2711
+ imports.wbg.__wbg_set_17499e8aa4003ebd = function (arg0, arg1, arg2) {
2767
2712
  getObject(arg0).set(getObject(arg1), arg2 >>> 0);
2768
2713
  };
2769
- imports.wbg.__wbg_now_58886682b7e790d7 = function() {
2714
+ imports.wbg.__wbg_now_931686b195a14f9d = function () {
2770
2715
  const ret = Date.now();
2771
2716
  return ret;
2772
2717
  };
2773
- imports.wbg.__wbg_target_bf704b7db7ad1387 = function(arg0) {
2718
+ imports.wbg.__wbg_target_b629c177f9bee3da = function (arg0) {
2774
2719
  const ret = getObject(arg0).target;
2775
2720
  return isLikeNone(ret) ? 0 : addHeapObject(ret);
2776
2721
  };
2777
- imports.wbg.__wbg_result_9e399c14676970d9 = function() { return handleError(function (arg0) {
2778
- const ret = getObject(arg0).result;
2779
- return addHeapObject(ret);
2780
- }, arguments) };
2781
- imports.wbg.__wbg_contains_6cf516181cd86571 = function(arg0, arg1, arg2) {
2722
+ imports.wbg.__wbg_result_3a1fef332bc47038 = function () {
2723
+ return handleError(function (arg0) {
2724
+ const ret = getObject(arg0).result;
2725
+ return addHeapObject(ret);
2726
+ }, arguments);
2727
+ };
2728
+ imports.wbg.__wbg_contains_eab173da4886df95 = function (arg0, arg1, arg2) {
2782
2729
  const ret = getObject(arg0).contains(getStringFromWasm0(arg1, arg2));
2783
2730
  return ret;
2784
2731
  };
2785
- imports.wbg.__wbg_createObjectStore_f4c2f030bc994158 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
2786
- const ret = getObject(arg0).createObjectStore(getStringFromWasm0(arg1, arg2), getObject(arg3));
2787
- return addHeapObject(ret);
2788
- }, arguments) };
2789
- imports.wbg.__wbg_transaction_2a414baad674f8d4 = function(arg0) {
2732
+ imports.wbg.__wbg_createObjectStore_ed1e91faa3997893 = function () {
2733
+ return handleError(function (arg0, arg1, arg2, arg3) {
2734
+ const ret = getObject(arg0).createObjectStore(getStringFromWasm0(arg1, arg2), getObject(arg3));
2735
+ return addHeapObject(ret);
2736
+ }, arguments);
2737
+ };
2738
+ imports.wbg.__wbg_transaction_c231cf0e3feac876 = function (arg0) {
2790
2739
  const ret = getObject(arg0).transaction;
2791
2740
  return isLikeNone(ret) ? 0 : addHeapObject(ret);
2792
2741
  };
2793
- imports.wbg.__wbg_indexNames_e6ea7f4d67313c8c = function(arg0) {
2742
+ imports.wbg.__wbg_indexNames_7ef05cac7f9faea0 = function (arg0) {
2794
2743
  const ret = getObject(arg0).indexNames;
2795
2744
  return addHeapObject(ret);
2796
2745
  };
2797
- imports.wbg.__wbg_createIndex_2e6761d6cd83a0d6 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
2798
- const ret = getObject(arg0).createIndex(getStringFromWasm0(arg1, arg2), getObject(arg3), getObject(arg4));
2799
- return addHeapObject(ret);
2800
- }, arguments) };
2801
- imports.wbg.__wbg_deleteIndex_2f8e18b00c1554e1 = function() { return handleError(function (arg0, arg1, arg2) {
2802
- getObject(arg0).deleteIndex(getStringFromWasm0(arg1, arg2));
2803
- }, arguments) };
2804
- imports.wbg.__wbg_deleteObjectStore_1b698c5fd1bc077d = function() { return handleError(function (arg0, arg1, arg2) {
2805
- getObject(arg0).deleteObjectStore(getStringFromWasm0(arg1, arg2));
2806
- }, arguments) };
2807
- imports.wbg.__wbg_error_aacf5ac191e54ed0 = function() { return handleError(function (arg0) {
2808
- const ret = getObject(arg0).error;
2809
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
2810
- }, arguments) };
2811
- imports.wbg.__wbindgen_is_falsy = function(arg0) {
2746
+ imports.wbg.__wbg_createIndex_308667a6a7549b87 = function () {
2747
+ return handleError(function (arg0, arg1, arg2, arg3, arg4) {
2748
+ const ret = getObject(arg0).createIndex(getStringFromWasm0(arg1, arg2), getObject(arg3), getObject(arg4));
2749
+ return addHeapObject(ret);
2750
+ }, arguments);
2751
+ };
2752
+ imports.wbg.__wbg_deleteIndex_4f7897daa8425a6c = function () {
2753
+ return handleError(function (arg0, arg1, arg2) {
2754
+ getObject(arg0).deleteIndex(getStringFromWasm0(arg1, arg2));
2755
+ }, arguments);
2756
+ };
2757
+ imports.wbg.__wbg_deleteObjectStore_a67245ba486fb641 = function () {
2758
+ return handleError(function (arg0, arg1, arg2) {
2759
+ getObject(arg0).deleteObjectStore(getStringFromWasm0(arg1, arg2));
2760
+ }, arguments);
2761
+ };
2762
+ imports.wbg.__wbg_error_f64b8d41ed4d2fdc = function () {
2763
+ return handleError(function (arg0) {
2764
+ const ret = getObject(arg0).error;
2765
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
2766
+ }, arguments);
2767
+ };
2768
+ imports.wbg.__wbindgen_is_falsy = function (arg0) {
2812
2769
  const ret = !getObject(arg0);
2813
2770
  return ret;
2814
2771
  };
2815
- imports.wbg.__wbg_key_1a7ac8cd4fa1c7a1 = function() { return handleError(function (arg0) {
2816
- const ret = getObject(arg0).key;
2817
- return addHeapObject(ret);
2818
- }, arguments) };
2819
- imports.wbg.__wbg_advance_ca3cc2aceae7ca47 = function() { return handleError(function (arg0, arg1) {
2820
- getObject(arg0).advance(arg1 >>> 0);
2821
- }, arguments) };
2822
- imports.wbg.__wbg_instanceof_IdbFactory_52a891270c686e1c = function(arg0) {
2772
+ imports.wbg.__wbg_key_4b29c4de1db73033 = function () {
2773
+ return handleError(function (arg0) {
2774
+ const ret = getObject(arg0).key;
2775
+ return addHeapObject(ret);
2776
+ }, arguments);
2777
+ };
2778
+ imports.wbg.__wbg_advance_b4ae7221325b28eb = function () {
2779
+ return handleError(function (arg0, arg1) {
2780
+ getObject(arg0).advance(arg1 >>> 0);
2781
+ }, arguments);
2782
+ };
2783
+ imports.wbg.__wbg_instanceof_IdbFactory_9c5780a46ebd3426 = function (arg0) {
2823
2784
  let result;
2824
2785
  try {
2825
2786
  result = getObject(arg0) instanceof IDBFactory;
2826
- } catch {
2787
+ }
2788
+ catch {
2827
2789
  result = false;
2828
2790
  }
2829
2791
  const ret = result;
2830
2792
  return ret;
2831
2793
  };
2832
- imports.wbg.__wbg_toString_73c9b562dccf34bd = function(arg0) {
2794
+ imports.wbg.__wbg_open_bd135117d9924392 = function () {
2795
+ return handleError(function (arg0, arg1, arg2) {
2796
+ const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2));
2797
+ return addHeapObject(ret);
2798
+ }, arguments);
2799
+ };
2800
+ imports.wbg.__wbg_open_2f9bdc2df25fc92e = function () {
2801
+ return handleError(function (arg0, arg1, arg2, arg3) {
2802
+ const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
2803
+ return addHeapObject(ret);
2804
+ }, arguments);
2805
+ };
2806
+ imports.wbg.__wbg_setonupgradeneeded_8961be061344d04a = function (arg0, arg1) {
2807
+ getObject(arg0).onupgradeneeded = getObject(arg1);
2808
+ };
2809
+ imports.wbg.__wbg_toString_cec163b212643722 = function (arg0) {
2833
2810
  const ret = getObject(arg0).toString();
2834
2811
  return addHeapObject(ret);
2835
2812
  };
2836
- imports.wbg.__wbg_instanceof_Window_acc97ff9f5d2c7b4 = function(arg0) {
2813
+ imports.wbg.__wbg_instanceof_Window_e266f02eee43b570 = function (arg0) {
2837
2814
  let result;
2838
2815
  try {
2839
2816
  result = getObject(arg0) instanceof Window;
2840
- } catch {
2817
+ }
2818
+ catch {
2841
2819
  result = false;
2842
2820
  }
2843
2821
  const ret = result;
2844
2822
  return ret;
2845
2823
  };
2846
- imports.wbg.__wbg_crypto_9f07beb1e97bfa1b = function() { return handleError(function (arg0) {
2847
- const ret = getObject(arg0).crypto;
2848
- return addHeapObject(ret);
2849
- }, arguments) };
2850
- imports.wbg.__wbg_getRandomValues_f134f772d240c51f = function() { return handleError(function (arg0, arg1, arg2) {
2851
- const ret = getObject(arg0).getRandomValues(getArrayU8FromWasm0(arg1, arg2));
2852
- return addHeapObject(ret);
2853
- }, arguments) };
2854
- imports.wbg.__wbg_instanceof_Uint8Array_971eeda69eb75003 = function(arg0) {
2824
+ imports.wbg.__wbg_crypto_71b946c90b06fb5b = function () {
2825
+ return handleError(function (arg0) {
2826
+ const ret = getObject(arg0).crypto;
2827
+ return addHeapObject(ret);
2828
+ }, arguments);
2829
+ };
2830
+ imports.wbg.__wbg_getRandomValues_2a91ccd2d6c499b0 = function () {
2831
+ return handleError(function (arg0, arg1, arg2) {
2832
+ const ret = getObject(arg0).getRandomValues(getArrayU8FromWasm0(arg1, arg2));
2833
+ return addHeapObject(ret);
2834
+ }, arguments);
2835
+ };
2836
+ imports.wbg.__wbg_instanceof_Uint8Array_01cebe79ca606cca = function (arg0) {
2855
2837
  let result;
2856
2838
  try {
2857
2839
  result = getObject(arg0) instanceof Uint8Array;
2858
- } catch {
2840
+ }
2841
+ catch {
2859
2842
  result = false;
2860
2843
  }
2861
2844
  const ret = result;
2862
2845
  return ret;
2863
2846
  };
2864
- imports.wbg.__wbg_instanceof_ArrayBuffer_e5e48f4762c5610b = function(arg0) {
2847
+ imports.wbg.__wbg_instanceof_ArrayBuffer_a69f02ee4c4f5065 = function (arg0) {
2865
2848
  let result;
2866
2849
  try {
2867
2850
  result = getObject(arg0) instanceof ArrayBuffer;
2868
- } catch {
2851
+ }
2852
+ catch {
2869
2853
  result = false;
2870
2854
  }
2871
2855
  const ret = result;
2872
2856
  return ret;
2873
2857
  };
2874
- imports.wbg.__wbg_entries_65a76a413fc91037 = function(arg0) {
2858
+ imports.wbg.__wbg_entries_4e1315b774245952 = function (arg0) {
2875
2859
  const ret = Object.entries(getObject(arg0));
2876
2860
  return addHeapObject(ret);
2877
2861
  };
2878
- imports.wbg.__wbg_String_91fba7ded13ba54c = function(arg0, arg1) {
2862
+ imports.wbg.__wbg_String_91fba7ded13ba54c = function (arg0, arg1) {
2879
2863
  const ret = String(getObject(arg1));
2880
2864
  const ptr0 = passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
2881
2865
  const len0 = WASM_VECTOR_LEN;
2882
2866
  getInt32Memory0()[arg0 / 4 + 1] = len0;
2883
2867
  getInt32Memory0()[arg0 / 4 + 0] = ptr0;
2884
2868
  };
2885
- imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
2869
+ imports.wbg.__wbindgen_debug_string = function (arg0, arg1) {
2886
2870
  const ret = debugString(getObject(arg1));
2887
2871
  const ptr0 = passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
2888
2872
  const len0 = WASM_VECTOR_LEN;
2889
2873
  getInt32Memory0()[arg0 / 4 + 1] = len0;
2890
2874
  getInt32Memory0()[arg0 / 4 + 0] = ptr0;
2891
2875
  };
2892
- imports.wbg.__wbindgen_throw = function(arg0, arg1) {
2876
+ imports.wbg.__wbindgen_throw = function (arg0, arg1) {
2893
2877
  throw new Error(getStringFromWasm0(arg0, arg1));
2894
2878
  };
2895
- imports.wbg.__wbg_then_11f7a54d67b4bfad = function(arg0, arg1) {
2879
+ imports.wbg.__wbg_then_ec5db6d509eb475f = function (arg0, arg1) {
2896
2880
  const ret = getObject(arg0).then(getObject(arg1));
2897
2881
  return addHeapObject(ret);
2898
2882
  };
2899
- imports.wbg.__wbg_resolve_99fe17964f31ffc0 = function(arg0) {
2883
+ imports.wbg.__wbg_resolve_fd40f858d9db1a04 = function (arg0) {
2900
2884
  const ret = Promise.resolve(getObject(arg0));
2901
2885
  return addHeapObject(ret);
2902
2886
  };
2903
- imports.wbg.__wbg_get_0ab855454881e5cf = function(arg0, arg1, arg2) {
2887
+ imports.wbg.__wbg_get_ed3fbcc16ce7b4bb = function (arg0, arg1, arg2) {
2904
2888
  const ret = getObject(arg1)[arg2 >>> 0];
2905
2889
  var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
2906
2890
  var len0 = WASM_VECTOR_LEN;
2907
2891
  getInt32Memory0()[arg0 / 4 + 1] = len0;
2908
2892
  getInt32Memory0()[arg0 / 4 + 0] = ptr0;
2909
2893
  };
2910
- imports.wbg.__wbg_continue_3ff6a82c48409f45 = function() { return handleError(function (arg0) {
2911
- getObject(arg0).continue();
2912
- }, arguments) };
2913
- imports.wbg.__wbg_value_b663fab9801b9d19 = function() { return handleError(function (arg0) {
2914
- const ret = getObject(arg0).value;
2915
- return addHeapObject(ret);
2916
- }, arguments) };
2917
- imports.wbg.__wbg_openCursor_3b7256b00a9b7d9f = function() { return handleError(function (arg0, arg1, arg2) {
2918
- const ret = getObject(arg0).openCursor(getObject(arg1), takeObject(arg2));
2919
- return addHeapObject(ret);
2920
- }, arguments) };
2921
- imports.wbg.__wbg_openCursor_4fee2b2ca0f3ed32 = function() { return handleError(function (arg0, arg1, arg2) {
2922
- const ret = getObject(arg0).openCursor(getObject(arg1), takeObject(arg2));
2923
- return addHeapObject(ret);
2924
- }, arguments) };
2925
- imports.wbg.__wbg_objectStore_f17976b0e6377830 = function() { return handleError(function (arg0, arg1, arg2) {
2926
- const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2));
2927
- return addHeapObject(ret);
2928
- }, arguments) };
2929
- imports.wbg.__wbindgen_closure_wrapper2639 = function(arg0, arg1, arg2) {
2930
- const ret = makeMutClosure(arg0, arg1, 142, __wbg_adapter_52);
2894
+ imports.wbg.__wbg_continue_1df0825170e4d395 = function () {
2895
+ return handleError(function (arg0) {
2896
+ getObject(arg0).continue();
2897
+ }, arguments);
2898
+ };
2899
+ imports.wbg.__wbg_value_97772e372f20b04e = function () {
2900
+ return handleError(function (arg0) {
2901
+ const ret = getObject(arg0).value;
2902
+ return addHeapObject(ret);
2903
+ }, arguments);
2904
+ };
2905
+ imports.wbg.__wbg_openCursor_f07a2d20b356da80 = function () {
2906
+ return handleError(function (arg0) {
2907
+ const ret = getObject(arg0).openCursor();
2908
+ return addHeapObject(ret);
2909
+ }, arguments);
2910
+ };
2911
+ imports.wbg.__wbg_openCursor_03f95e6b2b64c86e = function () {
2912
+ return handleError(function (arg0, arg1, arg2) {
2913
+ const ret = getObject(arg0).openCursor(getObject(arg1), takeObject(arg2));
2914
+ return addHeapObject(ret);
2915
+ }, arguments);
2916
+ };
2917
+ imports.wbg.__wbg_get_18b8195859195e7e = function () {
2918
+ return handleError(function (arg0, arg1) {
2919
+ const ret = getObject(arg0).get(getObject(arg1));
2920
+ return addHeapObject(ret);
2921
+ }, arguments);
2922
+ };
2923
+ imports.wbg.__wbg_openCursor_a00e5f8015710a1a = function () {
2924
+ return handleError(function (arg0) {
2925
+ const ret = getObject(arg0).openCursor();
2926
+ return addHeapObject(ret);
2927
+ }, arguments);
2928
+ };
2929
+ imports.wbg.__wbg_openCursor_51766f7156aa29ab = function () {
2930
+ return handleError(function (arg0, arg1) {
2931
+ const ret = getObject(arg0).openCursor(getObject(arg1));
2932
+ return addHeapObject(ret);
2933
+ }, arguments);
2934
+ };
2935
+ imports.wbg.__wbg_openCursor_4bc8942a881766b1 = function () {
2936
+ return handleError(function (arg0, arg1, arg2) {
2937
+ const ret = getObject(arg0).openCursor(getObject(arg1), takeObject(arg2));
2938
+ return addHeapObject(ret);
2939
+ }, arguments);
2940
+ };
2941
+ imports.wbg.__wbg_objectStore_cdc69f65ad4a71eb = function () {
2942
+ return handleError(function (arg0, arg1, arg2) {
2943
+ const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2));
2944
+ return addHeapObject(ret);
2945
+ }, arguments);
2946
+ };
2947
+ imports.wbg.__wbindgen_closure_wrapper4326 = function (arg0, arg1, arg2) {
2948
+ const ret = makeMutClosure(arg0, arg1, 146, __wbg_adapter_52);
2931
2949
  return addHeapObject(ret);
2932
2950
  };
2933
- imports.wbg.__wbindgen_closure_wrapper4541 = function(arg0, arg1, arg2) {
2934
- const ret = makeMutClosure(arg0, arg1, 142, __wbg_adapter_55);
2951
+ imports.wbg.__wbindgen_closure_wrapper4766 = function (arg0, arg1, arg2) {
2952
+ const ret = makeMutClosure(arg0, arg1, 146, __wbg_adapter_55);
2935
2953
  return addHeapObject(ret);
2936
2954
  };
2937
-
2938
2955
  return imports;
2939
2956
  }
2940
-
2941
2957
  function finalizeInit(instance, module) {
2942
2958
  wasm$1 = instance.exports;
2943
2959
  init.__wbindgen_wasm_module = module;
2944
- cachedBigInt64Memory0 = new BigInt64Array();
2945
- cachedFloat64Memory0 = new Float64Array();
2946
- cachedInt32Memory0 = new Int32Array();
2947
- cachedUint32Memory0 = new Uint32Array();
2948
- cachedUint8Memory0 = new Uint8Array();
2949
-
2950
-
2960
+ cachedBigInt64Memory0 = null;
2961
+ cachedFloat64Memory0 = null;
2962
+ cachedInt32Memory0 = null;
2963
+ cachedUint32Memory0 = null;
2964
+ cachedUint8Memory0 = null;
2951
2965
  return wasm$1;
2952
2966
  }
2953
-
2954
2967
  function initSync(module) {
2955
2968
  const imports = getImports();
2956
-
2957
2969
  if (!(module instanceof WebAssembly.Module)) {
2958
2970
  module = new WebAssembly.Module(module);
2959
2971
  }
2960
-
2961
2972
  const instance = new WebAssembly.Instance(module, imports);
2962
-
2963
2973
  return finalizeInit(instance, module);
2964
2974
  }
2965
-
2966
2975
  async function init(input) {
2967
-
2968
2976
  const imports = getImports();
2969
-
2970
2977
  if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
2971
2978
  input = fetch(input);
2972
2979
  }
2973
-
2974
2980
  const { instance, module } = await load(await input, imports);
2975
-
2976
2981
  return finalizeInit(instance, module);
2977
2982
  }
2978
2983
 
2979
2984
  var exports = /*#__PURE__*/Object.freeze({
2980
2985
  __proto__: null,
2981
- version: version,
2982
- WirePolicy: WirePolicy$1,
2983
- Ciphersuite: Ciphersuite$1,
2984
2986
  AcmeChallenge: AcmeChallenge,
2985
2987
  AcmeDirectory: AcmeDirectory,
2986
2988
  AcmeFinalize: AcmeFinalize,
2989
+ Ciphersuite: Ciphersuite$1,
2987
2990
  CommitBundle: CommitBundle,
2988
2991
  ConversationConfiguration: ConversationConfiguration,
2989
2992
  ConversationInitBundle: ConversationInitBundle,
@@ -2991,21 +2994,23 @@ var exports = /*#__PURE__*/Object.freeze({
2991
2994
  CoreCryptoWasmCallbacks: CoreCryptoWasmCallbacks,
2992
2995
  CustomConfiguration: CustomConfiguration,
2993
2996
  DecryptedMessage: DecryptedMessage,
2997
+ FfiWireE2EIdentity: FfiWireE2EIdentity,
2994
2998
  Invitee: Invitee,
2995
2999
  MemberAddedMessages: MemberAddedMessages,
2996
3000
  NewAcmeAuthz: NewAcmeAuthz,
2997
3001
  NewAcmeOrder: NewAcmeOrder,
2998
3002
  ProposalBundle: ProposalBundle,
2999
3003
  PublicGroupStateBundle: PublicGroupStateBundle,
3000
- WireE2eIdentity: WireE2eIdentity$1,
3004
+ WirePolicy: WirePolicy$1,
3005
+ default: init,
3001
3006
  initSync: initSync,
3002
- 'default': init
3007
+ version: version
3003
3008
  });
3004
3009
 
3005
3010
  var wasm = async (opt = {}) => {
3006
3011
  let {importHook, serverPath} = opt;
3007
3012
 
3008
- let path = "assets/core_crypto_ffi-7a5675cc.wasm";
3013
+ let path = "assets/core_crypto_ffi-fb64c1f7.wasm";
3009
3014
 
3010
3015
  if (serverPath != null) {
3011
3016
  path = serverPath + /[^\/\\]*$/.exec(path)[0];
@@ -3021,7 +3026,65 @@ var wasm = async (opt = {}) => {
3021
3026
 
3022
3027
  // Wire
3023
3028
  // Copyright (C) 2022 Wire Swiss GmbH
3024
- var _a, _CoreCrypto_module, _CoreCrypto_cc, _b, _WireE2eIdentity_module, _WireE2eIdentity_e2ei;
3029
+ var _a, _CoreCrypto_module, _CoreCrypto_cc, _WireE2eIdentity_e2ei;
3030
+ /**
3031
+ * Error wrapper that takes care of extracting rich error details across the FFI (through JSON parsing)
3032
+ *
3033
+ * Whenever you're supposed to get this class (that extends `Error`) you might end up with a base `Error`
3034
+ * in case the parsing of the message structure fails. This is unlikely but the case is still covered and fall backs automatically.
3035
+ * More information will be found in the base `Error.cause` to inform you why the parsing has failed.
3036
+ *
3037
+ * Please note that in this case the extra properties will not be available.
3038
+ */
3039
+ class CoreCryptoError extends Error {
3040
+ constructor(msg, richError, ...params) {
3041
+ // @ts-ignore
3042
+ super(msg, ...params);
3043
+ Object.setPrototypeOf(this, new.target.prototype);
3044
+ this.name = richError.errorName;
3045
+ this.rustStackTrace = richError.rustStackTrace;
3046
+ this.proteusErrorCode = richError.proteusErrorCode;
3047
+ }
3048
+ static fallback(msg, ...params) {
3049
+ console.warn("Cannot build CoreCryptoError, falling back to standard Error");
3050
+ // @ts-ignore
3051
+ return new Error(msg, ...params);
3052
+ }
3053
+ static build(msg, ...params) {
3054
+ const parts = msg.split("\n\n");
3055
+ if (parts.length < 2) {
3056
+ const cause = new Error("CoreCrypto WASM FFI Error doesn't have enough elements to build a rich error");
3057
+ return this.fallback(msg, { cause }, ...params);
3058
+ }
3059
+ const [errMsg, richErrorJSON,] = parts;
3060
+ try {
3061
+ const richError = JSON.parse(richErrorJSON);
3062
+ return new this(errMsg, richError, ...params);
3063
+ }
3064
+ catch (cause) {
3065
+ return this.fallback(msg, { cause }, ...params);
3066
+ }
3067
+ }
3068
+ static fromStdError(e) {
3069
+ const opts = {
3070
+ // @ts-ignore
3071
+ cause: e.cause || undefined,
3072
+ stack: e.stack || undefined,
3073
+ };
3074
+ return this.build(e.message, opts);
3075
+ }
3076
+ static async asyncMapErr(p) {
3077
+ const mappedErrorPromise = p.catch((e) => {
3078
+ if (e instanceof CoreCryptoError) {
3079
+ throw e;
3080
+ }
3081
+ else {
3082
+ throw this.fromStdError(e);
3083
+ }
3084
+ });
3085
+ return await mappedErrorPromise;
3086
+ }
3087
+ }
3025
3088
  /**
3026
3089
  * see [core_crypto::prelude::CiphersuiteName]
3027
3090
  */
@@ -3179,7 +3242,7 @@ class CoreCrypto {
3179
3242
  const exports = (await wasm(wasmImportArgs));
3180
3243
  __classPrivateFieldSet(this, _a, exports, "f", _CoreCrypto_module);
3181
3244
  }
3182
- const cc = await __classPrivateFieldGet(this, _a, "f", _CoreCrypto_module).CoreCrypto._internal_new(databaseName, key, clientId, entropySeed);
3245
+ const cc = await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _a, "f", _CoreCrypto_module).CoreCrypto._internal_new(databaseName, key, clientId, entropySeed));
3183
3246
  return new this(cc);
3184
3247
  }
3185
3248
  /**
@@ -3187,14 +3250,15 @@ class CoreCrypto {
3187
3250
  * First, calling this will set up the keystore and will allow generating proteus prekeys.
3188
3251
  * Then, those keys can be traded for a clientId.
3189
3252
  * Use this clientId to initialize MLS with {@link CoreCrypto.mlsInit}.
3253
+ * @param params - {@link CoreCryptoDeferredParams}
3190
3254
  */
3191
- static async deferredInit(databaseName, key, entropySeed, wasmFilePath) {
3255
+ static async deferredInit({ databaseName, key, entropySeed, wasmFilePath }) {
3192
3256
  if (!__classPrivateFieldGet(this, _a, "f", _CoreCrypto_module)) {
3193
3257
  const wasmImportArgs = wasmFilePath ? { importHook: () => wasmFilePath } : undefined;
3194
3258
  const exports = (await wasm(wasmImportArgs));
3195
3259
  __classPrivateFieldSet(this, _a, exports, "f", _CoreCrypto_module);
3196
3260
  }
3197
- const cc = await __classPrivateFieldGet(this, _a, "f", _CoreCrypto_module).CoreCrypto.deferred_init(databaseName, key, entropySeed);
3261
+ const cc = await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _a, "f", _CoreCrypto_module).CoreCrypto.deferred_init(databaseName, key, entropySeed));
3198
3262
  return new this(cc);
3199
3263
  }
3200
3264
  /**
@@ -3203,7 +3267,7 @@ class CoreCrypto {
3203
3267
  * @param clientId - {@link CoreCryptoParams#clientId} but required
3204
3268
  */
3205
3269
  async mlsInit(clientId) {
3206
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").mls_init(clientId);
3270
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").mls_init(clientId));
3207
3271
  }
3208
3272
  /** @hidden */
3209
3273
  constructor(cc) {
@@ -3217,7 +3281,7 @@ class CoreCrypto {
3217
3281
  * **CAUTION**: This {@link CoreCrypto} instance won't be useable after a call to this method, but there's no way to express this requirement in TypeScript so you'll get errors instead!
3218
3282
  */
3219
3283
  async wipe() {
3220
- await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").wipe();
3284
+ await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").wipe());
3221
3285
  }
3222
3286
  /**
3223
3287
  * Closes this {@link CoreCrypto} instance and deallocates all loaded resources
@@ -3225,7 +3289,7 @@ class CoreCrypto {
3225
3289
  * **CAUTION**: This {@link CoreCrypto} instance won't be useable after a call to this method, but there's no way to express this requirement in TypeScript so you'll get errors instead!
3226
3290
  */
3227
3291
  async close() {
3228
- await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").close();
3292
+ await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").close());
3229
3293
  }
3230
3294
  /**
3231
3295
  * Registers the callbacks for CoreCrypto to use in order to gain additional information
@@ -3233,8 +3297,13 @@ class CoreCrypto {
3233
3297
  * @param callbacks - Any interface following the {@link CoreCryptoCallbacks} interface
3234
3298
  */
3235
3299
  registerCallbacks(callbacks) {
3236
- const wasmCallbacks = new (__classPrivateFieldGet(CoreCrypto, _a, "f", _CoreCrypto_module).CoreCryptoWasmCallbacks)(callbacks.authorize, callbacks.userAuthorize, callbacks.clientIsExistingGroupUser);
3237
- __classPrivateFieldGet(this, _CoreCrypto_cc, "f").set_callbacks(wasmCallbacks);
3300
+ try {
3301
+ const wasmCallbacks = new (__classPrivateFieldGet(CoreCrypto, _a, "f", _CoreCrypto_module).CoreCryptoWasmCallbacks)(callbacks.authorize, callbacks.userAuthorize, callbacks.clientIsExistingGroupUser);
3302
+ __classPrivateFieldGet(this, _CoreCrypto_cc, "f").set_callbacks(wasmCallbacks);
3303
+ }
3304
+ catch (e) {
3305
+ throw CoreCryptoError.fromStdError(e);
3306
+ }
3238
3307
  }
3239
3308
  /**
3240
3309
  * Checks if the Client is member of a given conversation and if the MLS Group is loaded up
@@ -3253,7 +3322,7 @@ class CoreCrypto {
3253
3322
  * ```
3254
3323
  */
3255
3324
  async conversationExists(conversationId) {
3256
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").conversation_exists(conversationId);
3325
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").conversation_exists(conversationId));
3257
3326
  }
3258
3327
  /**
3259
3328
  * Returns the current epoch of a conversation
@@ -3268,7 +3337,7 @@ class CoreCrypto {
3268
3337
  * ```
3269
3338
  */
3270
3339
  async conversationEpoch(conversationId) {
3271
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").conversation_epoch(conversationId);
3340
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").conversation_epoch(conversationId));
3272
3341
  }
3273
3342
  /**
3274
3343
  * Wipes and destroys the local storage of a given conversation / MLS group
@@ -3276,7 +3345,7 @@ class CoreCrypto {
3276
3345
  * @param conversationId - The ID of the conversation to remove
3277
3346
  */
3278
3347
  async wipeConversation(conversationId) {
3279
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").wipe_conversation(conversationId);
3348
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").wipe_conversation(conversationId));
3280
3349
  }
3281
3350
  /**
3282
3351
  * Creates a new conversation with the current client being the sole member
@@ -3289,10 +3358,15 @@ class CoreCrypto {
3289
3358
  * @param configuration.custom - {@link CustomConfiguration}
3290
3359
  */
3291
3360
  async createConversation(conversationId, configuration = {}) {
3292
- const { ciphersuite, externalSenders, custom = {} } = configuration || {};
3293
- const config = new (__classPrivateFieldGet(CoreCrypto, _a, "f", _CoreCrypto_module).ConversationConfiguration)(ciphersuite, externalSenders, custom?.keyRotationSpan);
3294
- const ret = await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").create_conversation(conversationId, config);
3295
- return ret;
3361
+ try {
3362
+ const { ciphersuite, externalSenders, custom = {} } = configuration || {};
3363
+ const config = new (__classPrivateFieldGet(CoreCrypto, _a, "f", _CoreCrypto_module).ConversationConfiguration)(ciphersuite, externalSenders, custom?.keyRotationSpan);
3364
+ const ret = await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").create_conversation(conversationId, config));
3365
+ return ret;
3366
+ }
3367
+ catch (e) {
3368
+ throw CoreCryptoError.fromStdError(e);
3369
+ }
3296
3370
  }
3297
3371
  /**
3298
3372
  * Decrypts a message for a given conversation
@@ -3303,19 +3377,24 @@ class CoreCrypto {
3303
3377
  * @returns a {@link DecryptedMessage}. Note that {@link DecryptedMessage#message} is `undefined` when the encrypted payload contains a system message such a proposal or commit
3304
3378
  */
3305
3379
  async decryptMessage(conversationId, payload) {
3306
- const ffiDecryptedMessage = await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").decrypt_message(conversationId, payload);
3307
- const commitDelay = ffiDecryptedMessage.commit_delay ?
3308
- ffiDecryptedMessage.commit_delay * 1000 :
3309
- undefined;
3310
- const ret = {
3311
- message: ffiDecryptedMessage.message,
3312
- proposals: ffiDecryptedMessage.proposals,
3313
- isActive: ffiDecryptedMessage.is_active,
3314
- senderClientId: ffiDecryptedMessage.sender_client_id,
3315
- commitDelay,
3316
- hasEpochChanged: ffiDecryptedMessage.has_epoch_changed,
3317
- };
3318
- return ret;
3380
+ try {
3381
+ const ffiDecryptedMessage = await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").decrypt_message(conversationId, payload));
3382
+ const commitDelay = ffiDecryptedMessage.commit_delay ?
3383
+ ffiDecryptedMessage.commit_delay * 1000 :
3384
+ undefined;
3385
+ const ret = {
3386
+ message: ffiDecryptedMessage.message,
3387
+ proposals: ffiDecryptedMessage.proposals,
3388
+ isActive: ffiDecryptedMessage.is_active,
3389
+ senderClientId: ffiDecryptedMessage.sender_client_id,
3390
+ commitDelay,
3391
+ hasEpochChanged: ffiDecryptedMessage.has_epoch_changed,
3392
+ };
3393
+ return ret;
3394
+ }
3395
+ catch (e) {
3396
+ throw CoreCryptoError.fromStdError(e);
3397
+ }
3319
3398
  }
3320
3399
  /**
3321
3400
  * Encrypts a message for a given conversation
@@ -3326,7 +3405,7 @@ class CoreCrypto {
3326
3405
  * @returns The encrypted payload for the given group. This needs to be fanned out to the other members of the group.
3327
3406
  */
3328
3407
  async encryptMessage(conversationId, message) {
3329
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").encrypt_message(conversationId, message);
3408
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").encrypt_message(conversationId, message));
3330
3409
  }
3331
3410
  /**
3332
3411
  * Ingest a TLS-serialized MLS welcome message to join an existing MLS group
@@ -3336,21 +3415,26 @@ class CoreCrypto {
3336
3415
  * @returns The conversation ID of the newly joined group. You can use the same ID to decrypt/encrypt messages
3337
3416
  */
3338
3417
  async processWelcomeMessage(welcomeMessage, configuration = {}) {
3339
- const { keyRotationSpan, wirePolicy } = configuration || {};
3340
- const config = new (__classPrivateFieldGet(CoreCrypto, _a, "f", _CoreCrypto_module).CustomConfiguration)(keyRotationSpan, wirePolicy);
3341
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").process_welcome_message(welcomeMessage, config);
3418
+ try {
3419
+ const { keyRotationSpan, wirePolicy } = configuration || {};
3420
+ const config = new (__classPrivateFieldGet(CoreCrypto, _a, "f", _CoreCrypto_module).CustomConfiguration)(keyRotationSpan, wirePolicy);
3421
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").process_welcome_message(welcomeMessage, config));
3422
+ }
3423
+ catch (e) {
3424
+ throw CoreCryptoError.fromStdError(e);
3425
+ }
3342
3426
  }
3343
3427
  /**
3344
3428
  * @returns The client's public key
3345
3429
  */
3346
3430
  async clientPublicKey() {
3347
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").client_public_key();
3431
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").client_public_key());
3348
3432
  }
3349
3433
  /**
3350
3434
  * @returns The amount of valid, non-expired KeyPackages that are persisted in the backing storage
3351
3435
  */
3352
3436
  async clientValidKeypackagesCount() {
3353
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").client_valid_keypackages_count();
3437
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").client_valid_keypackages_count());
3354
3438
  }
3355
3439
  /**
3356
3440
  * Fetches a requested amount of keypackages
@@ -3359,7 +3443,7 @@ class CoreCrypto {
3359
3443
  * @returns An array of length `amountRequested` containing TLS-serialized KeyPackages
3360
3444
  */
3361
3445
  async clientKeypackages(amountRequested) {
3362
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").client_keypackages(amountRequested);
3446
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").client_keypackages(amountRequested));
3363
3447
  }
3364
3448
  /**
3365
3449
  * Adds new clients to a conversation, assuming the current client has the right to add new clients to the conversation.
@@ -3374,20 +3458,25 @@ class CoreCrypto {
3374
3458
  * @returns A {@link CommitBundle}
3375
3459
  */
3376
3460
  async addClientsToConversation(conversationId, clients) {
3377
- const ffiClients = clients.map((invitee) => new (__classPrivateFieldGet(CoreCrypto, _a, "f", _CoreCrypto_module).Invitee)(invitee.id, invitee.kp));
3378
- const ffiRet = await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").add_clients_to_conversation(conversationId, ffiClients);
3379
- ffiClients.forEach(c => c.free());
3380
- const pgs = ffiRet.public_group_state;
3381
- const ret = {
3382
- welcome: ffiRet.welcome,
3383
- commit: ffiRet.commit,
3384
- publicGroupState: {
3385
- encryptionType: pgs.encryption_type,
3386
- ratchetTreeType: pgs.ratchet_tree_type,
3387
- payload: pgs.payload
3388
- },
3389
- };
3390
- return ret;
3461
+ try {
3462
+ const ffiClients = clients.map((invitee) => new (__classPrivateFieldGet(CoreCrypto, _a, "f", _CoreCrypto_module).Invitee)(invitee.id, invitee.kp));
3463
+ const ffiRet = await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").add_clients_to_conversation(conversationId, ffiClients));
3464
+ ffiClients.forEach(c => c.free());
3465
+ const pgs = ffiRet.public_group_state;
3466
+ const ret = {
3467
+ welcome: ffiRet.welcome,
3468
+ commit: ffiRet.commit,
3469
+ publicGroupState: {
3470
+ encryptionType: pgs.encryption_type,
3471
+ ratchetTreeType: pgs.ratchet_tree_type,
3472
+ payload: pgs.payload
3473
+ },
3474
+ };
3475
+ return ret;
3476
+ }
3477
+ catch (e) {
3478
+ throw CoreCryptoError.fromStdError(e);
3479
+ }
3391
3480
  }
3392
3481
  /**
3393
3482
  * Removes the provided clients from a conversation; Assuming those clients exist and the current client is allowed
@@ -3403,18 +3492,23 @@ class CoreCrypto {
3403
3492
  * @returns A {@link CommitBundle}
3404
3493
  */
3405
3494
  async removeClientsFromConversation(conversationId, clientIds) {
3406
- const ffiRet = await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").remove_clients_from_conversation(conversationId, clientIds);
3407
- const pgs = ffiRet.public_group_state;
3408
- const ret = {
3409
- welcome: ffiRet.welcome,
3410
- commit: ffiRet.commit,
3411
- publicGroupState: {
3412
- encryptionType: pgs.encryption_type,
3413
- ratchetTreeType: pgs.ratchet_tree_type,
3414
- payload: pgs.payload
3415
- },
3416
- };
3417
- return ret;
3495
+ try {
3496
+ const ffiRet = await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").remove_clients_from_conversation(conversationId, clientIds));
3497
+ const pgs = ffiRet.public_group_state;
3498
+ const ret = {
3499
+ welcome: ffiRet.welcome,
3500
+ commit: ffiRet.commit,
3501
+ publicGroupState: {
3502
+ encryptionType: pgs.encryption_type,
3503
+ ratchetTreeType: pgs.ratchet_tree_type,
3504
+ payload: pgs.payload
3505
+ },
3506
+ };
3507
+ return ret;
3508
+ }
3509
+ catch (e) {
3510
+ throw CoreCryptoError.fromStdError(e);
3511
+ }
3418
3512
  }
3419
3513
  /**
3420
3514
  * Creates an update commit which forces every client to update their keypackages in the conversation
@@ -3428,18 +3522,23 @@ class CoreCrypto {
3428
3522
  * @returns A {@link CommitBundle}
3429
3523
  */
3430
3524
  async updateKeyingMaterial(conversationId) {
3431
- const ffiRet = await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").update_keying_material(conversationId);
3432
- const pgs = ffiRet.public_group_state;
3433
- const ret = {
3434
- welcome: ffiRet.welcome,
3435
- commit: ffiRet.commit,
3436
- publicGroupState: {
3437
- encryptionType: pgs.encryption_type,
3438
- ratchetTreeType: pgs.ratchet_tree_type,
3439
- payload: pgs.payload
3440
- },
3441
- };
3442
- return ret;
3525
+ try {
3526
+ const ffiRet = await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").update_keying_material(conversationId));
3527
+ const pgs = ffiRet.public_group_state;
3528
+ const ret = {
3529
+ welcome: ffiRet.welcome,
3530
+ commit: ffiRet.commit,
3531
+ publicGroupState: {
3532
+ encryptionType: pgs.encryption_type,
3533
+ ratchetTreeType: pgs.ratchet_tree_type,
3534
+ payload: pgs.payload
3535
+ },
3536
+ };
3537
+ return ret;
3538
+ }
3539
+ catch (e) {
3540
+ throw CoreCryptoError.fromStdError(e);
3541
+ }
3443
3542
  }
3444
3543
  /**
3445
3544
  * Commits the local pending proposals and returns the {@link CommitBundle} object containing what can result from this operation.
@@ -3453,20 +3552,25 @@ class CoreCrypto {
3453
3552
  * @returns A {@link CommitBundle} or `undefined` when there was no pending proposal to commit
3454
3553
  */
3455
3554
  async commitPendingProposals(conversationId) {
3456
- const ffiCommitBundle = await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").commit_pending_proposals(conversationId);
3457
- if (!ffiCommitBundle) {
3458
- return undefined;
3555
+ try {
3556
+ const ffiCommitBundle = await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").commit_pending_proposals(conversationId));
3557
+ if (!ffiCommitBundle) {
3558
+ return undefined;
3559
+ }
3560
+ const pgs = ffiCommitBundle.public_group_state;
3561
+ return {
3562
+ welcome: ffiCommitBundle.welcome,
3563
+ commit: ffiCommitBundle.commit,
3564
+ publicGroupState: {
3565
+ encryptionType: pgs.encryption_type,
3566
+ ratchetTreeType: pgs.ratchet_tree_type,
3567
+ payload: pgs.payload
3568
+ },
3569
+ };
3570
+ }
3571
+ catch (e) {
3572
+ throw CoreCryptoError.fromStdError(e);
3459
3573
  }
3460
- const pgs = ffiCommitBundle.public_group_state;
3461
- return {
3462
- welcome: ffiCommitBundle.welcome,
3463
- commit: ffiCommitBundle.commit,
3464
- publicGroupState: {
3465
- encryptionType: pgs.encryption_type,
3466
- ratchetTreeType: pgs.ratchet_tree_type,
3467
- payload: pgs.payload
3468
- },
3469
- };
3470
3574
  }
3471
3575
  /**
3472
3576
  * Creates a new proposal for the provided Conversation ID
@@ -3482,16 +3586,16 @@ class CoreCrypto {
3482
3586
  if (!args.kp) {
3483
3587
  throw new Error("kp is not contained in the proposal arguments");
3484
3588
  }
3485
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").new_add_proposal(args.conversationId, args.kp);
3589
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").new_add_proposal(args.conversationId, args.kp));
3486
3590
  }
3487
3591
  case ProposalType.Remove: {
3488
3592
  if (!args.clientId) {
3489
3593
  throw new Error("clientId is not contained in the proposal arguments");
3490
3594
  }
3491
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").new_remove_proposal(args.conversationId, args.clientId);
3595
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").new_remove_proposal(args.conversationId, args.clientId));
3492
3596
  }
3493
3597
  case ProposalType.Update: {
3494
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").new_update_proposal(args.conversationId);
3598
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").new_update_proposal(args.conversationId));
3495
3599
  }
3496
3600
  default:
3497
3601
  throw new Error("Invalid proposal type!");
@@ -3500,13 +3604,13 @@ class CoreCrypto {
3500
3604
  async newExternalProposal(externalProposalType, args) {
3501
3605
  switch (externalProposalType) {
3502
3606
  case ExternalProposalType.Add: {
3503
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").new_external_add_proposal(args.conversationId, args.epoch);
3607
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").new_external_add_proposal(args.conversationId, args.epoch));
3504
3608
  }
3505
3609
  case ExternalProposalType.Remove: {
3506
3610
  if (!args.keyPackageRef) {
3507
3611
  throw new Error("keyPackageRef is not contained in the external proposal arguments");
3508
3612
  }
3509
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").new_external_remove_proposal(args.conversationId, args.epoch, args.keyPackageRef);
3613
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").new_external_remove_proposal(args.conversationId, args.epoch, args.keyPackageRef));
3510
3614
  }
3511
3615
  default:
3512
3616
  throw new Error("Invalid external proposal type!");
@@ -3519,7 +3623,7 @@ class CoreCrypto {
3519
3623
  * @returns TLS-serialized MLS public group state
3520
3624
  */
3521
3625
  async exportGroupState(conversationId) {
3522
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").export_group_state(conversationId);
3626
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").export_group_state(conversationId));
3523
3627
  }
3524
3628
  /**
3525
3629
  * Allows to create an external commit to "apply" to join a group through its public group state.
@@ -3536,20 +3640,25 @@ class CoreCrypto {
3536
3640
  * @returns see {@link ConversationInitBundle}
3537
3641
  */
3538
3642
  async joinByExternalCommit(publicGroupState, configuration = {}) {
3539
- const { keyRotationSpan, wirePolicy } = configuration || {};
3540
- const config = new (__classPrivateFieldGet(CoreCrypto, _a, "f", _CoreCrypto_module).CustomConfiguration)(keyRotationSpan, wirePolicy);
3541
- const ffiInitMessage = await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").join_by_external_commit(publicGroupState, config);
3542
- const pgs = ffiInitMessage.public_group_state;
3543
- const ret = {
3544
- conversationId: ffiInitMessage.conversation_id,
3545
- commit: ffiInitMessage.commit,
3546
- publicGroupState: {
3547
- encryptionType: pgs.encryption_type,
3548
- ratchetTreeType: pgs.ratchet_tree_type,
3549
- payload: pgs.payload
3550
- },
3551
- };
3552
- return ret;
3643
+ try {
3644
+ const { keyRotationSpan, wirePolicy } = configuration || {};
3645
+ const config = new (__classPrivateFieldGet(CoreCrypto, _a, "f", _CoreCrypto_module).CustomConfiguration)(keyRotationSpan, wirePolicy);
3646
+ const ffiInitMessage = await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").join_by_external_commit(publicGroupState, config));
3647
+ const pgs = ffiInitMessage.public_group_state;
3648
+ const ret = {
3649
+ conversationId: ffiInitMessage.conversation_id,
3650
+ commit: ffiInitMessage.commit,
3651
+ publicGroupState: {
3652
+ encryptionType: pgs.encryption_type,
3653
+ ratchetTreeType: pgs.ratchet_tree_type,
3654
+ payload: pgs.payload
3655
+ },
3656
+ };
3657
+ return ret;
3658
+ }
3659
+ catch (e) {
3660
+ throw CoreCryptoError.fromStdError(e);
3661
+ }
3553
3662
  }
3554
3663
  /**
3555
3664
  * This merges the commit generated by {@link CoreCrypto.joinByExternalCommit}, persists the group permanently
@@ -3558,7 +3667,7 @@ class CoreCrypto {
3558
3667
  * @param conversationId - The ID of the conversation
3559
3668
  */
3560
3669
  async mergePendingGroupFromExternalCommit(conversationId) {
3561
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").merge_pending_group_from_external_commit(conversationId);
3670
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").merge_pending_group_from_external_commit(conversationId));
3562
3671
  }
3563
3672
  /**
3564
3673
  * In case the external commit generated by {@link CoreCrypto.joinByExternalCommit} is rejected by the Delivery Service, and we
@@ -3568,7 +3677,7 @@ class CoreCrypto {
3568
3677
  * @param conversationId - The ID of the conversation
3569
3678
  */
3570
3679
  async clearPendingGroupFromExternalCommit(conversationId) {
3571
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").clear_pending_group_from_external_commit(conversationId);
3680
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").clear_pending_group_from_external_commit(conversationId));
3572
3681
  }
3573
3682
  /**
3574
3683
  * Allows to mark the latest commit produced as "accepted" and be able to safely merge it
@@ -3577,7 +3686,7 @@ class CoreCrypto {
3577
3686
  * @param conversationId - The group's ID
3578
3687
  */
3579
3688
  async commitAccepted(conversationId) {
3580
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").commit_accepted(conversationId);
3689
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").commit_accepted(conversationId));
3581
3690
  }
3582
3691
  /**
3583
3692
  * Allows to remove a pending proposal (rollback). Use this when backend rejects the proposal you just sent e.g. if permissions
@@ -3590,7 +3699,7 @@ class CoreCrypto {
3590
3699
  * @param proposalRef - A reference to the proposal to delete. You get one when using {@link CoreCrypto.newProposal}
3591
3700
  */
3592
3701
  async clearPendingProposal(conversationId, proposalRef) {
3593
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").clear_pending_proposal(conversationId, proposalRef);
3702
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").clear_pending_proposal(conversationId, proposalRef));
3594
3703
  }
3595
3704
  /**
3596
3705
  * Allows to remove a pending commit (rollback). Use this when backend rejects the commit you just sent e.g. if permissions
@@ -3604,7 +3713,7 @@ class CoreCrypto {
3604
3713
  * @param conversationId - The group's ID
3605
3714
  */
3606
3715
  async clearPendingCommit(conversationId) {
3607
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").clear_pending_commit(conversationId);
3716
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").clear_pending_commit(conversationId));
3608
3717
  }
3609
3718
  /**
3610
3719
  * Derives a new key from the group
@@ -3616,7 +3725,7 @@ class CoreCrypto {
3616
3725
  * @returns A `Uint8Array` representing the derived key
3617
3726
  */
3618
3727
  async exportSecretKey(conversationId, keyLength) {
3619
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").export_secret_key(conversationId, keyLength);
3728
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").export_secret_key(conversationId, keyLength));
3620
3729
  }
3621
3730
  /**
3622
3731
  * Returns all clients from group's members
@@ -3626,7 +3735,7 @@ class CoreCrypto {
3626
3735
  * @returns A list of clients from the members of the group
3627
3736
  */
3628
3737
  async getClientIds(conversationId) {
3629
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").get_client_ids(conversationId);
3738
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").get_client_ids(conversationId));
3630
3739
  }
3631
3740
  /**
3632
3741
  * Allows {@link CoreCrypto} to act as a CSPRNG provider
@@ -3637,7 +3746,7 @@ class CoreCrypto {
3637
3746
  * @returns A `Uint8Array` buffer that contains `length` cryptographically-secure random bytes
3638
3747
  */
3639
3748
  async randomBytes(length) {
3640
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").random_bytes(length);
3749
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").random_bytes(length));
3641
3750
  }
3642
3751
  /**
3643
3752
  * Allows to reseed {@link CoreCrypto}'s internal CSPRNG with a new seed.
@@ -3648,13 +3757,13 @@ class CoreCrypto {
3648
3757
  if (seed.length !== 32) {
3649
3758
  throw new Error(`The seed length needs to be exactly 32 bytes. ${seed.length} bytes provided.`);
3650
3759
  }
3651
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").reseed_rng(seed);
3760
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").reseed_rng(seed));
3652
3761
  }
3653
3762
  /**
3654
3763
  * Initiailizes the proteus client
3655
3764
  */
3656
3765
  async proteusInit() {
3657
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_init();
3766
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_init());
3658
3767
  }
3659
3768
  /**
3660
3769
  * Create a Proteus session using a prekey
@@ -3663,7 +3772,7 @@ class CoreCrypto {
3663
3772
  * @param prekey - CBOR-encoded Proteus prekey of the other client
3664
3773
  */
3665
3774
  async proteusSessionFromPrekey(sessionId, prekey) {
3666
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_session_from_prekey(sessionId, prekey);
3775
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_session_from_prekey(sessionId, prekey));
3667
3776
  }
3668
3777
  /**
3669
3778
  * Create a Proteus session from a handshake message
@@ -3674,7 +3783,7 @@ class CoreCrypto {
3674
3783
  * @returns A `Uint8Array` containing the message that was sent along with the session handshake
3675
3784
  */
3676
3785
  async proteusSessionFromMessage(sessionId, envelope) {
3677
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_session_from_message(sessionId, envelope);
3786
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_session_from_message(sessionId, envelope));
3678
3787
  }
3679
3788
  /**
3680
3789
  * Locally persists a session to the keystore
@@ -3684,7 +3793,7 @@ class CoreCrypto {
3684
3793
  * @param sessionId - ID of the Proteus session
3685
3794
  */
3686
3795
  async proteusSessionSave(sessionId) {
3687
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_session_save(sessionId);
3796
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_session_save(sessionId));
3688
3797
  }
3689
3798
  /**
3690
3799
  * Deletes a session
@@ -3693,7 +3802,7 @@ class CoreCrypto {
3693
3802
  * @param sessionId - ID of the Proteus session
3694
3803
  */
3695
3804
  async proteusSessionDelete(sessionId) {
3696
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_session_delete(sessionId);
3805
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_session_delete(sessionId));
3697
3806
  }
3698
3807
  /**
3699
3808
  * Checks if a session exists
@@ -3703,7 +3812,7 @@ class CoreCrypto {
3703
3812
  * @returns whether the session exists or not
3704
3813
  */
3705
3814
  async proteusSessionExists(sessionId) {
3706
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_session_exists(sessionId);
3815
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_session_exists(sessionId));
3707
3816
  }
3708
3817
  /**
3709
3818
  * Decrypt an incoming message for an existing Proteus session
@@ -3713,7 +3822,7 @@ class CoreCrypto {
3713
3822
  * @returns The decrypted payload contained within the message
3714
3823
  */
3715
3824
  async proteusDecrypt(sessionId, ciphertext) {
3716
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_decrypt(sessionId, ciphertext);
3825
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_decrypt(sessionId, ciphertext));
3717
3826
  }
3718
3827
  /**
3719
3828
  * Encrypt a message for a given Proteus session
@@ -3723,7 +3832,7 @@ class CoreCrypto {
3723
3832
  * @returns The CBOR-serialized encrypted message
3724
3833
  */
3725
3834
  async proteusEncrypt(sessionId, plaintext) {
3726
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_encrypt(sessionId, plaintext);
3835
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_encrypt(sessionId, plaintext));
3727
3836
  }
3728
3837
  /**
3729
3838
  * Batch encryption for proteus messages
@@ -3734,7 +3843,7 @@ class CoreCrypto {
3734
3843
  * @returns A map indexed by each session ID and the corresponding CBOR-serialized encrypted message for this session
3735
3844
  */
3736
3845
  async proteusEncryptBatched(sessions, plaintext) {
3737
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_encrypt_batched(sessions, plaintext);
3846
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_encrypt_batched(sessions, plaintext));
3738
3847
  }
3739
3848
  /**
3740
3849
  * Creates a new prekey with the requested ID.
@@ -3743,7 +3852,7 @@ class CoreCrypto {
3743
3852
  * @returns: A CBOR-serialized version of the PreKeyBundle corresponding to the newly generated and stored PreKey
3744
3853
  */
3745
3854
  async proteusNewPrekey(prekeyId) {
3746
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_new_prekey(prekeyId);
3855
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_new_prekey(prekeyId));
3747
3856
  }
3748
3857
  /**
3749
3858
  * Creates a new prekey with an automatically generated ID..
@@ -3751,7 +3860,7 @@ class CoreCrypto {
3751
3860
  * @returns: A CBOR-serialized version of the PreKeyBundle corresponding to the newly generated and stored PreKey
3752
3861
  */
3753
3862
  async proteusNewPrekeyAuto() {
3754
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_new_prekey_auto();
3863
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_new_prekey_auto());
3755
3864
  }
3756
3865
  /**
3757
3866
  * Proteus public key fingerprint
@@ -3760,7 +3869,7 @@ class CoreCrypto {
3760
3869
  * @returns Hex-encoded public key string
3761
3870
  */
3762
3871
  async proteusFingerprint() {
3763
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_fingerprint();
3872
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_fingerprint());
3764
3873
  }
3765
3874
  /**
3766
3875
  * Proteus session local fingerprint
@@ -3769,7 +3878,7 @@ class CoreCrypto {
3769
3878
  * @returns Hex-encoded public key string
3770
3879
  */
3771
3880
  async proteusFingerprintLocal(sessionId) {
3772
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_fingerprint_local(sessionId);
3881
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_fingerprint_local(sessionId));
3773
3882
  }
3774
3883
  /**
3775
3884
  * Proteus session remote fingerprint
@@ -3778,7 +3887,7 @@ class CoreCrypto {
3778
3887
  * @returns Hex-encoded public key string
3779
3888
  */
3780
3889
  async proteusFingerprintRemote(sessionId) {
3781
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_fingerprint_remote(sessionId);
3890
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_fingerprint_remote(sessionId));
3782
3891
  }
3783
3892
  /**
3784
3893
  * Hex-encoded fingerprint of the given prekey
@@ -3787,7 +3896,12 @@ class CoreCrypto {
3787
3896
  * @returns Hex-encoded public key string
3788
3897
  **/
3789
3898
  static proteusFingerprintPrekeybundle(prekey) {
3790
- return __classPrivateFieldGet(this, _a, "f", _CoreCrypto_module).CoreCrypto.proteus_fingerprint_prekeybundle(prekey);
3899
+ try {
3900
+ return __classPrivateFieldGet(this, _a, "f", _CoreCrypto_module).CoreCrypto.proteus_fingerprint_prekeybundle(prekey);
3901
+ }
3902
+ catch (e) {
3903
+ throw CoreCryptoError.fromStdError(e);
3904
+ }
3791
3905
  }
3792
3906
  /**
3793
3907
  * Imports all the data stored by Cryptobox into the CoreCrypto keystore
@@ -3795,7 +3909,14 @@ class CoreCrypto {
3795
3909
  * @param storeName - The name of the IndexedDB store where the data is stored
3796
3910
  */
3797
3911
  async proteusCryptoboxMigrate(storeName) {
3798
- return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_cryptobox_migrate(storeName);
3912
+ return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_cryptobox_migrate(storeName));
3913
+ }
3914
+ /**
3915
+ * Note: this call clears out the code and resets it to 0 (aka no error)
3916
+ * @returns the last proteus error code that occured.
3917
+ */
3918
+ async proteusLastErrorCode() {
3919
+ return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_last_error_code();
3799
3920
  }
3800
3921
  /**
3801
3922
  * Creates an enrollment instance with private key material you can use in order to fetch
@@ -3806,8 +3927,8 @@ class CoreCrypto {
3806
3927
  * @param ciphersuite - For generating signing key material. Only {@link Ciphersuite.MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519} is supported currently
3807
3928
  */
3808
3929
  async newAcmeEnrollment() {
3809
- const e2ei = await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").new_acme_enrollment(Ciphersuite.MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519);
3810
- return new WireE2eIdentity(e2ei, __classPrivateFieldGet(CoreCrypto, _a, "f", _CoreCrypto_module));
3930
+ const e2ei = await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").new_acme_enrollment(Ciphersuite.MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519));
3931
+ return new WireE2eIdentity(e2ei);
3811
3932
  }
3812
3933
  /**
3813
3934
  * Returns the current version of {@link CoreCrypto}
@@ -3826,13 +3947,10 @@ _a = CoreCrypto, _CoreCrypto_cc = new WeakMap();
3826
3947
  _CoreCrypto_module = { value: void 0 };
3827
3948
  class WireE2eIdentity {
3828
3949
  /** @hidden */
3829
- constructor(e2ei, module) {
3950
+ constructor(e2ei) {
3830
3951
  /** @hidden */
3831
3952
  _WireE2eIdentity_e2ei.set(this, void 0);
3832
3953
  __classPrivateFieldSet(this, _WireE2eIdentity_e2ei, e2ei, "f");
3833
- if (!__classPrivateFieldGet(WireE2eIdentity, _b, "f", _WireE2eIdentity_module)) {
3834
- __classPrivateFieldSet(WireE2eIdentity, _b, module, "f", _WireE2eIdentity_module);
3835
- }
3836
3954
  }
3837
3955
  /**
3838
3956
  * Parses the response from `GET /acme/{provisioner-name}/directory`.
@@ -3843,7 +3961,12 @@ class WireE2eIdentity {
3843
3961
  * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.1.1
3844
3962
  */
3845
3963
  directoryResponse(directory) {
3846
- return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").directory_response(directory);
3964
+ try {
3965
+ return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").directory_response(directory);
3966
+ }
3967
+ catch (e) {
3968
+ throw CoreCryptoError.fromStdError(e);
3969
+ }
3847
3970
  }
3848
3971
  /**
3849
3972
  * For creating a new acme account. This returns a signed JWS-alike request body to send to
@@ -3854,7 +3977,12 @@ class WireE2eIdentity {
3854
3977
  * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.3
3855
3978
  */
3856
3979
  newAccountRequest(directory, previousNonce) {
3857
- return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_account_request(directory, previousNonce);
3980
+ try {
3981
+ return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_account_request(directory, previousNonce);
3982
+ }
3983
+ catch (e) {
3984
+ throw CoreCryptoError.fromStdError(e);
3985
+ }
3858
3986
  }
3859
3987
  /**
3860
3988
  * Parses the response from `POST /acme/{provisioner-name}/new-account`.
@@ -3862,7 +3990,12 @@ class WireE2eIdentity {
3862
3990
  * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.3
3863
3991
  */
3864
3992
  newAccountResponse(account) {
3865
- return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_account_response(account);
3993
+ try {
3994
+ return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_account_response(account);
3995
+ }
3996
+ catch (e) {
3997
+ throw CoreCryptoError.fromStdError(e);
3998
+ }
3866
3999
  }
3867
4000
  /**
3868
4001
  * Creates a new acme order for the handle (userId + display name) and the clientId.
@@ -3876,7 +4009,12 @@ class WireE2eIdentity {
3876
4009
  * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4
3877
4010
  */
3878
4011
  newOrderRequest(handle, clientId, expiryDays, directory, account, previousNonce) {
3879
- return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_order_request(handle, clientId, expiryDays, directory, account, previousNonce);
4012
+ try {
4013
+ return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_order_request(handle, clientId, expiryDays, directory, account, previousNonce);
4014
+ }
4015
+ catch (e) {
4016
+ throw CoreCryptoError.fromStdError(e);
4017
+ }
3880
4018
  }
3881
4019
  /**
3882
4020
  * Parses the response from `POST /acme/{provisioner-name}/new-order`.
@@ -3885,7 +4023,12 @@ class WireE2eIdentity {
3885
4023
  * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4
3886
4024
  */
3887
4025
  newOrderResponse(order) {
3888
- return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_order_response(order);
4026
+ try {
4027
+ return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_order_response(order);
4028
+ }
4029
+ catch (e) {
4030
+ throw CoreCryptoError.fromStdError(e);
4031
+ }
3889
4032
  }
3890
4033
  /**
3891
4034
  * Creates a new authorization request.
@@ -3897,7 +4040,12 @@ class WireE2eIdentity {
3897
4040
  * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.5
3898
4041
  */
3899
4042
  newAuthzRequest(url, account, previousNonce) {
3900
- return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_authz_request(url, account, previousNonce);
4043
+ try {
4044
+ return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_authz_request(url, account, previousNonce);
4045
+ }
4046
+ catch (e) {
4047
+ throw CoreCryptoError.fromStdError(e);
4048
+ }
3901
4049
  }
3902
4050
  /**
3903
4051
  * Parses the response from `POST /acme/{provisioner-name}/authz/{authz-id}`
@@ -3910,7 +4058,12 @@ class WireE2eIdentity {
3910
4058
  * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.5
3911
4059
  */
3912
4060
  newAuthzResponse(authz) {
3913
- return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_authz_response(authz);
4061
+ try {
4062
+ return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_authz_response(authz);
4063
+ }
4064
+ catch (e) {
4065
+ throw CoreCryptoError.fromStdError(e);
4066
+ }
3914
4067
  }
3915
4068
  /**
3916
4069
  * Generates a new client Dpop JWT token. It demonstrates proof of possession of the nonces
@@ -3929,7 +4082,12 @@ class WireE2eIdentity {
3929
4082
  * @param expiryDays token expiry in days
3930
4083
  */
3931
4084
  createDpopToken(accessTokenUrl, userId, clientId, domain, clientIdChallenge, backendNonce, expiryDays) {
3932
- return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").create_dpop_token(accessTokenUrl, userId, clientId, domain, clientIdChallenge, backendNonce, expiryDays);
4085
+ try {
4086
+ return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").create_dpop_token(accessTokenUrl, userId, clientId, domain, clientIdChallenge, backendNonce, expiryDays);
4087
+ }
4088
+ catch (e) {
4089
+ throw CoreCryptoError.fromStdError(e);
4090
+ }
3933
4091
  }
3934
4092
  /**
3935
4093
  * Creates a new challenge request.
@@ -3940,7 +4098,12 @@ class WireE2eIdentity {
3940
4098
  * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.5.1
3941
4099
  */
3942
4100
  newChallengeRequest(handleChallenge, account, previousNonce) {
3943
- return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_challenge_request(handleChallenge, account, previousNonce);
4101
+ try {
4102
+ return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_challenge_request(handleChallenge, account, previousNonce);
4103
+ }
4104
+ catch (e) {
4105
+ throw CoreCryptoError.fromStdError(e);
4106
+ }
3944
4107
  }
3945
4108
  /**
3946
4109
  * Parses the response from `POST /acme/{provisioner-name}/challenge/{challenge-id}`.
@@ -3949,7 +4112,12 @@ class WireE2eIdentity {
3949
4112
  * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.5.1
3950
4113
  */
3951
4114
  newChallengeResponse(challenge) {
3952
- return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_challenge_response(challenge);
4115
+ try {
4116
+ return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_challenge_response(challenge);
4117
+ }
4118
+ catch (e) {
4119
+ throw CoreCryptoError.fromStdError(e);
4120
+ }
3953
4121
  }
3954
4122
  /**
3955
4123
  * Verifies that the previous challenge has been completed.
@@ -3960,7 +4128,12 @@ class WireE2eIdentity {
3960
4128
  * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4
3961
4129
  */
3962
4130
  checkOrderRequest(orderUrl, account, previousNonce) {
3963
- return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").check_order_request(orderUrl, account, previousNonce);
4131
+ try {
4132
+ return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").check_order_request(orderUrl, account, previousNonce);
4133
+ }
4134
+ catch (e) {
4135
+ throw CoreCryptoError.fromStdError(e);
4136
+ }
3964
4137
  }
3965
4138
  /**
3966
4139
  * Parses the response from `POST /acme/{provisioner-name}/order/{order-id}`.
@@ -3969,7 +4142,12 @@ class WireE2eIdentity {
3969
4142
  * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4
3970
4143
  */
3971
4144
  checkOrderResponse(order) {
3972
- return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").check_order_response(order);
4145
+ try {
4146
+ return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").check_order_response(order);
4147
+ }
4148
+ catch (e) {
4149
+ throw CoreCryptoError.fromStdError(e);
4150
+ }
3973
4151
  }
3974
4152
  /**
3975
4153
  * Final step before fetching the certificate.
@@ -3981,7 +4159,12 @@ class WireE2eIdentity {
3981
4159
  * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4
3982
4160
  */
3983
4161
  finalizeRequest(domains, order, account, previousNonce) {
3984
- return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").finalize_request(domains, order, account, previousNonce);
4162
+ try {
4163
+ return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").finalize_request(domains, order, account, previousNonce);
4164
+ }
4165
+ catch (e) {
4166
+ throw CoreCryptoError.fromStdError(e);
4167
+ }
3985
4168
  }
3986
4169
  /**
3987
4170
  * Parses the response from `POST /acme/{provisioner-name}/order/{order-id}/finalize`.
@@ -3990,7 +4173,12 @@ class WireE2eIdentity {
3990
4173
  * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4
3991
4174
  */
3992
4175
  finalizeResponse(finalize) {
3993
- return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").finalize_response(finalize);
4176
+ try {
4177
+ return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").finalize_response(finalize);
4178
+ }
4179
+ catch (e) {
4180
+ throw CoreCryptoError.fromStdError(e);
4181
+ }
3994
4182
  }
3995
4183
  /**
3996
4184
  * Creates a request for finally fetching the x509 certificate.
@@ -4001,7 +4189,12 @@ class WireE2eIdentity {
4001
4189
  * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4.2
4002
4190
  */
4003
4191
  certificateRequest(finalize, account, previousNonce) {
4004
- return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").certificate_request(finalize, account, previousNonce);
4192
+ try {
4193
+ return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").certificate_request(finalize, account, previousNonce);
4194
+ }
4195
+ catch (e) {
4196
+ throw CoreCryptoError.fromStdError(e);
4197
+ }
4005
4198
  }
4006
4199
  /**
4007
4200
  * Parses the response from `POST /acme/{provisioner-name}/certificate/{certificate-id}`.
@@ -4010,11 +4203,14 @@ class WireE2eIdentity {
4010
4203
  * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4.2
4011
4204
  */
4012
4205
  certificateResponse(certificateChain) {
4013
- return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").certificate_response(certificateChain);
4206
+ try {
4207
+ return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").certificate_response(certificateChain);
4208
+ }
4209
+ catch (e) {
4210
+ throw CoreCryptoError.fromStdError(e);
4211
+ }
4014
4212
  }
4015
4213
  }
4016
- _b = WireE2eIdentity, _WireE2eIdentity_e2ei = new WeakMap();
4017
- /** @hidden */
4018
- _WireE2eIdentity_module = { value: void 0 };
4214
+ _WireE2eIdentity_e2ei = new WeakMap();
4019
4215
 
4020
- export { Ciphersuite, CoreCrypto, ExternalProposalType, ProposalType, PublicGroupStateEncryptionType, RatchetTreeType, WireE2eIdentity, WirePolicy };
4216
+ export { Ciphersuite, CoreCrypto, CoreCryptoError, ExternalProposalType, ProposalType, PublicGroupStateEncryptionType, RatchetTreeType, WireE2eIdentity, WirePolicy };