@wireapp/core-crypto 0.4.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +674 -0
- package/README.md +118 -0
- package/package.json +63 -0
- package/platforms/web/.gitkeep +0 -0
- package/platforms/web/assets/core_crypto_ffi-0df6a73f.wasm +0 -0
- package/platforms/web/corecrypto.d.ts +644 -0
- package/platforms/web/corecrypto.js +2315 -0
- package/platforms/web/es2017/assets/core_crypto_ffi-e63ef1c1.wasm +0 -0
- package/platforms/web/es2017/corecrypto.d.ts +644 -0
- package/platforms/web/es2017/corecrypto.js +2284 -0
- package/platforms/web/es2019/assets/core_crypto_ffi-e63ef1c1.wasm +0 -0
- package/platforms/web/es2019/corecrypto.d.ts +644 -0
- package/platforms/web/es2019/corecrypto.js +2284 -0
@@ -0,0 +1,2284 @@
|
|
1
|
+
let wasm$1;
|
2
|
+
|
3
|
+
const heap = new Array(32).fill(undefined);
|
4
|
+
|
5
|
+
heap.push(undefined, null, true, false);
|
6
|
+
|
7
|
+
function getObject(idx) { return heap[idx]; }
|
8
|
+
|
9
|
+
let heap_next = heap.length;
|
10
|
+
|
11
|
+
function addHeapObject(obj) {
|
12
|
+
if (heap_next === heap.length) heap.push(heap.length + 1);
|
13
|
+
const idx = heap_next;
|
14
|
+
heap_next = heap[idx];
|
15
|
+
|
16
|
+
heap[idx] = obj;
|
17
|
+
return idx;
|
18
|
+
}
|
19
|
+
|
20
|
+
function dropObject(idx) {
|
21
|
+
if (idx < 36) return;
|
22
|
+
heap[idx] = heap_next;
|
23
|
+
heap_next = idx;
|
24
|
+
}
|
25
|
+
|
26
|
+
function takeObject(idx) {
|
27
|
+
const ret = getObject(idx);
|
28
|
+
dropObject(idx);
|
29
|
+
return ret;
|
30
|
+
}
|
31
|
+
|
32
|
+
const cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
|
33
|
+
|
34
|
+
cachedTextDecoder.decode();
|
35
|
+
|
36
|
+
let cachedUint8Memory0 = new Uint8Array();
|
37
|
+
|
38
|
+
function getUint8Memory0() {
|
39
|
+
if (cachedUint8Memory0.byteLength === 0) {
|
40
|
+
cachedUint8Memory0 = new Uint8Array(wasm$1.memory.buffer);
|
41
|
+
}
|
42
|
+
return cachedUint8Memory0;
|
43
|
+
}
|
44
|
+
|
45
|
+
function getStringFromWasm0(ptr, len) {
|
46
|
+
return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
|
47
|
+
}
|
48
|
+
|
49
|
+
function isLikeNone(x) {
|
50
|
+
return x === undefined || x === null;
|
51
|
+
}
|
52
|
+
|
53
|
+
let cachedFloat64Memory0 = new Float64Array();
|
54
|
+
|
55
|
+
function getFloat64Memory0() {
|
56
|
+
if (cachedFloat64Memory0.byteLength === 0) {
|
57
|
+
cachedFloat64Memory0 = new Float64Array(wasm$1.memory.buffer);
|
58
|
+
}
|
59
|
+
return cachedFloat64Memory0;
|
60
|
+
}
|
61
|
+
|
62
|
+
let cachedInt32Memory0 = new Int32Array();
|
63
|
+
|
64
|
+
function getInt32Memory0() {
|
65
|
+
if (cachedInt32Memory0.byteLength === 0) {
|
66
|
+
cachedInt32Memory0 = new Int32Array(wasm$1.memory.buffer);
|
67
|
+
}
|
68
|
+
return cachedInt32Memory0;
|
69
|
+
}
|
70
|
+
|
71
|
+
let WASM_VECTOR_LEN = 0;
|
72
|
+
|
73
|
+
const cachedTextEncoder = new TextEncoder('utf-8');
|
74
|
+
|
75
|
+
const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
|
76
|
+
? function (arg, view) {
|
77
|
+
return cachedTextEncoder.encodeInto(arg, view);
|
78
|
+
}
|
79
|
+
: function (arg, view) {
|
80
|
+
const buf = cachedTextEncoder.encode(arg);
|
81
|
+
view.set(buf);
|
82
|
+
return {
|
83
|
+
read: arg.length,
|
84
|
+
written: buf.length
|
85
|
+
};
|
86
|
+
});
|
87
|
+
|
88
|
+
function passStringToWasm0(arg, malloc, realloc) {
|
89
|
+
|
90
|
+
if (realloc === undefined) {
|
91
|
+
const buf = cachedTextEncoder.encode(arg);
|
92
|
+
const ptr = malloc(buf.length);
|
93
|
+
getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
|
94
|
+
WASM_VECTOR_LEN = buf.length;
|
95
|
+
return ptr;
|
96
|
+
}
|
97
|
+
|
98
|
+
let len = arg.length;
|
99
|
+
let ptr = malloc(len);
|
100
|
+
|
101
|
+
const mem = getUint8Memory0();
|
102
|
+
|
103
|
+
let offset = 0;
|
104
|
+
|
105
|
+
for (; offset < len; offset++) {
|
106
|
+
const code = arg.charCodeAt(offset);
|
107
|
+
if (code > 0x7F) break;
|
108
|
+
mem[ptr + offset] = code;
|
109
|
+
}
|
110
|
+
|
111
|
+
if (offset !== len) {
|
112
|
+
if (offset !== 0) {
|
113
|
+
arg = arg.slice(offset);
|
114
|
+
}
|
115
|
+
ptr = realloc(ptr, len, len = offset + arg.length * 3);
|
116
|
+
const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
|
117
|
+
const ret = encodeString(arg, view);
|
118
|
+
|
119
|
+
offset += ret.written;
|
120
|
+
}
|
121
|
+
|
122
|
+
WASM_VECTOR_LEN = offset;
|
123
|
+
return ptr;
|
124
|
+
}
|
125
|
+
|
126
|
+
function debugString(val) {
|
127
|
+
// primitive types
|
128
|
+
const type = typeof val;
|
129
|
+
if (type == 'number' || type == 'boolean' || val == null) {
|
130
|
+
return `${val}`;
|
131
|
+
}
|
132
|
+
if (type == 'string') {
|
133
|
+
return `"${val}"`;
|
134
|
+
}
|
135
|
+
if (type == 'symbol') {
|
136
|
+
const description = val.description;
|
137
|
+
if (description == null) {
|
138
|
+
return 'Symbol';
|
139
|
+
} else {
|
140
|
+
return `Symbol(${description})`;
|
141
|
+
}
|
142
|
+
}
|
143
|
+
if (type == 'function') {
|
144
|
+
const name = val.name;
|
145
|
+
if (typeof name == 'string' && name.length > 0) {
|
146
|
+
return `Function(${name})`;
|
147
|
+
} else {
|
148
|
+
return 'Function';
|
149
|
+
}
|
150
|
+
}
|
151
|
+
// objects
|
152
|
+
if (Array.isArray(val)) {
|
153
|
+
const length = val.length;
|
154
|
+
let debug = '[';
|
155
|
+
if (length > 0) {
|
156
|
+
debug += debugString(val[0]);
|
157
|
+
}
|
158
|
+
for(let i = 1; i < length; i++) {
|
159
|
+
debug += ', ' + debugString(val[i]);
|
160
|
+
}
|
161
|
+
debug += ']';
|
162
|
+
return debug;
|
163
|
+
}
|
164
|
+
// Test for built-in
|
165
|
+
const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
|
166
|
+
let className;
|
167
|
+
if (builtInMatches.length > 1) {
|
168
|
+
className = builtInMatches[1];
|
169
|
+
} else {
|
170
|
+
// Failed to match the standard '[object ClassName]'
|
171
|
+
return toString.call(val);
|
172
|
+
}
|
173
|
+
if (className == 'Object') {
|
174
|
+
// we're a user defined class or Object
|
175
|
+
// JSON.stringify avoids problems with cycles, and is generally much
|
176
|
+
// easier than looping through ownProperties of `val`.
|
177
|
+
try {
|
178
|
+
return 'Object(' + JSON.stringify(val) + ')';
|
179
|
+
} catch (_) {
|
180
|
+
return 'Object';
|
181
|
+
}
|
182
|
+
}
|
183
|
+
// errors
|
184
|
+
if (val instanceof Error) {
|
185
|
+
return `${val.name}: ${val.message}\n${val.stack}`;
|
186
|
+
}
|
187
|
+
// TODO we could test for more things here, like `Set`s and `Map`s.
|
188
|
+
return className;
|
189
|
+
}
|
190
|
+
|
191
|
+
function makeMutClosure(arg0, arg1, dtor, f) {
|
192
|
+
const state = { a: arg0, b: arg1, cnt: 1, dtor };
|
193
|
+
const real = (...args) => {
|
194
|
+
// First up with a closure we increment the internal reference
|
195
|
+
// count. This ensures that the Rust closure environment won't
|
196
|
+
// be deallocated while we're invoking it.
|
197
|
+
state.cnt++;
|
198
|
+
const a = state.a;
|
199
|
+
state.a = 0;
|
200
|
+
try {
|
201
|
+
return f(a, state.b, ...args);
|
202
|
+
} finally {
|
203
|
+
if (--state.cnt === 0) {
|
204
|
+
wasm$1.__wbindgen_export_2.get(state.dtor)(a, state.b);
|
205
|
+
|
206
|
+
} else {
|
207
|
+
state.a = a;
|
208
|
+
}
|
209
|
+
}
|
210
|
+
};
|
211
|
+
real.original = state;
|
212
|
+
|
213
|
+
return real;
|
214
|
+
}
|
215
|
+
function __wbg_adapter_40(arg0, arg1, arg2) {
|
216
|
+
try {
|
217
|
+
const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
|
218
|
+
wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hfa283dadb011e75c(retptr, arg0, arg1, addHeapObject(arg2));
|
219
|
+
var r0 = getInt32Memory0()[retptr / 4 + 0];
|
220
|
+
var r1 = getInt32Memory0()[retptr / 4 + 1];
|
221
|
+
if (r1) {
|
222
|
+
throw takeObject(r0);
|
223
|
+
}
|
224
|
+
} finally {
|
225
|
+
wasm$1.__wbindgen_add_to_stack_pointer(16);
|
226
|
+
}
|
227
|
+
}
|
228
|
+
|
229
|
+
function __wbg_adapter_43(arg0, arg1, arg2) {
|
230
|
+
wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h04f9c855c75e5606(arg0, arg1, addHeapObject(arg2));
|
231
|
+
}
|
232
|
+
|
233
|
+
/**
|
234
|
+
* @returns {string}
|
235
|
+
*/
|
236
|
+
function version() {
|
237
|
+
try {
|
238
|
+
const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
|
239
|
+
wasm$1.version(retptr);
|
240
|
+
var r0 = getInt32Memory0()[retptr / 4 + 0];
|
241
|
+
var r1 = getInt32Memory0()[retptr / 4 + 1];
|
242
|
+
return getStringFromWasm0(r0, r1);
|
243
|
+
} finally {
|
244
|
+
wasm$1.__wbindgen_add_to_stack_pointer(16);
|
245
|
+
wasm$1.__wbindgen_free(r0, r1);
|
246
|
+
}
|
247
|
+
}
|
248
|
+
|
249
|
+
function passArray8ToWasm0(arg, malloc) {
|
250
|
+
const ptr = malloc(arg.length * 1);
|
251
|
+
getUint8Memory0().set(arg, ptr / 1);
|
252
|
+
WASM_VECTOR_LEN = arg.length;
|
253
|
+
return ptr;
|
254
|
+
}
|
255
|
+
|
256
|
+
function _assertClass(instance, klass) {
|
257
|
+
if (!(instance instanceof klass)) {
|
258
|
+
throw new Error(`expected instance of ${klass.name}`);
|
259
|
+
}
|
260
|
+
return instance.ptr;
|
261
|
+
}
|
262
|
+
|
263
|
+
let cachedUint32Memory0 = new Uint32Array();
|
264
|
+
|
265
|
+
function getUint32Memory0() {
|
266
|
+
if (cachedUint32Memory0.byteLength === 0) {
|
267
|
+
cachedUint32Memory0 = new Uint32Array(wasm$1.memory.buffer);
|
268
|
+
}
|
269
|
+
return cachedUint32Memory0;
|
270
|
+
}
|
271
|
+
|
272
|
+
function passArrayJsValueToWasm0(array, malloc) {
|
273
|
+
const ptr = malloc(array.length * 4);
|
274
|
+
const mem = getUint32Memory0();
|
275
|
+
for (let i = 0; i < array.length; i++) {
|
276
|
+
mem[ptr / 4 + i] = addHeapObject(array[i]);
|
277
|
+
}
|
278
|
+
WASM_VECTOR_LEN = array.length;
|
279
|
+
return ptr;
|
280
|
+
}
|
281
|
+
|
282
|
+
function handleError(f, args) {
|
283
|
+
try {
|
284
|
+
return f.apply(this, args);
|
285
|
+
} catch (e) {
|
286
|
+
wasm$1.__wbindgen_exn_store(addHeapObject(e));
|
287
|
+
}
|
288
|
+
}
|
289
|
+
|
290
|
+
function getArrayU8FromWasm0(ptr, len) {
|
291
|
+
return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
|
292
|
+
}
|
293
|
+
function __wbg_adapter_176(arg0, arg1, arg2, arg3) {
|
294
|
+
wasm$1.wasm_bindgen__convert__closures__invoke2_mut__h4791cbe418449d5d(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
|
295
|
+
}
|
296
|
+
|
297
|
+
/**
|
298
|
+
* see [core_crypto::prelude::CiphersuiteName]
|
299
|
+
*/
|
300
|
+
const Ciphersuite = Object.freeze({
|
301
|
+
/**
|
302
|
+
* DH KEM x25519 | AES-GCM 128 | SHA2-256 | Ed25519
|
303
|
+
*/
|
304
|
+
MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519:1,"1":"MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519",
|
305
|
+
/**
|
306
|
+
* DH KEM P256 | AES-GCM 128 | SHA2-256 | EcDSA P256
|
307
|
+
*/
|
308
|
+
MLS_128_DHKEMP256_AES128GCM_SHA256_P256:2,"2":"MLS_128_DHKEMP256_AES128GCM_SHA256_P256",
|
309
|
+
/**
|
310
|
+
* DH KEM x25519 | Chacha20Poly1305 | SHA2-256 | Ed25519
|
311
|
+
*/
|
312
|
+
MLS_128_DHKEMX25519_CHACHA20POLY1305_SHA256_Ed25519:3,"3":"MLS_128_DHKEMX25519_CHACHA20POLY1305_SHA256_Ed25519",
|
313
|
+
/**
|
314
|
+
* DH KEM x448 | AES-GCM 256 | SHA2-512 | Ed448
|
315
|
+
*/
|
316
|
+
MLS_256_DHKEMX448_AES256GCM_SHA512_Ed448:4,"4":"MLS_256_DHKEMX448_AES256GCM_SHA512_Ed448",
|
317
|
+
/**
|
318
|
+
* DH KEM P521 | AES-GCM 256 | SHA2-512 | EcDSA P521
|
319
|
+
*/
|
320
|
+
MLS_256_DHKEMP521_AES256GCM_SHA512_P521:5,"5":"MLS_256_DHKEMP521_AES256GCM_SHA512_P521",
|
321
|
+
/**
|
322
|
+
* DH KEM x448 | Chacha20Poly1305 | SHA2-512 | Ed448
|
323
|
+
*/
|
324
|
+
MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448:6,"6":"MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448",
|
325
|
+
/**
|
326
|
+
* DH KEM P384 | AES-GCM 256 | SHA2-384 | EcDSA P384
|
327
|
+
*/
|
328
|
+
MLS_256_DHKEMP384_AES256GCM_SHA384_P384:7,"7":"MLS_256_DHKEMP384_AES256GCM_SHA384_P384", });
|
329
|
+
/**
|
330
|
+
*/
|
331
|
+
class CommitBundle {
|
332
|
+
|
333
|
+
__destroy_into_raw() {
|
334
|
+
const ptr = this.ptr;
|
335
|
+
this.ptr = 0;
|
336
|
+
|
337
|
+
return ptr;
|
338
|
+
}
|
339
|
+
|
340
|
+
free() {
|
341
|
+
const ptr = this.__destroy_into_raw();
|
342
|
+
wasm$1.__wbg_commitbundle_free(ptr);
|
343
|
+
}
|
344
|
+
/**
|
345
|
+
* @returns {Uint8Array}
|
346
|
+
*/
|
347
|
+
get commit() {
|
348
|
+
const ret = wasm$1.commitbundle_commit(this.ptr);
|
349
|
+
return takeObject(ret);
|
350
|
+
}
|
351
|
+
/**
|
352
|
+
* @returns {Uint8Array | undefined}
|
353
|
+
*/
|
354
|
+
get welcome() {
|
355
|
+
const ret = wasm$1.commitbundle_welcome(this.ptr);
|
356
|
+
return takeObject(ret);
|
357
|
+
}
|
358
|
+
/**
|
359
|
+
* @returns {Uint8Array}
|
360
|
+
*/
|
361
|
+
get public_group_state() {
|
362
|
+
const ret = wasm$1.commitbundle_public_group_state(this.ptr);
|
363
|
+
return takeObject(ret);
|
364
|
+
}
|
365
|
+
}
|
366
|
+
/**
|
367
|
+
* see [core_crypto::prelude::MlsConversationConfiguration]
|
368
|
+
*/
|
369
|
+
class ConversationConfiguration {
|
370
|
+
|
371
|
+
static __wrap(ptr) {
|
372
|
+
const obj = Object.create(ConversationConfiguration.prototype);
|
373
|
+
obj.ptr = ptr;
|
374
|
+
|
375
|
+
return obj;
|
376
|
+
}
|
377
|
+
|
378
|
+
__destroy_into_raw() {
|
379
|
+
const ptr = this.ptr;
|
380
|
+
this.ptr = 0;
|
381
|
+
|
382
|
+
return ptr;
|
383
|
+
}
|
384
|
+
|
385
|
+
free() {
|
386
|
+
const ptr = this.__destroy_into_raw();
|
387
|
+
wasm$1.__wbg_conversationconfiguration_free(ptr);
|
388
|
+
}
|
389
|
+
/**
|
390
|
+
* @param {(Uint8Array)[] | undefined} admins
|
391
|
+
* @param {number | undefined} ciphersuite
|
392
|
+
* @param {number | undefined} key_rotation_span
|
393
|
+
* @param {(Uint8Array)[] | undefined} external_senders
|
394
|
+
*/
|
395
|
+
constructor(admins, ciphersuite, key_rotation_span, external_senders) {
|
396
|
+
var ptr0 = isLikeNone(admins) ? 0 : passArrayJsValueToWasm0(admins, wasm$1.__wbindgen_malloc);
|
397
|
+
var len0 = WASM_VECTOR_LEN;
|
398
|
+
var ptr1 = isLikeNone(external_senders) ? 0 : passArrayJsValueToWasm0(external_senders, wasm$1.__wbindgen_malloc);
|
399
|
+
var len1 = WASM_VECTOR_LEN;
|
400
|
+
const ret = wasm$1.conversationconfiguration_new(ptr0, len0, isLikeNone(ciphersuite) ? 8 : ciphersuite, !isLikeNone(key_rotation_span), isLikeNone(key_rotation_span) ? 0 : key_rotation_span, ptr1, len1);
|
401
|
+
return ConversationConfiguration.__wrap(ret);
|
402
|
+
}
|
403
|
+
}
|
404
|
+
/**
|
405
|
+
*/
|
406
|
+
class CoreCrypto$1 {
|
407
|
+
|
408
|
+
static __wrap(ptr) {
|
409
|
+
const obj = Object.create(CoreCrypto$1.prototype);
|
410
|
+
obj.ptr = ptr;
|
411
|
+
|
412
|
+
return obj;
|
413
|
+
}
|
414
|
+
|
415
|
+
__destroy_into_raw() {
|
416
|
+
const ptr = this.ptr;
|
417
|
+
this.ptr = 0;
|
418
|
+
|
419
|
+
return ptr;
|
420
|
+
}
|
421
|
+
|
422
|
+
free() {
|
423
|
+
const ptr = this.__destroy_into_raw();
|
424
|
+
wasm$1.__wbg_corecrypto_free(ptr);
|
425
|
+
}
|
426
|
+
/**
|
427
|
+
* see [core_crypto::MlsCentral::try_new]
|
428
|
+
* @param {string} path
|
429
|
+
* @param {string} key
|
430
|
+
* @param {string} client_id
|
431
|
+
* @param {Uint8Array | undefined} entropy_seed
|
432
|
+
* @returns {Promise<CoreCrypto>}
|
433
|
+
*/
|
434
|
+
static _internal_new(path, key, client_id, entropy_seed) {
|
435
|
+
const ptr0 = passStringToWasm0(path, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
|
436
|
+
const len0 = WASM_VECTOR_LEN;
|
437
|
+
const ptr1 = passStringToWasm0(key, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
|
438
|
+
const len1 = WASM_VECTOR_LEN;
|
439
|
+
const ptr2 = passStringToWasm0(client_id, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
|
440
|
+
const len2 = WASM_VECTOR_LEN;
|
441
|
+
var ptr3 = isLikeNone(entropy_seed) ? 0 : passArray8ToWasm0(entropy_seed, wasm$1.__wbindgen_malloc);
|
442
|
+
var len3 = WASM_VECTOR_LEN;
|
443
|
+
const ret = wasm$1.corecrypto__internal_new(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
|
444
|
+
return takeObject(ret);
|
445
|
+
}
|
446
|
+
/**
|
447
|
+
* Returns: [`WasmCryptoResult<()>`]
|
448
|
+
*
|
449
|
+
* see [core_crypto::MlsCentral::close]
|
450
|
+
* @returns {Promise<any>}
|
451
|
+
*/
|
452
|
+
close() {
|
453
|
+
const ptr = this.__destroy_into_raw();
|
454
|
+
const ret = wasm$1.corecrypto_close(ptr);
|
455
|
+
return takeObject(ret);
|
456
|
+
}
|
457
|
+
/**
|
458
|
+
* Returns: [`WasmCryptoResult<()>`]
|
459
|
+
*
|
460
|
+
* see [core_crypto::MlsCentral::wipe]
|
461
|
+
* @returns {Promise<any>}
|
462
|
+
*/
|
463
|
+
wipe() {
|
464
|
+
const ptr = this.__destroy_into_raw();
|
465
|
+
const ret = wasm$1.corecrypto_wipe(ptr);
|
466
|
+
return takeObject(ret);
|
467
|
+
}
|
468
|
+
/**
|
469
|
+
* Returns: [`WasmCryptoResult<()>`]
|
470
|
+
*
|
471
|
+
* see [core_crypto::MlsCentral::callbacks]
|
472
|
+
* @param {CoreCryptoWasmCallbacks} callbacks
|
473
|
+
* @returns {Promise<any>}
|
474
|
+
*/
|
475
|
+
set_callbacks(callbacks) {
|
476
|
+
_assertClass(callbacks, CoreCryptoWasmCallbacks);
|
477
|
+
var ptr0 = callbacks.ptr;
|
478
|
+
callbacks.ptr = 0;
|
479
|
+
const ret = wasm$1.corecrypto_set_callbacks(this.ptr, ptr0);
|
480
|
+
return takeObject(ret);
|
481
|
+
}
|
482
|
+
/**
|
483
|
+
* Returns:: [`WasmCryptoResult<js_sys::Uint8Array>`]
|
484
|
+
*
|
485
|
+
* see [core_crypto::MlsCentral::client_public_key]
|
486
|
+
* @returns {Promise<any>}
|
487
|
+
*/
|
488
|
+
client_public_key() {
|
489
|
+
const ret = wasm$1.corecrypto_client_public_key(this.ptr);
|
490
|
+
return takeObject(ret);
|
491
|
+
}
|
492
|
+
/**
|
493
|
+
* Returns: [`WasmCryptoResult<js_sys::Array<js_sys::Uint8Array>>`]
|
494
|
+
*
|
495
|
+
* see [core_crypto::MlsCentral::client_keypackages]
|
496
|
+
* @param {number} amount_requested
|
497
|
+
* @returns {Promise<any>}
|
498
|
+
*/
|
499
|
+
client_keypackages(amount_requested) {
|
500
|
+
const ret = wasm$1.corecrypto_client_keypackages(this.ptr, amount_requested);
|
501
|
+
return takeObject(ret);
|
502
|
+
}
|
503
|
+
/**
|
504
|
+
* Returns: [`WasmCryptoResult<usize>`]
|
505
|
+
*
|
506
|
+
* see [core_crypto::MlsCentral::client_valid_keypackages_count]
|
507
|
+
* @returns {Promise<any>}
|
508
|
+
*/
|
509
|
+
client_valid_keypackages_count() {
|
510
|
+
const ret = wasm$1.corecrypto_client_valid_keypackages_count(this.ptr);
|
511
|
+
return takeObject(ret);
|
512
|
+
}
|
513
|
+
/**
|
514
|
+
* Returns: [`WasmCryptoResult<()>`]
|
515
|
+
*
|
516
|
+
* see [core_crypto::MlsCentral::new_conversation]
|
517
|
+
* @param {Uint8Array} conversation_id
|
518
|
+
* @param {ConversationConfiguration} config
|
519
|
+
* @returns {Promise<any>}
|
520
|
+
*/
|
521
|
+
create_conversation(conversation_id, config) {
|
522
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
523
|
+
const len0 = WASM_VECTOR_LEN;
|
524
|
+
_assertClass(config, ConversationConfiguration);
|
525
|
+
var ptr1 = config.ptr;
|
526
|
+
config.ptr = 0;
|
527
|
+
const ret = wasm$1.corecrypto_create_conversation(this.ptr, ptr0, len0, ptr1);
|
528
|
+
return takeObject(ret);
|
529
|
+
}
|
530
|
+
/**
|
531
|
+
* Returns [`WasmCryptoResult<u64>`]
|
532
|
+
*
|
533
|
+
* see [core_crypto::MlsCentral::conversation_epoch]
|
534
|
+
* @param {Uint8Array} conversation_id
|
535
|
+
* @returns {Promise<any>}
|
536
|
+
*/
|
537
|
+
conversation_epoch(conversation_id) {
|
538
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
539
|
+
const len0 = WASM_VECTOR_LEN;
|
540
|
+
const ret = wasm$1.corecrypto_conversation_epoch(this.ptr, ptr0, len0);
|
541
|
+
return takeObject(ret);
|
542
|
+
}
|
543
|
+
/**
|
544
|
+
* Returns: [`bool`]
|
545
|
+
*
|
546
|
+
* see [core_crypto::MlsCentral::conversation_exists]
|
547
|
+
* @param {Uint8Array} conversation_id
|
548
|
+
* @returns {Promise<any>}
|
549
|
+
*/
|
550
|
+
conversation_exists(conversation_id) {
|
551
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
552
|
+
const len0 = WASM_VECTOR_LEN;
|
553
|
+
const ret = wasm$1.corecrypto_conversation_exists(this.ptr, ptr0, len0);
|
554
|
+
return takeObject(ret);
|
555
|
+
}
|
556
|
+
/**
|
557
|
+
* Returns: [`WasmCryptoResult<Uint8Array>`]
|
558
|
+
*
|
559
|
+
* see [core_crypto::MlsCentral::process_raw_welcome_message]
|
560
|
+
* @param {Uint8Array} welcome_message
|
561
|
+
* @returns {Promise<any>}
|
562
|
+
*/
|
563
|
+
process_welcome_message(welcome_message) {
|
564
|
+
const ptr0 = passArray8ToWasm0(welcome_message, wasm$1.__wbindgen_malloc);
|
565
|
+
const len0 = WASM_VECTOR_LEN;
|
566
|
+
const ret = wasm$1.corecrypto_process_welcome_message(this.ptr, ptr0, len0);
|
567
|
+
return takeObject(ret);
|
568
|
+
}
|
569
|
+
/**
|
570
|
+
* Returns: [`WasmCryptoResult<Option<MemberAddedMessages>>`]
|
571
|
+
*
|
572
|
+
* see [core_crypto::MlsCentral::add_members_to_conversation]
|
573
|
+
* @param {Uint8Array} conversation_id
|
574
|
+
* @param {any[]} clients
|
575
|
+
* @returns {Promise<any>}
|
576
|
+
*/
|
577
|
+
add_clients_to_conversation(conversation_id, clients) {
|
578
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
579
|
+
const len0 = WASM_VECTOR_LEN;
|
580
|
+
const ptr1 = passArrayJsValueToWasm0(clients, wasm$1.__wbindgen_malloc);
|
581
|
+
const len1 = WASM_VECTOR_LEN;
|
582
|
+
const ret = wasm$1.corecrypto_add_clients_to_conversation(this.ptr, ptr0, len0, ptr1, len1);
|
583
|
+
return takeObject(ret);
|
584
|
+
}
|
585
|
+
/**
|
586
|
+
* Returns: [`WasmCryptoResult<Option<js_sys::Uint8Array>>`]
|
587
|
+
*
|
588
|
+
* see [core_crypto::MlsCentral::remove_members_from_conversation]
|
589
|
+
* @param {Uint8Array} conversation_id
|
590
|
+
* @param {(Uint8Array)[]} clients
|
591
|
+
* @returns {Promise<any>}
|
592
|
+
*/
|
593
|
+
remove_clients_from_conversation(conversation_id, clients) {
|
594
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
595
|
+
const len0 = WASM_VECTOR_LEN;
|
596
|
+
const ptr1 = passArrayJsValueToWasm0(clients, wasm$1.__wbindgen_malloc);
|
597
|
+
const len1 = WASM_VECTOR_LEN;
|
598
|
+
const ret = wasm$1.corecrypto_remove_clients_from_conversation(this.ptr, ptr0, len0, ptr1, len1);
|
599
|
+
return takeObject(ret);
|
600
|
+
}
|
601
|
+
/**
|
602
|
+
* Returns: [`WasmCryptoResult<CommitBundle>`]
|
603
|
+
*
|
604
|
+
* see [core_crypto::MlsCentral::update_keying_material]
|
605
|
+
* @param {Uint8Array} conversation_id
|
606
|
+
* @returns {Promise<any>}
|
607
|
+
*/
|
608
|
+
update_keying_material(conversation_id) {
|
609
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
610
|
+
const len0 = WASM_VECTOR_LEN;
|
611
|
+
const ret = wasm$1.corecrypto_update_keying_material(this.ptr, ptr0, len0);
|
612
|
+
return takeObject(ret);
|
613
|
+
}
|
614
|
+
/**
|
615
|
+
* see [core_crypto::MlsCentral::commit_pending_proposals]
|
616
|
+
* @param {Uint8Array} conversation_id
|
617
|
+
* @returns {Promise<any>}
|
618
|
+
*/
|
619
|
+
commit_pending_proposals(conversation_id) {
|
620
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
621
|
+
const len0 = WASM_VECTOR_LEN;
|
622
|
+
const ret = wasm$1.corecrypto_commit_pending_proposals(this.ptr, ptr0, len0);
|
623
|
+
return takeObject(ret);
|
624
|
+
}
|
625
|
+
/**
|
626
|
+
* Returns: [`WasmCryptoResult<Option<MemberAddedMessages>>`]
|
627
|
+
*
|
628
|
+
* see [core_crypto::MlsCentral::add_members_to_conversation]
|
629
|
+
* @param {Uint8Array} conversation_id
|
630
|
+
* @param {any[]} clients
|
631
|
+
* @returns {Promise<any>}
|
632
|
+
*/
|
633
|
+
final_add_clients_to_conversation(conversation_id, clients) {
|
634
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
635
|
+
const len0 = WASM_VECTOR_LEN;
|
636
|
+
const ptr1 = passArrayJsValueToWasm0(clients, wasm$1.__wbindgen_malloc);
|
637
|
+
const len1 = WASM_VECTOR_LEN;
|
638
|
+
const ret = wasm$1.corecrypto_final_add_clients_to_conversation(this.ptr, ptr0, len0, ptr1, len1);
|
639
|
+
return takeObject(ret);
|
640
|
+
}
|
641
|
+
/**
|
642
|
+
* Returns: [`WasmCryptoResult<Option<js_sys::Uint8Array>>`]
|
643
|
+
*
|
644
|
+
* see [core_crypto::MlsCentral::remove_members_from_conversation]
|
645
|
+
* @param {Uint8Array} conversation_id
|
646
|
+
* @param {(Uint8Array)[]} clients
|
647
|
+
* @returns {Promise<any>}
|
648
|
+
*/
|
649
|
+
final_remove_clients_from_conversation(conversation_id, clients) {
|
650
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
651
|
+
const len0 = WASM_VECTOR_LEN;
|
652
|
+
const ptr1 = passArrayJsValueToWasm0(clients, wasm$1.__wbindgen_malloc);
|
653
|
+
const len1 = WASM_VECTOR_LEN;
|
654
|
+
const ret = wasm$1.corecrypto_final_remove_clients_from_conversation(this.ptr, ptr0, len0, ptr1, len1);
|
655
|
+
return takeObject(ret);
|
656
|
+
}
|
657
|
+
/**
|
658
|
+
* Returns: [`WasmCryptoResult<CommitBundle>`]
|
659
|
+
*
|
660
|
+
* see [core_crypto::MlsCentral::update_keying_material]
|
661
|
+
* @param {Uint8Array} conversation_id
|
662
|
+
* @returns {Promise<any>}
|
663
|
+
*/
|
664
|
+
final_update_keying_material(conversation_id) {
|
665
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
666
|
+
const len0 = WASM_VECTOR_LEN;
|
667
|
+
const ret = wasm$1.corecrypto_final_update_keying_material(this.ptr, ptr0, len0);
|
668
|
+
return takeObject(ret);
|
669
|
+
}
|
670
|
+
/**
|
671
|
+
* see [core_crypto::MlsCentral::commit_pending_proposals]
|
672
|
+
* @param {Uint8Array} conversation_id
|
673
|
+
* @returns {Promise<any>}
|
674
|
+
*/
|
675
|
+
final_commit_pending_proposals(conversation_id) {
|
676
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
677
|
+
const len0 = WASM_VECTOR_LEN;
|
678
|
+
const ret = wasm$1.corecrypto_final_commit_pending_proposals(this.ptr, ptr0, len0);
|
679
|
+
return takeObject(ret);
|
680
|
+
}
|
681
|
+
/**
|
682
|
+
* Returns: [`WasmCryptoResult<()>`]
|
683
|
+
*
|
684
|
+
* see [core_crypto::MlsCentral::wipe_conversation]
|
685
|
+
* @param {Uint8Array} conversation_id
|
686
|
+
* @returns {Promise<any>}
|
687
|
+
*/
|
688
|
+
wipe_conversation(conversation_id) {
|
689
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
690
|
+
const len0 = WASM_VECTOR_LEN;
|
691
|
+
const ret = wasm$1.corecrypto_wipe_conversation(this.ptr, ptr0, len0);
|
692
|
+
return takeObject(ret);
|
693
|
+
}
|
694
|
+
/**
|
695
|
+
* Returns: [`WasmCryptoResult<DecryptedMessage>`]
|
696
|
+
*
|
697
|
+
* see [core_crypto::MlsCentral::decrypt_message]
|
698
|
+
* @param {Uint8Array} conversation_id
|
699
|
+
* @param {Uint8Array} payload
|
700
|
+
* @returns {Promise<any>}
|
701
|
+
*/
|
702
|
+
decrypt_message(conversation_id, payload) {
|
703
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
704
|
+
const len0 = WASM_VECTOR_LEN;
|
705
|
+
const ptr1 = passArray8ToWasm0(payload, wasm$1.__wbindgen_malloc);
|
706
|
+
const len1 = WASM_VECTOR_LEN;
|
707
|
+
const ret = wasm$1.corecrypto_decrypt_message(this.ptr, ptr0, len0, ptr1, len1);
|
708
|
+
return takeObject(ret);
|
709
|
+
}
|
710
|
+
/**
|
711
|
+
* Returns: [`WasmCryptoResult<Uint8Array>`]
|
712
|
+
*
|
713
|
+
* see [core_crypto::MlsCentral::encrypt_message]
|
714
|
+
* @param {Uint8Array} conversation_id
|
715
|
+
* @param {Uint8Array} message
|
716
|
+
* @returns {Promise<any>}
|
717
|
+
*/
|
718
|
+
encrypt_message(conversation_id, message) {
|
719
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
720
|
+
const len0 = WASM_VECTOR_LEN;
|
721
|
+
const ptr1 = passArray8ToWasm0(message, wasm$1.__wbindgen_malloc);
|
722
|
+
const len1 = WASM_VECTOR_LEN;
|
723
|
+
const ret = wasm$1.corecrypto_encrypt_message(this.ptr, ptr0, len0, ptr1, len1);
|
724
|
+
return takeObject(ret);
|
725
|
+
}
|
726
|
+
/**
|
727
|
+
* Returns: [`WasmCryptoResult<js_sys::Uint8Array>`]
|
728
|
+
*
|
729
|
+
* see [core_crypto::MlsCentral::new_proposal]
|
730
|
+
* @param {Uint8Array} conversation_id
|
731
|
+
* @param {Uint8Array} keypackage
|
732
|
+
* @returns {Promise<any>}
|
733
|
+
*/
|
734
|
+
new_add_proposal(conversation_id, keypackage) {
|
735
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
736
|
+
const len0 = WASM_VECTOR_LEN;
|
737
|
+
const ptr1 = passArray8ToWasm0(keypackage, wasm$1.__wbindgen_malloc);
|
738
|
+
const len1 = WASM_VECTOR_LEN;
|
739
|
+
const ret = wasm$1.corecrypto_new_add_proposal(this.ptr, ptr0, len0, ptr1, len1);
|
740
|
+
return takeObject(ret);
|
741
|
+
}
|
742
|
+
/**
|
743
|
+
* Returns: [`WasmCryptoResult<js_sys::Uint8Array>`]
|
744
|
+
*
|
745
|
+
* see [core_crypto::MlsCentral::new_proposal]
|
746
|
+
* @param {Uint8Array} conversation_id
|
747
|
+
* @returns {Promise<any>}
|
748
|
+
*/
|
749
|
+
new_update_proposal(conversation_id) {
|
750
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
751
|
+
const len0 = WASM_VECTOR_LEN;
|
752
|
+
const ret = wasm$1.corecrypto_new_update_proposal(this.ptr, ptr0, len0);
|
753
|
+
return takeObject(ret);
|
754
|
+
}
|
755
|
+
/**
|
756
|
+
* Returns: [`WasmCryptoResult<js_sys::Uint8Array>`]
|
757
|
+
*
|
758
|
+
* see [core_crypto::MlsCentral::new_proposal]
|
759
|
+
* @param {Uint8Array} conversation_id
|
760
|
+
* @param {Uint8Array} client_id
|
761
|
+
* @returns {Promise<any>}
|
762
|
+
*/
|
763
|
+
new_remove_proposal(conversation_id, client_id) {
|
764
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
765
|
+
const len0 = WASM_VECTOR_LEN;
|
766
|
+
const ptr1 = passArray8ToWasm0(client_id, wasm$1.__wbindgen_malloc);
|
767
|
+
const len1 = WASM_VECTOR_LEN;
|
768
|
+
const ret = wasm$1.corecrypto_new_remove_proposal(this.ptr, ptr0, len0, ptr1, len1);
|
769
|
+
return takeObject(ret);
|
770
|
+
}
|
771
|
+
/**
|
772
|
+
* Returns: [`WasmCryptoResult<js_sys::Uint8Array>`]
|
773
|
+
*
|
774
|
+
* see [core_crypto::MlsCentral::new_external_add_proposal]
|
775
|
+
* @param {Uint8Array} conversation_id
|
776
|
+
* @param {number} epoch
|
777
|
+
* @returns {Promise<any>}
|
778
|
+
*/
|
779
|
+
new_external_add_proposal(conversation_id, epoch) {
|
780
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
781
|
+
const len0 = WASM_VECTOR_LEN;
|
782
|
+
const ret = wasm$1.corecrypto_new_external_add_proposal(this.ptr, ptr0, len0, epoch);
|
783
|
+
return takeObject(ret);
|
784
|
+
}
|
785
|
+
/**
|
786
|
+
* Returns: [`WasmCryptoResult<js_sys::Uint8Array>`]
|
787
|
+
*
|
788
|
+
* see [core_crypto::MlsCentral::new_external_remove_proposal]
|
789
|
+
* @param {Uint8Array} conversation_id
|
790
|
+
* @param {number} epoch
|
791
|
+
* @param {Uint8Array} keypackage_ref
|
792
|
+
* @returns {Promise<any>}
|
793
|
+
*/
|
794
|
+
new_external_remove_proposal(conversation_id, epoch, keypackage_ref) {
|
795
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
796
|
+
const len0 = WASM_VECTOR_LEN;
|
797
|
+
const ptr1 = passArray8ToWasm0(keypackage_ref, wasm$1.__wbindgen_malloc);
|
798
|
+
const len1 = WASM_VECTOR_LEN;
|
799
|
+
const ret = wasm$1.corecrypto_new_external_remove_proposal(this.ptr, ptr0, len0, epoch, ptr1, len1);
|
800
|
+
return takeObject(ret);
|
801
|
+
}
|
802
|
+
/**
|
803
|
+
* Returns: [`WasmCryptoResult<js_sys::Uint8Array>`]
|
804
|
+
*
|
805
|
+
* see [core_crypto::MlsCentral::export_public_group_state]
|
806
|
+
* @param {Uint8Array} conversation_id
|
807
|
+
* @returns {Promise<any>}
|
808
|
+
*/
|
809
|
+
export_group_state(conversation_id) {
|
810
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
811
|
+
const len0 = WASM_VECTOR_LEN;
|
812
|
+
const ret = wasm$1.corecrypto_export_group_state(this.ptr, ptr0, len0);
|
813
|
+
return takeObject(ret);
|
814
|
+
}
|
815
|
+
/**
|
816
|
+
* Returns: [`WasmCryptoResult<MlsConversationInitMessage>`]
|
817
|
+
*
|
818
|
+
* see [core_crypto::MlsCentral::join_by_external_commit]
|
819
|
+
* @param {Uint8Array} group_state
|
820
|
+
* @returns {Promise<any>}
|
821
|
+
*/
|
822
|
+
join_by_external_commit(group_state) {
|
823
|
+
const ptr0 = passArray8ToWasm0(group_state, wasm$1.__wbindgen_malloc);
|
824
|
+
const len0 = WASM_VECTOR_LEN;
|
825
|
+
const ret = wasm$1.corecrypto_join_by_external_commit(this.ptr, ptr0, len0);
|
826
|
+
return takeObject(ret);
|
827
|
+
}
|
828
|
+
/**
|
829
|
+
* Returns: [`WasmCryptoResult<()>`]
|
830
|
+
*
|
831
|
+
* see [core_crypto::MlsCentral::merge_pending_group_from_external_commit]
|
832
|
+
* @param {Uint8Array} conversation_id
|
833
|
+
* @param {ConversationConfiguration} configuration
|
834
|
+
* @returns {Promise<any>}
|
835
|
+
*/
|
836
|
+
merge_pending_group_from_external_commit(conversation_id, configuration) {
|
837
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
838
|
+
const len0 = WASM_VECTOR_LEN;
|
839
|
+
_assertClass(configuration, ConversationConfiguration);
|
840
|
+
var ptr1 = configuration.ptr;
|
841
|
+
configuration.ptr = 0;
|
842
|
+
const ret = wasm$1.corecrypto_merge_pending_group_from_external_commit(this.ptr, ptr0, len0, ptr1);
|
843
|
+
return takeObject(ret);
|
844
|
+
}
|
845
|
+
/**
|
846
|
+
* see [core_crypto::MlsCentral::commit_accepted]
|
847
|
+
* @param {Uint8Array} conversation_id
|
848
|
+
* @returns {Promise<any>}
|
849
|
+
*/
|
850
|
+
commit_accepted(conversation_id) {
|
851
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
852
|
+
const len0 = WASM_VECTOR_LEN;
|
853
|
+
const ret = wasm$1.corecrypto_commit_accepted(this.ptr, ptr0, len0);
|
854
|
+
return takeObject(ret);
|
855
|
+
}
|
856
|
+
/**
|
857
|
+
* see [core_crypto::MlsCentral::clear_pending_proposal]
|
858
|
+
* @param {Uint8Array} conversation_id
|
859
|
+
* @param {Uint8Array} proposal_ref
|
860
|
+
* @returns {Promise<any>}
|
861
|
+
*/
|
862
|
+
clear_pending_proposal(conversation_id, proposal_ref) {
|
863
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
864
|
+
const len0 = WASM_VECTOR_LEN;
|
865
|
+
const ptr1 = passArray8ToWasm0(proposal_ref, wasm$1.__wbindgen_malloc);
|
866
|
+
const len1 = WASM_VECTOR_LEN;
|
867
|
+
const ret = wasm$1.corecrypto_clear_pending_proposal(this.ptr, ptr0, len0, ptr1, len1);
|
868
|
+
return takeObject(ret);
|
869
|
+
}
|
870
|
+
/**
|
871
|
+
* see [core_crypto::MlsCentral::clear_pending_commit]
|
872
|
+
* @param {Uint8Array} conversation_id
|
873
|
+
* @returns {Promise<any>}
|
874
|
+
*/
|
875
|
+
clear_pending_commit(conversation_id) {
|
876
|
+
const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
|
877
|
+
const len0 = WASM_VECTOR_LEN;
|
878
|
+
const ret = wasm$1.corecrypto_clear_pending_commit(this.ptr, ptr0, len0);
|
879
|
+
return takeObject(ret);
|
880
|
+
}
|
881
|
+
/**
|
882
|
+
* Returns: [`WasmCryptoResult<js_sys::Uint8Array>`]
|
883
|
+
*
|
884
|
+
* see [core_crypto::MlsCentral::random_bytes]
|
885
|
+
* @param {number} len
|
886
|
+
* @returns {Promise<any>}
|
887
|
+
*/
|
888
|
+
random_bytes(len) {
|
889
|
+
const ret = wasm$1.corecrypto_random_bytes(this.ptr, len);
|
890
|
+
return takeObject(ret);
|
891
|
+
}
|
892
|
+
/**
|
893
|
+
* Returns: [`WasmCryptoResult<()>`]
|
894
|
+
*
|
895
|
+
* see [mls_crypto_provider::MlsCryptoProvider::reseed]
|
896
|
+
* @param {Uint8Array} seed
|
897
|
+
* @returns {Promise<any>}
|
898
|
+
*/
|
899
|
+
reseed_rng(seed) {
|
900
|
+
const ptr0 = passArray8ToWasm0(seed, wasm$1.__wbindgen_malloc);
|
901
|
+
const len0 = WASM_VECTOR_LEN;
|
902
|
+
const ret = wasm$1.corecrypto_reseed_rng(this.ptr, ptr0, len0);
|
903
|
+
return takeObject(ret);
|
904
|
+
}
|
905
|
+
}
|
906
|
+
/**
|
907
|
+
* see [core_crypto::prelude::CoreCryptoCallbacks]
|
908
|
+
*/
|
909
|
+
class CoreCryptoWasmCallbacks {
|
910
|
+
|
911
|
+
static __wrap(ptr) {
|
912
|
+
const obj = Object.create(CoreCryptoWasmCallbacks.prototype);
|
913
|
+
obj.ptr = ptr;
|
914
|
+
|
915
|
+
return obj;
|
916
|
+
}
|
917
|
+
|
918
|
+
__destroy_into_raw() {
|
919
|
+
const ptr = this.ptr;
|
920
|
+
this.ptr = 0;
|
921
|
+
|
922
|
+
return ptr;
|
923
|
+
}
|
924
|
+
|
925
|
+
free() {
|
926
|
+
const ptr = this.__destroy_into_raw();
|
927
|
+
wasm$1.__wbg_corecryptowasmcallbacks_free(ptr);
|
928
|
+
}
|
929
|
+
/**
|
930
|
+
* @param {Function} authorize
|
931
|
+
* @param {Function} is_user_in_group
|
932
|
+
*/
|
933
|
+
constructor(authorize, is_user_in_group) {
|
934
|
+
const ret = wasm$1.corecryptowasmcallbacks_new(addHeapObject(authorize), addHeapObject(is_user_in_group));
|
935
|
+
return CoreCryptoWasmCallbacks.__wrap(ret);
|
936
|
+
}
|
937
|
+
}
|
938
|
+
/**
|
939
|
+
* see [core_crypto::prelude::decrypt::MlsConversationDecryptMessage]
|
940
|
+
*/
|
941
|
+
class DecryptedMessage {
|
942
|
+
|
943
|
+
static __wrap(ptr) {
|
944
|
+
const obj = Object.create(DecryptedMessage.prototype);
|
945
|
+
obj.ptr = ptr;
|
946
|
+
|
947
|
+
return obj;
|
948
|
+
}
|
949
|
+
|
950
|
+
__destroy_into_raw() {
|
951
|
+
const ptr = this.ptr;
|
952
|
+
this.ptr = 0;
|
953
|
+
|
954
|
+
return ptr;
|
955
|
+
}
|
956
|
+
|
957
|
+
free() {
|
958
|
+
const ptr = this.__destroy_into_raw();
|
959
|
+
wasm$1.__wbg_decryptedmessage_free(ptr);
|
960
|
+
}
|
961
|
+
/**
|
962
|
+
* @returns {Uint8Array | undefined}
|
963
|
+
*/
|
964
|
+
get message() {
|
965
|
+
const ret = wasm$1.decryptedmessage_message(this.ptr);
|
966
|
+
return takeObject(ret);
|
967
|
+
}
|
968
|
+
/**
|
969
|
+
* @returns {Array<any>}
|
970
|
+
*/
|
971
|
+
get proposals() {
|
972
|
+
const ret = wasm$1.decryptedmessage_proposals(this.ptr);
|
973
|
+
return takeObject(ret);
|
974
|
+
}
|
975
|
+
/**
|
976
|
+
* @returns {boolean}
|
977
|
+
*/
|
978
|
+
get is_active() {
|
979
|
+
const ret = wasm$1.decryptedmessage_is_active(this.ptr);
|
980
|
+
return ret !== 0;
|
981
|
+
}
|
982
|
+
/**
|
983
|
+
* @returns {number | undefined}
|
984
|
+
*/
|
985
|
+
get commit_delay() {
|
986
|
+
try {
|
987
|
+
const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
|
988
|
+
wasm$1.decryptedmessage_commit_delay(retptr, this.ptr);
|
989
|
+
var r0 = getInt32Memory0()[retptr / 4 + 0];
|
990
|
+
var r1 = getInt32Memory0()[retptr / 4 + 1];
|
991
|
+
return r0 === 0 ? undefined : r1 >>> 0;
|
992
|
+
} finally {
|
993
|
+
wasm$1.__wbindgen_add_to_stack_pointer(16);
|
994
|
+
}
|
995
|
+
}
|
996
|
+
}
|
997
|
+
/**
|
998
|
+
* see [core_crypto::prelude::ConversationMember]
|
999
|
+
*/
|
1000
|
+
class Invitee {
|
1001
|
+
|
1002
|
+
static __wrap(ptr) {
|
1003
|
+
const obj = Object.create(Invitee.prototype);
|
1004
|
+
obj.ptr = ptr;
|
1005
|
+
|
1006
|
+
return obj;
|
1007
|
+
}
|
1008
|
+
|
1009
|
+
__destroy_into_raw() {
|
1010
|
+
const ptr = this.ptr;
|
1011
|
+
this.ptr = 0;
|
1012
|
+
|
1013
|
+
return ptr;
|
1014
|
+
}
|
1015
|
+
|
1016
|
+
free() {
|
1017
|
+
const ptr = this.__destroy_into_raw();
|
1018
|
+
wasm$1.__wbg_invitee_free(ptr);
|
1019
|
+
}
|
1020
|
+
/**
|
1021
|
+
* @param {Uint8Array} id
|
1022
|
+
* @param {Uint8Array} kp
|
1023
|
+
*/
|
1024
|
+
constructor(id, kp) {
|
1025
|
+
const ret = wasm$1.invitee_new(addHeapObject(id), addHeapObject(kp));
|
1026
|
+
return Invitee.__wrap(ret);
|
1027
|
+
}
|
1028
|
+
/**
|
1029
|
+
* @returns {Uint8Array}
|
1030
|
+
*/
|
1031
|
+
get id() {
|
1032
|
+
const ret = wasm$1.invitee_id(this.ptr);
|
1033
|
+
return takeObject(ret);
|
1034
|
+
}
|
1035
|
+
/**
|
1036
|
+
* @returns {Uint8Array}
|
1037
|
+
*/
|
1038
|
+
get kp() {
|
1039
|
+
const ret = wasm$1.invitee_kp(this.ptr);
|
1040
|
+
return takeObject(ret);
|
1041
|
+
}
|
1042
|
+
}
|
1043
|
+
/**
|
1044
|
+
* see [core_crypto::prelude::MlsConversationCreationMessage]
|
1045
|
+
*/
|
1046
|
+
class MemberAddedMessages {
|
1047
|
+
|
1048
|
+
static __wrap(ptr) {
|
1049
|
+
const obj = Object.create(MemberAddedMessages.prototype);
|
1050
|
+
obj.ptr = ptr;
|
1051
|
+
|
1052
|
+
return obj;
|
1053
|
+
}
|
1054
|
+
|
1055
|
+
__destroy_into_raw() {
|
1056
|
+
const ptr = this.ptr;
|
1057
|
+
this.ptr = 0;
|
1058
|
+
|
1059
|
+
return ptr;
|
1060
|
+
}
|
1061
|
+
|
1062
|
+
free() {
|
1063
|
+
const ptr = this.__destroy_into_raw();
|
1064
|
+
wasm$1.__wbg_memberaddedmessages_free(ptr);
|
1065
|
+
}
|
1066
|
+
/**
|
1067
|
+
* @param {Uint8Array} welcome
|
1068
|
+
* @param {Uint8Array} commit
|
1069
|
+
* @param {Uint8Array} public_group_state
|
1070
|
+
*/
|
1071
|
+
constructor(welcome, commit, public_group_state) {
|
1072
|
+
const ret = wasm$1.memberaddedmessages_new(addHeapObject(welcome), addHeapObject(commit), addHeapObject(public_group_state));
|
1073
|
+
return MemberAddedMessages.__wrap(ret);
|
1074
|
+
}
|
1075
|
+
/**
|
1076
|
+
* @returns {Uint8Array}
|
1077
|
+
*/
|
1078
|
+
get welcome() {
|
1079
|
+
const ret = wasm$1.memberaddedmessages_welcome(this.ptr);
|
1080
|
+
return takeObject(ret);
|
1081
|
+
}
|
1082
|
+
/**
|
1083
|
+
* @returns {Uint8Array}
|
1084
|
+
*/
|
1085
|
+
get commit() {
|
1086
|
+
const ret = wasm$1.memberaddedmessages_commit(this.ptr);
|
1087
|
+
return takeObject(ret);
|
1088
|
+
}
|
1089
|
+
/**
|
1090
|
+
* @returns {Uint8Array}
|
1091
|
+
*/
|
1092
|
+
get public_group_state() {
|
1093
|
+
const ret = wasm$1.memberaddedmessages_public_group_state(this.ptr);
|
1094
|
+
return takeObject(ret);
|
1095
|
+
}
|
1096
|
+
}
|
1097
|
+
/**
|
1098
|
+
*/
|
1099
|
+
class MlsConversationInitMessage {
|
1100
|
+
|
1101
|
+
__destroy_into_raw() {
|
1102
|
+
const ptr = this.ptr;
|
1103
|
+
this.ptr = 0;
|
1104
|
+
|
1105
|
+
return ptr;
|
1106
|
+
}
|
1107
|
+
|
1108
|
+
free() {
|
1109
|
+
const ptr = this.__destroy_into_raw();
|
1110
|
+
wasm$1.__wbg_mlsconversationinitmessage_free(ptr);
|
1111
|
+
}
|
1112
|
+
/**
|
1113
|
+
* @returns {Uint8Array}
|
1114
|
+
*/
|
1115
|
+
get commit() {
|
1116
|
+
const ret = wasm$1.mlsconversationinitmessage_commit(this.ptr);
|
1117
|
+
return takeObject(ret);
|
1118
|
+
}
|
1119
|
+
/**
|
1120
|
+
* @returns {Uint8Array}
|
1121
|
+
*/
|
1122
|
+
get group() {
|
1123
|
+
const ret = wasm$1.mlsconversationinitmessage_group(this.ptr);
|
1124
|
+
return takeObject(ret);
|
1125
|
+
}
|
1126
|
+
}
|
1127
|
+
/**
|
1128
|
+
*/
|
1129
|
+
class ProposalBundle {
|
1130
|
+
|
1131
|
+
static __wrap(ptr) {
|
1132
|
+
const obj = Object.create(ProposalBundle.prototype);
|
1133
|
+
obj.ptr = ptr;
|
1134
|
+
|
1135
|
+
return obj;
|
1136
|
+
}
|
1137
|
+
|
1138
|
+
__destroy_into_raw() {
|
1139
|
+
const ptr = this.ptr;
|
1140
|
+
this.ptr = 0;
|
1141
|
+
|
1142
|
+
return ptr;
|
1143
|
+
}
|
1144
|
+
|
1145
|
+
free() {
|
1146
|
+
const ptr = this.__destroy_into_raw();
|
1147
|
+
wasm$1.__wbg_proposalbundle_free(ptr);
|
1148
|
+
}
|
1149
|
+
/**
|
1150
|
+
* @returns {Uint8Array}
|
1151
|
+
*/
|
1152
|
+
get proposal() {
|
1153
|
+
const ret = wasm$1.proposalbundle_proposal(this.ptr);
|
1154
|
+
return takeObject(ret);
|
1155
|
+
}
|
1156
|
+
/**
|
1157
|
+
* @returns {Uint8Array}
|
1158
|
+
*/
|
1159
|
+
get proposal_ref() {
|
1160
|
+
const ret = wasm$1.proposalbundle_proposal_ref(this.ptr);
|
1161
|
+
return takeObject(ret);
|
1162
|
+
}
|
1163
|
+
}
|
1164
|
+
|
1165
|
+
async function load(module, imports) {
|
1166
|
+
if (typeof Response === 'function' && module instanceof Response) {
|
1167
|
+
if (typeof WebAssembly.instantiateStreaming === 'function') {
|
1168
|
+
try {
|
1169
|
+
return await WebAssembly.instantiateStreaming(module, imports);
|
1170
|
+
|
1171
|
+
} catch (e) {
|
1172
|
+
if (module.headers.get('Content-Type') != 'application/wasm') {
|
1173
|
+
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);
|
1174
|
+
|
1175
|
+
} else {
|
1176
|
+
throw e;
|
1177
|
+
}
|
1178
|
+
}
|
1179
|
+
}
|
1180
|
+
|
1181
|
+
const bytes = await module.arrayBuffer();
|
1182
|
+
return await WebAssembly.instantiate(bytes, imports);
|
1183
|
+
|
1184
|
+
} else {
|
1185
|
+
const instance = await WebAssembly.instantiate(module, imports);
|
1186
|
+
|
1187
|
+
if (instance instanceof WebAssembly.Instance) {
|
1188
|
+
return { instance, module };
|
1189
|
+
|
1190
|
+
} else {
|
1191
|
+
return instance;
|
1192
|
+
}
|
1193
|
+
}
|
1194
|
+
}
|
1195
|
+
|
1196
|
+
function getImports() {
|
1197
|
+
const imports = {};
|
1198
|
+
imports.wbg = {};
|
1199
|
+
imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
|
1200
|
+
const ret = getObject(arg0);
|
1201
|
+
return addHeapObject(ret);
|
1202
|
+
};
|
1203
|
+
imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
|
1204
|
+
takeObject(arg0);
|
1205
|
+
};
|
1206
|
+
imports.wbg.__wbindgen_is_object = function(arg0) {
|
1207
|
+
const val = getObject(arg0);
|
1208
|
+
const ret = typeof(val) === 'object' && val !== null;
|
1209
|
+
return ret;
|
1210
|
+
};
|
1211
|
+
imports.wbg.__wbg_new_e6a9fecc2bf26696 = function() {
|
1212
|
+
const ret = new Object();
|
1213
|
+
return addHeapObject(ret);
|
1214
|
+
};
|
1215
|
+
imports.wbg.__wbg_set_e93b31d47b90bff6 = function(arg0, arg1, arg2) {
|
1216
|
+
getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
|
1217
|
+
};
|
1218
|
+
imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
|
1219
|
+
const ret = new Error(getStringFromWasm0(arg0, arg1));
|
1220
|
+
return addHeapObject(ret);
|
1221
|
+
};
|
1222
|
+
imports.wbg.__wbg_new0_adda2d4bcb124f0a = function() {
|
1223
|
+
const ret = new Date();
|
1224
|
+
return addHeapObject(ret);
|
1225
|
+
};
|
1226
|
+
imports.wbg.__wbg_getTime_58b0bdbebd4ef11d = function(arg0) {
|
1227
|
+
const ret = getObject(arg0).getTime();
|
1228
|
+
return ret;
|
1229
|
+
};
|
1230
|
+
imports.wbg.__wbg_new_cda198d9dbc6d7ea = function(arg0) {
|
1231
|
+
const ret = new Uint8Array(getObject(arg0));
|
1232
|
+
return addHeapObject(ret);
|
1233
|
+
};
|
1234
|
+
imports.wbg.__wbindgen_bigint_new = function(arg0, arg1) {
|
1235
|
+
const ret = BigInt(getStringFromWasm0(arg0, arg1));
|
1236
|
+
return addHeapObject(ret);
|
1237
|
+
};
|
1238
|
+
imports.wbg.__wbg_new_ee1a3da85465d621 = function() {
|
1239
|
+
const ret = new Array();
|
1240
|
+
return addHeapObject(ret);
|
1241
|
+
};
|
1242
|
+
imports.wbg.__wbg_push_0bc7fce4a139a883 = function(arg0, arg1) {
|
1243
|
+
const ret = getObject(arg0).push(getObject(arg1));
|
1244
|
+
return ret;
|
1245
|
+
};
|
1246
|
+
imports.wbg.__wbg_decryptedmessage_new = function(arg0) {
|
1247
|
+
const ret = DecryptedMessage.__wrap(arg0);
|
1248
|
+
return addHeapObject(ret);
|
1249
|
+
};
|
1250
|
+
imports.wbg.__wbindgen_number_new = function(arg0) {
|
1251
|
+
const ret = arg0;
|
1252
|
+
return addHeapObject(ret);
|
1253
|
+
};
|
1254
|
+
imports.wbg.__wbg_corecrypto_new = function(arg0) {
|
1255
|
+
const ret = CoreCrypto$1.__wrap(arg0);
|
1256
|
+
return addHeapObject(ret);
|
1257
|
+
};
|
1258
|
+
imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
|
1259
|
+
const ret = getStringFromWasm0(arg0, arg1);
|
1260
|
+
return addHeapObject(ret);
|
1261
|
+
};
|
1262
|
+
imports.wbg.__wbindgen_boolean_get = function(arg0) {
|
1263
|
+
const v = getObject(arg0);
|
1264
|
+
const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
|
1265
|
+
return ret;
|
1266
|
+
};
|
1267
|
+
imports.wbg.__wbg_new_52205195aa880fc2 = function(arg0, arg1) {
|
1268
|
+
try {
|
1269
|
+
var state0 = {a: arg0, b: arg1};
|
1270
|
+
var cb0 = (arg0, arg1) => {
|
1271
|
+
const a = state0.a;
|
1272
|
+
state0.a = 0;
|
1273
|
+
try {
|
1274
|
+
return __wbg_adapter_176(a, state0.b, arg0, arg1);
|
1275
|
+
} finally {
|
1276
|
+
state0.a = a;
|
1277
|
+
}
|
1278
|
+
};
|
1279
|
+
const ret = new Promise(cb0);
|
1280
|
+
return addHeapObject(ret);
|
1281
|
+
} finally {
|
1282
|
+
state0.a = state0.b = 0;
|
1283
|
+
}
|
1284
|
+
};
|
1285
|
+
imports.wbg.__wbg_proposalbundle_new = function(arg0) {
|
1286
|
+
const ret = ProposalBundle.__wrap(arg0);
|
1287
|
+
return addHeapObject(ret);
|
1288
|
+
};
|
1289
|
+
imports.wbg.__wbg_get_093fe3cdafaf8976 = function(arg0, arg1) {
|
1290
|
+
const ret = getObject(arg0)[takeObject(arg1)];
|
1291
|
+
return addHeapObject(ret);
|
1292
|
+
};
|
1293
|
+
imports.wbg.__wbg_isArray_a1a8c3a8ac24bdf1 = function(arg0) {
|
1294
|
+
const ret = Array.isArray(getObject(arg0));
|
1295
|
+
return ret;
|
1296
|
+
};
|
1297
|
+
imports.wbg.__wbg_length_a73bfd4c96dd97ef = function(arg0) {
|
1298
|
+
const ret = getObject(arg0).length;
|
1299
|
+
return ret;
|
1300
|
+
};
|
1301
|
+
imports.wbg.__wbg_iterator_22ed2b976832ff0c = function() {
|
1302
|
+
const ret = Symbol.iterator;
|
1303
|
+
return addHeapObject(ret);
|
1304
|
+
};
|
1305
|
+
imports.wbg.__wbg_get_72332cd2bc57924c = function() { return handleError(function (arg0, arg1) {
|
1306
|
+
const ret = Reflect.get(getObject(arg0), getObject(arg1));
|
1307
|
+
return addHeapObject(ret);
|
1308
|
+
}, arguments) };
|
1309
|
+
imports.wbg.__wbindgen_is_function = function(arg0) {
|
1310
|
+
const ret = typeof(getObject(arg0)) === 'function';
|
1311
|
+
return ret;
|
1312
|
+
};
|
1313
|
+
imports.wbg.__wbg_call_33d7bcddbbfa394a = function() { return handleError(function (arg0, arg1) {
|
1314
|
+
const ret = getObject(arg0).call(getObject(arg1));
|
1315
|
+
return addHeapObject(ret);
|
1316
|
+
}, arguments) };
|
1317
|
+
imports.wbg.__wbg_next_726d1c2255989269 = function(arg0) {
|
1318
|
+
const ret = getObject(arg0).next;
|
1319
|
+
return addHeapObject(ret);
|
1320
|
+
};
|
1321
|
+
imports.wbg.__wbg_next_3d0c4cc33e7418c9 = function() { return handleError(function (arg0) {
|
1322
|
+
const ret = getObject(arg0).next();
|
1323
|
+
return addHeapObject(ret);
|
1324
|
+
}, arguments) };
|
1325
|
+
imports.wbg.__wbg_done_e5655b169bb04f60 = function(arg0) {
|
1326
|
+
const ret = getObject(arg0).done;
|
1327
|
+
return ret;
|
1328
|
+
};
|
1329
|
+
imports.wbg.__wbg_value_8f901bca1014f843 = function(arg0) {
|
1330
|
+
const ret = getObject(arg0).value;
|
1331
|
+
return addHeapObject(ret);
|
1332
|
+
};
|
1333
|
+
imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
|
1334
|
+
const obj = getObject(arg1);
|
1335
|
+
const ret = typeof(obj) === 'number' ? obj : undefined;
|
1336
|
+
getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
|
1337
|
+
getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
|
1338
|
+
};
|
1339
|
+
imports.wbg.__wbg_isSafeInteger_f6dd91807e9c4d35 = function(arg0) {
|
1340
|
+
const ret = Number.isSafeInteger(getObject(arg0));
|
1341
|
+
return ret;
|
1342
|
+
};
|
1343
|
+
imports.wbg.__wbg_get_ad41fee29b7e0f53 = function(arg0, arg1) {
|
1344
|
+
const ret = getObject(arg0)[arg1 >>> 0];
|
1345
|
+
return addHeapObject(ret);
|
1346
|
+
};
|
1347
|
+
imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
|
1348
|
+
const obj = getObject(arg1);
|
1349
|
+
const ret = typeof(obj) === 'string' ? obj : undefined;
|
1350
|
+
var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
|
1351
|
+
var len0 = WASM_VECTOR_LEN;
|
1352
|
+
getInt32Memory0()[arg0 / 4 + 1] = len0;
|
1353
|
+
getInt32Memory0()[arg0 / 4 + 0] = ptr0;
|
1354
|
+
};
|
1355
|
+
imports.wbg.__wbindgen_is_null = function(arg0) {
|
1356
|
+
const ret = getObject(arg0) === null;
|
1357
|
+
return ret;
|
1358
|
+
};
|
1359
|
+
imports.wbg.__wbindgen_is_undefined = function(arg0) {
|
1360
|
+
const ret = getObject(arg0) === undefined;
|
1361
|
+
return ret;
|
1362
|
+
};
|
1363
|
+
imports.wbg.__wbg_name_f232931b09239ddb = function(arg0, arg1) {
|
1364
|
+
const ret = getObject(arg1).name;
|
1365
|
+
const ptr0 = passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
|
1366
|
+
const len0 = WASM_VECTOR_LEN;
|
1367
|
+
getInt32Memory0()[arg0 / 4 + 1] = len0;
|
1368
|
+
getInt32Memory0()[arg0 / 4 + 0] = ptr0;
|
1369
|
+
};
|
1370
|
+
imports.wbg.__wbg_transaction_0dcffc72158c7b6f = function() { return handleError(function (arg0, arg1, arg2) {
|
1371
|
+
const ret = getObject(arg0).transaction(getObject(arg1), takeObject(arg2));
|
1372
|
+
return addHeapObject(ret);
|
1373
|
+
}, arguments) };
|
1374
|
+
imports.wbg.__wbg_set_64cc39858b2ec3f1 = function(arg0, arg1, arg2) {
|
1375
|
+
getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
|
1376
|
+
};
|
1377
|
+
imports.wbg.__wbindgen_cb_drop = function(arg0) {
|
1378
|
+
const obj = takeObject(arg0).original;
|
1379
|
+
if (obj.cnt-- == 1) {
|
1380
|
+
obj.a = 0;
|
1381
|
+
return true;
|
1382
|
+
}
|
1383
|
+
const ret = false;
|
1384
|
+
return ret;
|
1385
|
+
};
|
1386
|
+
imports.wbg.__wbg_commit_6211fe2744b83edc = function() { return handleError(function (arg0) {
|
1387
|
+
getObject(arg0).commit();
|
1388
|
+
}, arguments) };
|
1389
|
+
imports.wbg.__wbg_setoncomplete_8bfbade4ed628fd0 = function(arg0, arg1) {
|
1390
|
+
getObject(arg0).oncomplete = getObject(arg1);
|
1391
|
+
};
|
1392
|
+
imports.wbg.__wbg_setonerror_9d842115702fd223 = function(arg0, arg1) {
|
1393
|
+
getObject(arg0).onerror = getObject(arg1);
|
1394
|
+
};
|
1395
|
+
imports.wbg.__wbg_put_e193e5c9c96e937f = function() { return handleError(function (arg0, arg1, arg2) {
|
1396
|
+
const ret = getObject(arg0).put(getObject(arg1), getObject(arg2));
|
1397
|
+
return addHeapObject(ret);
|
1398
|
+
}, arguments) };
|
1399
|
+
imports.wbg.__wbg_put_a727d1fdb5788ec1 = function() { return handleError(function (arg0, arg1) {
|
1400
|
+
const ret = getObject(arg0).put(getObject(arg1));
|
1401
|
+
return addHeapObject(ret);
|
1402
|
+
}, arguments) };
|
1403
|
+
imports.wbg.__wbg_setonsuccess_bb91afe1f8110021 = function(arg0, arg1) {
|
1404
|
+
getObject(arg0).onsuccess = getObject(arg1);
|
1405
|
+
};
|
1406
|
+
imports.wbg.__wbg_setonerror_db491b84dd45e918 = function(arg0, arg1) {
|
1407
|
+
getObject(arg0).onerror = getObject(arg1);
|
1408
|
+
};
|
1409
|
+
imports.wbg.__wbg_openCursor_4292a52d0e6d4246 = function() { return handleError(function (arg0, arg1) {
|
1410
|
+
const ret = getObject(arg0).openCursor(getObject(arg1));
|
1411
|
+
return addHeapObject(ret);
|
1412
|
+
}, arguments) };
|
1413
|
+
imports.wbg.__wbg_openCursor_10a7a7a41fce054c = function() { return handleError(function (arg0) {
|
1414
|
+
const ret = getObject(arg0).openCursor();
|
1415
|
+
return addHeapObject(ret);
|
1416
|
+
}, arguments) };
|
1417
|
+
imports.wbg.__wbg_delete_1ca98818fdc40291 = function() { return handleError(function (arg0, arg1) {
|
1418
|
+
const ret = getObject(arg0).delete(getObject(arg1));
|
1419
|
+
return addHeapObject(ret);
|
1420
|
+
}, arguments) };
|
1421
|
+
imports.wbg.__wbg_get_28f9ffc7eb5802f3 = function() { return handleError(function (arg0, arg1) {
|
1422
|
+
const ret = getObject(arg0).get(getObject(arg1));
|
1423
|
+
return addHeapObject(ret);
|
1424
|
+
}, arguments) };
|
1425
|
+
imports.wbg.__wbg_open_2a1e9120d3d8897d = function() { return handleError(function (arg0, arg1, arg2) {
|
1426
|
+
const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2));
|
1427
|
+
return addHeapObject(ret);
|
1428
|
+
}, arguments) };
|
1429
|
+
imports.wbg.__wbg_open_3384efa97bde264f = function() { return handleError(function (arg0, arg1, arg2, arg3) {
|
1430
|
+
const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
|
1431
|
+
return addHeapObject(ret);
|
1432
|
+
}, arguments) };
|
1433
|
+
imports.wbg.__wbg_setonupgradeneeded_8956d6214819f478 = function(arg0, arg1) {
|
1434
|
+
getObject(arg0).onupgradeneeded = getObject(arg1);
|
1435
|
+
};
|
1436
|
+
imports.wbg.__wbg_count_6f4c35312ff0234d = function() { return handleError(function (arg0) {
|
1437
|
+
const ret = getObject(arg0).count();
|
1438
|
+
return addHeapObject(ret);
|
1439
|
+
}, arguments) };
|
1440
|
+
imports.wbg.__wbg_count_ea5300005a5f227d = function() { return handleError(function (arg0, arg1) {
|
1441
|
+
const ret = getObject(arg0).count(getObject(arg1));
|
1442
|
+
return addHeapObject(ret);
|
1443
|
+
}, arguments) };
|
1444
|
+
imports.wbg.__wbg_deleteDatabase_7b98d08298856363 = function() { return handleError(function (arg0, arg1, arg2) {
|
1445
|
+
const ret = getObject(arg0).deleteDatabase(getStringFromWasm0(arg1, arg2));
|
1446
|
+
return addHeapObject(ret);
|
1447
|
+
}, arguments) };
|
1448
|
+
imports.wbg.__wbg_close_87495affacd7f79d = function(arg0) {
|
1449
|
+
getObject(arg0).close();
|
1450
|
+
};
|
1451
|
+
imports.wbg.__wbg_get_a06b4198f86b037d = function() { return handleError(function (arg0, arg1) {
|
1452
|
+
const ret = getObject(arg0).get(getObject(arg1));
|
1453
|
+
return addHeapObject(ret);
|
1454
|
+
}, arguments) };
|
1455
|
+
imports.wbg.__wbg_openCursor_a9656bd0901e39c0 = function() { return handleError(function (arg0) {
|
1456
|
+
const ret = getObject(arg0).openCursor();
|
1457
|
+
return addHeapObject(ret);
|
1458
|
+
}, arguments) };
|
1459
|
+
imports.wbg.__wbg_openCursor_2cfe2e04de0b6b91 = function() { return handleError(function (arg0, arg1) {
|
1460
|
+
const ret = getObject(arg0).openCursor(getObject(arg1));
|
1461
|
+
return addHeapObject(ret);
|
1462
|
+
}, arguments) };
|
1463
|
+
imports.wbg.__wbg_randomFillSync_91e2b39becca6147 = function() { return handleError(function (arg0, arg1, arg2) {
|
1464
|
+
getObject(arg0).randomFillSync(getArrayU8FromWasm0(arg1, arg2));
|
1465
|
+
}, arguments) };
|
1466
|
+
imports.wbg.__wbg_subarray_270ff8dd5582c1ac = function(arg0, arg1, arg2) {
|
1467
|
+
const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
|
1468
|
+
return addHeapObject(ret);
|
1469
|
+
};
|
1470
|
+
imports.wbg.__wbg_getRandomValues_b14734aa289bc356 = function() { return handleError(function (arg0, arg1) {
|
1471
|
+
getObject(arg0).getRandomValues(getObject(arg1));
|
1472
|
+
}, arguments) };
|
1473
|
+
imports.wbg.__wbg_length_51f19f73d6d9eff3 = function(arg0) {
|
1474
|
+
const ret = getObject(arg0).length;
|
1475
|
+
return ret;
|
1476
|
+
};
|
1477
|
+
imports.wbg.__wbg_process_e56fd54cf6319b6c = function(arg0) {
|
1478
|
+
const ret = getObject(arg0).process;
|
1479
|
+
return addHeapObject(ret);
|
1480
|
+
};
|
1481
|
+
imports.wbg.__wbg_versions_77e21455908dad33 = function(arg0) {
|
1482
|
+
const ret = getObject(arg0).versions;
|
1483
|
+
return addHeapObject(ret);
|
1484
|
+
};
|
1485
|
+
imports.wbg.__wbg_node_0dd25d832e4785d5 = function(arg0) {
|
1486
|
+
const ret = getObject(arg0).node;
|
1487
|
+
return addHeapObject(ret);
|
1488
|
+
};
|
1489
|
+
imports.wbg.__wbindgen_is_string = function(arg0) {
|
1490
|
+
const ret = typeof(getObject(arg0)) === 'string';
|
1491
|
+
return ret;
|
1492
|
+
};
|
1493
|
+
imports.wbg.__wbg_static_accessor_NODE_MODULE_26b231378c1be7dd = function() {
|
1494
|
+
const ret = module;
|
1495
|
+
return addHeapObject(ret);
|
1496
|
+
};
|
1497
|
+
imports.wbg.__wbg_require_0db1598d9ccecb30 = function() { return handleError(function (arg0, arg1, arg2) {
|
1498
|
+
const ret = getObject(arg0).require(getStringFromWasm0(arg1, arg2));
|
1499
|
+
return addHeapObject(ret);
|
1500
|
+
}, arguments) };
|
1501
|
+
imports.wbg.__wbg_crypto_b95d7173266618a9 = function(arg0) {
|
1502
|
+
const ret = getObject(arg0).crypto;
|
1503
|
+
return addHeapObject(ret);
|
1504
|
+
};
|
1505
|
+
imports.wbg.__wbg_msCrypto_5a86d77a66230f81 = function(arg0) {
|
1506
|
+
const ret = getObject(arg0).msCrypto;
|
1507
|
+
return addHeapObject(ret);
|
1508
|
+
};
|
1509
|
+
imports.wbg.__wbg_newwithlength_66e5530e7079ea1b = function(arg0) {
|
1510
|
+
const ret = new Uint8Array(arg0 >>> 0);
|
1511
|
+
return addHeapObject(ret);
|
1512
|
+
};
|
1513
|
+
imports.wbg.__wbg_self_fd00a1ef86d1b2ed = function() { return handleError(function () {
|
1514
|
+
const ret = self.self;
|
1515
|
+
return addHeapObject(ret);
|
1516
|
+
}, arguments) };
|
1517
|
+
imports.wbg.__wbg_window_6f6e346d8bbd61d7 = function() { return handleError(function () {
|
1518
|
+
const ret = window.window;
|
1519
|
+
return addHeapObject(ret);
|
1520
|
+
}, arguments) };
|
1521
|
+
imports.wbg.__wbg_globalThis_3348936ac49df00a = function() { return handleError(function () {
|
1522
|
+
const ret = globalThis.globalThis;
|
1523
|
+
return addHeapObject(ret);
|
1524
|
+
}, arguments) };
|
1525
|
+
imports.wbg.__wbg_global_67175caf56f55ca9 = function() { return handleError(function () {
|
1526
|
+
const ret = global.global;
|
1527
|
+
return addHeapObject(ret);
|
1528
|
+
}, arguments) };
|
1529
|
+
imports.wbg.__wbg_newnoargs_971e9a5abe185139 = function(arg0, arg1) {
|
1530
|
+
const ret = new Function(getStringFromWasm0(arg0, arg1));
|
1531
|
+
return addHeapObject(ret);
|
1532
|
+
};
|
1533
|
+
imports.wbg.__wbg_call_65af9f665ab6ade5 = function() { return handleError(function (arg0, arg1, arg2) {
|
1534
|
+
const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
|
1535
|
+
return addHeapObject(ret);
|
1536
|
+
}, arguments) };
|
1537
|
+
imports.wbg.__wbg_call_187e4e7f6f4285fb = function() { return handleError(function (arg0, arg1, arg2, arg3) {
|
1538
|
+
const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
|
1539
|
+
return addHeapObject(ret);
|
1540
|
+
}, arguments) };
|
1541
|
+
imports.wbg.__wbg_set_2762e698c2f5b7e0 = function() { return handleError(function (arg0, arg1, arg2) {
|
1542
|
+
const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
|
1543
|
+
return ret;
|
1544
|
+
}, arguments) };
|
1545
|
+
imports.wbg.__wbindgen_memory = function() {
|
1546
|
+
const ret = wasm$1.memory;
|
1547
|
+
return addHeapObject(ret);
|
1548
|
+
};
|
1549
|
+
imports.wbg.__wbg_buffer_34f5ec9f8a838ba0 = function(arg0) {
|
1550
|
+
const ret = getObject(arg0).buffer;
|
1551
|
+
return addHeapObject(ret);
|
1552
|
+
};
|
1553
|
+
imports.wbg.__wbg_newwithbyteoffsetandlength_88fdad741db1b182 = function(arg0, arg1, arg2) {
|
1554
|
+
const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
|
1555
|
+
return addHeapObject(ret);
|
1556
|
+
};
|
1557
|
+
imports.wbg.__wbg_set_1a930cfcda1a8067 = function(arg0, arg1, arg2) {
|
1558
|
+
getObject(arg0).set(getObject(arg1), arg2 >>> 0);
|
1559
|
+
};
|
1560
|
+
imports.wbg.__wbg_now_1b6e18d94ce2c037 = function() {
|
1561
|
+
const ret = Date.now();
|
1562
|
+
return ret;
|
1563
|
+
};
|
1564
|
+
imports.wbg.__wbg_target_68a5c10e2732a79e = function(arg0) {
|
1565
|
+
const ret = getObject(arg0).target;
|
1566
|
+
return isLikeNone(ret) ? 0 : addHeapObject(ret);
|
1567
|
+
};
|
1568
|
+
imports.wbg.__wbg_error_c872d3f7251736f1 = function() { return handleError(function (arg0) {
|
1569
|
+
const ret = getObject(arg0).error;
|
1570
|
+
return isLikeNone(ret) ? 0 : addHeapObject(ret);
|
1571
|
+
}, arguments) };
|
1572
|
+
imports.wbg.__wbg_objectStoreNames_d11a3d06e3226638 = function(arg0) {
|
1573
|
+
const ret = getObject(arg0).objectStoreNames;
|
1574
|
+
return addHeapObject(ret);
|
1575
|
+
};
|
1576
|
+
imports.wbg.__wbg_contains_bcaf1388e1ca982c = function(arg0, arg1, arg2) {
|
1577
|
+
const ret = getObject(arg0).contains(getStringFromWasm0(arg1, arg2));
|
1578
|
+
return ret;
|
1579
|
+
};
|
1580
|
+
imports.wbg.__wbg_createObjectStore_454d7cf701faa545 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
|
1581
|
+
const ret = getObject(arg0).createObjectStore(getStringFromWasm0(arg1, arg2), getObject(arg3));
|
1582
|
+
return addHeapObject(ret);
|
1583
|
+
}, arguments) };
|
1584
|
+
imports.wbg.__wbg_transaction_0ba302b35542323f = function(arg0) {
|
1585
|
+
const ret = getObject(arg0).transaction;
|
1586
|
+
return isLikeNone(ret) ? 0 : addHeapObject(ret);
|
1587
|
+
};
|
1588
|
+
imports.wbg.__wbg_indexNames_8f97f1f79bc278bf = function(arg0) {
|
1589
|
+
const ret = getObject(arg0).indexNames;
|
1590
|
+
return addHeapObject(ret);
|
1591
|
+
};
|
1592
|
+
imports.wbg.__wbg_createIndex_20c39366f6b22548 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
|
1593
|
+
const ret = getObject(arg0).createIndex(getStringFromWasm0(arg1, arg2), getObject(arg3), getObject(arg4));
|
1594
|
+
return addHeapObject(ret);
|
1595
|
+
}, arguments) };
|
1596
|
+
imports.wbg.__wbg_length_580a8f6d9757b9da = function(arg0) {
|
1597
|
+
const ret = getObject(arg0).length;
|
1598
|
+
return ret;
|
1599
|
+
};
|
1600
|
+
imports.wbg.__wbg_deleteIndex_9d33d4fd04e9038c = function() { return handleError(function (arg0, arg1, arg2) {
|
1601
|
+
getObject(arg0).deleteIndex(getStringFromWasm0(arg1, arg2));
|
1602
|
+
}, arguments) };
|
1603
|
+
imports.wbg.__wbg_deleteObjectStore_ec34033b22e0c4e1 = function() { return handleError(function (arg0, arg1, arg2) {
|
1604
|
+
getObject(arg0).deleteObjectStore(getStringFromWasm0(arg1, arg2));
|
1605
|
+
}, arguments) };
|
1606
|
+
imports.wbg.__wbindgen_is_falsy = function(arg0) {
|
1607
|
+
const ret = !getObject(arg0);
|
1608
|
+
return ret;
|
1609
|
+
};
|
1610
|
+
imports.wbg.__wbg_key_3ce14c27a234543a = function() { return handleError(function (arg0) {
|
1611
|
+
const ret = getObject(arg0).key;
|
1612
|
+
return addHeapObject(ret);
|
1613
|
+
}, arguments) };
|
1614
|
+
imports.wbg.__wbg_advance_5da26ebf2f15b82e = function() { return handleError(function (arg0, arg1) {
|
1615
|
+
getObject(arg0).advance(arg1 >>> 0);
|
1616
|
+
}, arguments) };
|
1617
|
+
imports.wbg.__wbg_instanceof_IdbFactory_acaddaa9df3f73bc = function(arg0) {
|
1618
|
+
const ret = getObject(arg0) instanceof IDBFactory;
|
1619
|
+
return ret;
|
1620
|
+
};
|
1621
|
+
imports.wbg.__wbg_index_49e22b15910e16d4 = function() { return handleError(function (arg0, arg1, arg2) {
|
1622
|
+
const ret = getObject(arg0).index(getStringFromWasm0(arg1, arg2));
|
1623
|
+
return addHeapObject(ret);
|
1624
|
+
}, arguments) };
|
1625
|
+
imports.wbg.__wbg_toString_dc4768002eeae1b0 = function(arg0) {
|
1626
|
+
const ret = getObject(arg0).toString();
|
1627
|
+
return addHeapObject(ret);
|
1628
|
+
};
|
1629
|
+
imports.wbg.__wbg_new_3ee7ebe9952c1fbd = function(arg0, arg1) {
|
1630
|
+
const ret = new Error(getStringFromWasm0(arg0, arg1));
|
1631
|
+
return addHeapObject(ret);
|
1632
|
+
};
|
1633
|
+
imports.wbg.__wbg_instanceof_Uint8Array_36c37b9ca15e3e0a = function(arg0) {
|
1634
|
+
const ret = getObject(arg0) instanceof Uint8Array;
|
1635
|
+
return ret;
|
1636
|
+
};
|
1637
|
+
imports.wbg.__wbg_instanceof_ArrayBuffer_02bbeeb60438c785 = function(arg0) {
|
1638
|
+
const ret = getObject(arg0) instanceof ArrayBuffer;
|
1639
|
+
return ret;
|
1640
|
+
};
|
1641
|
+
imports.wbg.__wbg_String_7462bcc0fcdbaf7d = function(arg0, arg1) {
|
1642
|
+
const ret = String(getObject(arg1));
|
1643
|
+
const ptr0 = passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
|
1644
|
+
const len0 = WASM_VECTOR_LEN;
|
1645
|
+
getInt32Memory0()[arg0 / 4 + 1] = len0;
|
1646
|
+
getInt32Memory0()[arg0 / 4 + 0] = ptr0;
|
1647
|
+
};
|
1648
|
+
imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
|
1649
|
+
const ret = debugString(getObject(arg1));
|
1650
|
+
const ptr0 = passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
|
1651
|
+
const len0 = WASM_VECTOR_LEN;
|
1652
|
+
getInt32Memory0()[arg0 / 4 + 1] = len0;
|
1653
|
+
getInt32Memory0()[arg0 / 4 + 0] = ptr0;
|
1654
|
+
};
|
1655
|
+
imports.wbg.__wbindgen_throw = function(arg0, arg1) {
|
1656
|
+
throw new Error(getStringFromWasm0(arg0, arg1));
|
1657
|
+
};
|
1658
|
+
imports.wbg.__wbg_then_18da6e5453572fc8 = function(arg0, arg1) {
|
1659
|
+
const ret = getObject(arg0).then(getObject(arg1));
|
1660
|
+
return addHeapObject(ret);
|
1661
|
+
};
|
1662
|
+
imports.wbg.__wbg_resolve_0107b3a501450ba0 = function(arg0) {
|
1663
|
+
const ret = Promise.resolve(getObject(arg0));
|
1664
|
+
return addHeapObject(ret);
|
1665
|
+
};
|
1666
|
+
imports.wbg.__wbg_get_50220f3428ca7e51 = function(arg0, arg1, arg2) {
|
1667
|
+
const ret = getObject(arg1)[arg2 >>> 0];
|
1668
|
+
var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
|
1669
|
+
var len0 = WASM_VECTOR_LEN;
|
1670
|
+
getInt32Memory0()[arg0 / 4 + 1] = len0;
|
1671
|
+
getInt32Memory0()[arg0 / 4 + 0] = ptr0;
|
1672
|
+
};
|
1673
|
+
imports.wbg.__wbg_continue_43562ff8da972056 = function() { return handleError(function (arg0) {
|
1674
|
+
getObject(arg0).continue();
|
1675
|
+
}, arguments) };
|
1676
|
+
imports.wbg.__wbg_value_a3a782e66c6935d3 = function() { return handleError(function (arg0) {
|
1677
|
+
const ret = getObject(arg0).value;
|
1678
|
+
return addHeapObject(ret);
|
1679
|
+
}, arguments) };
|
1680
|
+
imports.wbg.__wbg_openCursor_48949b0ae4868b31 = function() { return handleError(function (arg0, arg1, arg2) {
|
1681
|
+
const ret = getObject(arg0).openCursor(getObject(arg1), takeObject(arg2));
|
1682
|
+
return addHeapObject(ret);
|
1683
|
+
}, arguments) };
|
1684
|
+
imports.wbg.__wbg_openCursor_abefd2bc54b71e0f = function() { return handleError(function (arg0, arg1, arg2) {
|
1685
|
+
const ret = getObject(arg0).openCursor(getObject(arg1), takeObject(arg2));
|
1686
|
+
return addHeapObject(ret);
|
1687
|
+
}, arguments) };
|
1688
|
+
imports.wbg.__wbg_result_4b44b0d900b4ab6f = function() { return handleError(function (arg0) {
|
1689
|
+
const ret = getObject(arg0).result;
|
1690
|
+
return addHeapObject(ret);
|
1691
|
+
}, arguments) };
|
1692
|
+
imports.wbg.__wbg_objectStore_76c268be095ec9a5 = function() { return handleError(function (arg0, arg1, arg2) {
|
1693
|
+
const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2));
|
1694
|
+
return addHeapObject(ret);
|
1695
|
+
}, arguments) };
|
1696
|
+
imports.wbg.__wbindgen_closure_wrapper2486 = function(arg0, arg1, arg2) {
|
1697
|
+
const ret = makeMutClosure(arg0, arg1, 105, __wbg_adapter_40);
|
1698
|
+
return addHeapObject(ret);
|
1699
|
+
};
|
1700
|
+
imports.wbg.__wbindgen_closure_wrapper4443 = function(arg0, arg1, arg2) {
|
1701
|
+
const ret = makeMutClosure(arg0, arg1, 113, __wbg_adapter_43);
|
1702
|
+
return addHeapObject(ret);
|
1703
|
+
};
|
1704
|
+
|
1705
|
+
return imports;
|
1706
|
+
}
|
1707
|
+
|
1708
|
+
function finalizeInit(instance, module) {
|
1709
|
+
wasm$1 = instance.exports;
|
1710
|
+
init.__wbindgen_wasm_module = module;
|
1711
|
+
cachedFloat64Memory0 = new Float64Array();
|
1712
|
+
cachedInt32Memory0 = new Int32Array();
|
1713
|
+
cachedUint32Memory0 = new Uint32Array();
|
1714
|
+
cachedUint8Memory0 = new Uint8Array();
|
1715
|
+
|
1716
|
+
|
1717
|
+
return wasm$1;
|
1718
|
+
}
|
1719
|
+
|
1720
|
+
function initSync(bytes) {
|
1721
|
+
const imports = getImports();
|
1722
|
+
|
1723
|
+
const module = new WebAssembly.Module(bytes);
|
1724
|
+
const instance = new WebAssembly.Instance(module, imports);
|
1725
|
+
|
1726
|
+
return finalizeInit(instance, module);
|
1727
|
+
}
|
1728
|
+
|
1729
|
+
async function init(input) {
|
1730
|
+
if (typeof input === 'undefined') {
|
1731
|
+
input = new URL('index_bg.wasm', import.meta.url);
|
1732
|
+
}
|
1733
|
+
const imports = getImports();
|
1734
|
+
|
1735
|
+
if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
|
1736
|
+
input = fetch(input);
|
1737
|
+
}
|
1738
|
+
|
1739
|
+
const { instance, module } = await load(await input, imports);
|
1740
|
+
|
1741
|
+
return finalizeInit(instance, module);
|
1742
|
+
}
|
1743
|
+
|
1744
|
+
var exports = /*#__PURE__*/Object.freeze({
|
1745
|
+
__proto__: null,
|
1746
|
+
version: version,
|
1747
|
+
Ciphersuite: Ciphersuite,
|
1748
|
+
CommitBundle: CommitBundle,
|
1749
|
+
ConversationConfiguration: ConversationConfiguration,
|
1750
|
+
CoreCrypto: CoreCrypto$1,
|
1751
|
+
CoreCryptoWasmCallbacks: CoreCryptoWasmCallbacks,
|
1752
|
+
DecryptedMessage: DecryptedMessage,
|
1753
|
+
Invitee: Invitee,
|
1754
|
+
MemberAddedMessages: MemberAddedMessages,
|
1755
|
+
MlsConversationInitMessage: MlsConversationInitMessage,
|
1756
|
+
ProposalBundle: ProposalBundle,
|
1757
|
+
initSync: initSync,
|
1758
|
+
'default': init
|
1759
|
+
});
|
1760
|
+
|
1761
|
+
var wasm = async (opt = {}) => {
|
1762
|
+
let {importHook, serverPath} = opt;
|
1763
|
+
|
1764
|
+
let path = "assets/core_crypto_ffi-e63ef1c1.wasm";
|
1765
|
+
|
1766
|
+
if (serverPath != null) {
|
1767
|
+
path = serverPath + /[^\/\\]*$/.exec(path)[0];
|
1768
|
+
}
|
1769
|
+
|
1770
|
+
if (importHook != null) {
|
1771
|
+
path = importHook(path);
|
1772
|
+
}
|
1773
|
+
|
1774
|
+
await init(path);
|
1775
|
+
return exports;
|
1776
|
+
};
|
1777
|
+
|
1778
|
+
// Wire
|
1779
|
+
/**
|
1780
|
+
* Wrapper for the WASM-compiled version of CoreCrypto
|
1781
|
+
*/
|
1782
|
+
class CoreCrypto {
|
1783
|
+
/** @hidden */
|
1784
|
+
constructor(cc) {
|
1785
|
+
this.#cc = cc;
|
1786
|
+
}
|
1787
|
+
/** @hidden */
|
1788
|
+
static #module;
|
1789
|
+
/** @hidden */
|
1790
|
+
#cc;
|
1791
|
+
/**
|
1792
|
+
* This is your entrypoint to initialize {@link CoreCrypto}!
|
1793
|
+
*
|
1794
|
+
* @param params - {@link CoreCryptoParams}
|
1795
|
+
*
|
1796
|
+
* @example
|
1797
|
+
* ## Simple init
|
1798
|
+
* ```ts
|
1799
|
+
* const cc = await CoreCrypto.init({ databaseName: "test", key: "test", clientId: "test" });
|
1800
|
+
* // Do the rest with `cc`
|
1801
|
+
* ```
|
1802
|
+
*
|
1803
|
+
* ## Custom Entropy seed init & wasm file location
|
1804
|
+
* ```ts
|
1805
|
+
* // FYI, this is the IETF test vector #1
|
1806
|
+
* const entropySeed = Uint32Array.from([
|
1807
|
+
* 0xade0b876, 0x903df1a0, 0xe56a5d40, 0x28bd8653,
|
1808
|
+
* 0xb819d2bd, 0x1aed8da0, 0xccef36a8, 0xc70d778b,
|
1809
|
+
* 0x7c5941da, 0x8d485751, 0x3fe02477, 0x374ad8b8,
|
1810
|
+
* 0xf4b8436a, 0x1ca11815, 0x69b687c3, 0x8665eeb2,
|
1811
|
+
* ]);
|
1812
|
+
*
|
1813
|
+
* const wasmFilePath = "/long/complicated/path/on/webserver/whatever.wasm";
|
1814
|
+
*
|
1815
|
+
* const cc = await CoreCrypto.init({
|
1816
|
+
* databaseName: "test",
|
1817
|
+
* key: "test",
|
1818
|
+
* clientId: "test",
|
1819
|
+
* entropySeed,
|
1820
|
+
* wasmFilePath,
|
1821
|
+
* });
|
1822
|
+
* ````
|
1823
|
+
*/
|
1824
|
+
static async init({ databaseName, key, clientId, wasmFilePath, entropySeed }) {
|
1825
|
+
if (!this.#module) {
|
1826
|
+
const wasmImportArgs = wasmFilePath ? { importHook: () => wasmFilePath } : undefined;
|
1827
|
+
const exports = (await wasm(wasmImportArgs));
|
1828
|
+
this.#module = exports;
|
1829
|
+
}
|
1830
|
+
const cc = await this.#module.CoreCrypto._internal_new(databaseName, key, clientId, entropySeed);
|
1831
|
+
return new this(cc);
|
1832
|
+
}
|
1833
|
+
/**
|
1834
|
+
* Wipes the {@link CoreCrypto} backing storage (i.e. {@link https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API | IndexedDB} database)
|
1835
|
+
*
|
1836
|
+
* **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!
|
1837
|
+
*/
|
1838
|
+
async wipe() {
|
1839
|
+
await this.#cc.wipe();
|
1840
|
+
}
|
1841
|
+
/**
|
1842
|
+
* Closes this {@link CoreCrypto} instance and deallocates all loaded resources
|
1843
|
+
*
|
1844
|
+
* **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!
|
1845
|
+
*/
|
1846
|
+
async close() {
|
1847
|
+
await this.#cc.close();
|
1848
|
+
}
|
1849
|
+
/**
|
1850
|
+
* Checks if the Client is member of a given conversation and if the MLS Group is loaded up
|
1851
|
+
*
|
1852
|
+
* @returns Whether the given conversation ID exists
|
1853
|
+
*
|
1854
|
+
* @example
|
1855
|
+
* ```ts
|
1856
|
+
* const cc = await CoreCrypto.init({ databaseName: "test", key: "test", clientId: "test" });
|
1857
|
+
* const encoder = new TextEncoder();
|
1858
|
+
* if (await cc.conversationExists(encoder.encode("my super chat"))) {
|
1859
|
+
* // Do something
|
1860
|
+
* } else {
|
1861
|
+
* // Do something else
|
1862
|
+
* }
|
1863
|
+
* ```
|
1864
|
+
*/
|
1865
|
+
async conversationExists(conversationId) {
|
1866
|
+
return await this.#cc.conversation_exists(conversationId);
|
1867
|
+
}
|
1868
|
+
/**
|
1869
|
+
* Returns the current epoch of a conversation
|
1870
|
+
*
|
1871
|
+
* @returns the epoch of the conversation
|
1872
|
+
*
|
1873
|
+
* @example
|
1874
|
+
* ```ts
|
1875
|
+
* const cc = await CoreCrypto.init({ databaseName: "test", key: "test", clientId: "test" });
|
1876
|
+
* const encoder = new TextEncoder();
|
1877
|
+
* console.log(await cc.conversationEpoch(encoder.encode("my super chat")))
|
1878
|
+
* ```
|
1879
|
+
*/
|
1880
|
+
async conversationEpoch(conversationId) {
|
1881
|
+
return await this.#cc.conversation_epoch(conversationId);
|
1882
|
+
}
|
1883
|
+
/**
|
1884
|
+
* Wipes and destroys the local storage of a given conversation / MLS group
|
1885
|
+
*
|
1886
|
+
* @param conversationId - The ID of the conversation to remove
|
1887
|
+
*/
|
1888
|
+
async wipeConversation(conversationId) {
|
1889
|
+
return await this.#cc.wipe_conversation(conversationId);
|
1890
|
+
}
|
1891
|
+
/**
|
1892
|
+
* Creates a new conversation with the current client being the sole member
|
1893
|
+
* You will want to use {@link CoreCrypto.addClientsToConversation} afterwards to add clients to this conversation
|
1894
|
+
*
|
1895
|
+
* @param conversationId - The conversation ID; You can either make them random or let the backend attribute MLS group IDs
|
1896
|
+
* @param configuration.admins - An array of client IDs that will have administrative permissions over the group
|
1897
|
+
* @param configuration.ciphersuite - The {@link Ciphersuite} that is chosen to be the group's
|
1898
|
+
* @param configuration.keyRotationSpan - The amount of time in milliseconds after which the MLS Keypackages will be rotated
|
1899
|
+
* @param configuration.externalSenders - Array of Client IDs that are qualified as external senders within the group
|
1900
|
+
*/
|
1901
|
+
async createConversation(conversationId, configuration = {}) {
|
1902
|
+
const { admins, ciphersuite, keyRotationSpan, externalSenders } = configuration ?? {};
|
1903
|
+
const config = new CoreCrypto.#module.ConversationConfiguration(admins, ciphersuite, keyRotationSpan, externalSenders);
|
1904
|
+
const ret = await this.#cc.create_conversation(conversationId, config);
|
1905
|
+
return ret;
|
1906
|
+
}
|
1907
|
+
/**
|
1908
|
+
* Decrypts a message for a given conversation
|
1909
|
+
*
|
1910
|
+
* @param conversationId - The ID of the conversation
|
1911
|
+
* @param payload - The encrypted message buffer
|
1912
|
+
*
|
1913
|
+
* @returns Either a {@link DecryptedMessage} payload or `undefined` - This happens when the encrypted payload contains a system message such a proposal or commit
|
1914
|
+
*/
|
1915
|
+
async decryptMessage(conversationId, payload) {
|
1916
|
+
const ffiDecryptedMessage = await this.#cc.decrypt_message(conversationId, payload);
|
1917
|
+
const commitDelay = ffiDecryptedMessage.commit_delay ?
|
1918
|
+
ffiDecryptedMessage.commit_delay * 1000 :
|
1919
|
+
undefined;
|
1920
|
+
const ret = {
|
1921
|
+
message: ffiDecryptedMessage.message,
|
1922
|
+
proposals: ffiDecryptedMessage.proposals,
|
1923
|
+
isActive: ffiDecryptedMessage.is_active,
|
1924
|
+
commitDelay
|
1925
|
+
};
|
1926
|
+
return ret;
|
1927
|
+
}
|
1928
|
+
/**
|
1929
|
+
* Encrypts a message for a given conversation
|
1930
|
+
*
|
1931
|
+
* @param conversationId - The ID of the conversation
|
1932
|
+
* @param message - The plaintext message to encrypt
|
1933
|
+
*
|
1934
|
+
* @returns The encrypted payload for the given group. This needs to be fanned out to the other members of the group.
|
1935
|
+
*/
|
1936
|
+
async encryptMessage(conversationId, message) {
|
1937
|
+
return await this.#cc.encrypt_message(conversationId, message);
|
1938
|
+
}
|
1939
|
+
/**
|
1940
|
+
* Ingest a TLS-serialized MLS welcome message to join a an existing MLS group
|
1941
|
+
*
|
1942
|
+
* @param welcomeMessage - TLS-serialized MLS Welcome message
|
1943
|
+
* @returns The conversation ID of the newly joined group. You can use the same ID to decrypt/encrypt messages
|
1944
|
+
*/
|
1945
|
+
async processWelcomeMessage(welcomeMessage) {
|
1946
|
+
return await this.#cc.process_welcome_message(welcomeMessage);
|
1947
|
+
}
|
1948
|
+
/**
|
1949
|
+
* @returns The client's public key
|
1950
|
+
*/
|
1951
|
+
async clientPublicKey() {
|
1952
|
+
return await this.#cc.client_public_key();
|
1953
|
+
}
|
1954
|
+
/**
|
1955
|
+
* @returns The amount of valid, non-expired KeyPackages that are persisted in the backing storage
|
1956
|
+
*/
|
1957
|
+
async clientValidKeypackagesCount() {
|
1958
|
+
return await this.#cc.client_valid_keypackages_count();
|
1959
|
+
}
|
1960
|
+
/**
|
1961
|
+
* Fetches a requested amount of keypackages
|
1962
|
+
*
|
1963
|
+
* @param amountRequested - The amount of keypackages requested
|
1964
|
+
* @returns An array of length `amountRequested` containing TLS-serialized KeyPackages
|
1965
|
+
*/
|
1966
|
+
async clientKeypackages(amountRequested) {
|
1967
|
+
return await this.#cc.client_keypackages(amountRequested);
|
1968
|
+
}
|
1969
|
+
/**
|
1970
|
+
* Adds new clients to a conversation, assuming the current client has the right to add new clients to the conversation.
|
1971
|
+
*
|
1972
|
+
* **CAUTION**: {@link CoreCrypto.commitAccepted} **HAS TO** be called afterwards **ONLY IF** the Delivery Service responds
|
1973
|
+
* '200 OK' to the {@link CommitBundle} upload. It will "merge" the commit locally i.e. increment the local group
|
1974
|
+
* epoch, use new encryption secrets etc...
|
1975
|
+
*
|
1976
|
+
* @param conversationId - The ID of the conversation
|
1977
|
+
* @param clients - Array of {@link Invitee} (which are Client ID / KeyPackage pairs)
|
1978
|
+
*
|
1979
|
+
* @returns A {@link CommitBundle}
|
1980
|
+
*/
|
1981
|
+
async addClientsToConversation(conversationId, clients) {
|
1982
|
+
const ffiClients = clients.map((invitee) => new CoreCrypto.#module.Invitee(invitee.id, invitee.kp));
|
1983
|
+
const ffiRet = await this.#cc.add_clients_to_conversation(conversationId, ffiClients);
|
1984
|
+
ffiClients.forEach(c => c.free());
|
1985
|
+
const ret = {
|
1986
|
+
welcome: ffiRet.welcome,
|
1987
|
+
commit: ffiRet.commit,
|
1988
|
+
publicGroupState: ffiRet.public_group_state
|
1989
|
+
};
|
1990
|
+
return ret;
|
1991
|
+
}
|
1992
|
+
/**
|
1993
|
+
* Removes the provided clients from a conversation; Assuming those clients exist and the current client is allowed
|
1994
|
+
* to do so, otherwise this operation does nothing.
|
1995
|
+
*
|
1996
|
+
* **CAUTION**: {@link CoreCrypto.commitAccepted} **HAS TO** be called afterwards **ONLY IF** the Delivery Service responds
|
1997
|
+
* '200 OK' to the {@link CommitBundle} upload. It will "merge" the commit locally i.e. increment the local group
|
1998
|
+
* epoch, use new encryption secrets etc...
|
1999
|
+
*
|
2000
|
+
* @param conversationId - The ID of the conversation
|
2001
|
+
* @param clientIds - Array of Client IDs to remove.
|
2002
|
+
*
|
2003
|
+
* @returns A {@link CommitBundle}, or `undefined` if for any reason, the operation would result in an empty commit
|
2004
|
+
*/
|
2005
|
+
async removeClientsFromConversation(conversationId, clientIds) {
|
2006
|
+
const ffiRet = await this.#cc.remove_clients_from_conversation(conversationId, clientIds);
|
2007
|
+
const ret = {
|
2008
|
+
welcome: ffiRet.welcome,
|
2009
|
+
commit: ffiRet.commit,
|
2010
|
+
publicGroupState: ffiRet.public_group_state
|
2011
|
+
};
|
2012
|
+
return ret;
|
2013
|
+
}
|
2014
|
+
/**
|
2015
|
+
* Creates an update commit which forces every client to update their keypackages in the conversation
|
2016
|
+
*
|
2017
|
+
* **CAUTION**: {@link CoreCrypto.commitAccepted} **HAS TO** be called afterwards **ONLY IF** the Delivery Service responds
|
2018
|
+
* '200 OK' to the {@link CommitBundle} upload. It will "merge" the commit locally i.e. increment the local group
|
2019
|
+
* epoch, use new encryption secrets etc...
|
2020
|
+
*
|
2021
|
+
* @param conversationId - The ID of the conversation
|
2022
|
+
*
|
2023
|
+
* @returns A {@link CommitBundle}
|
2024
|
+
*/
|
2025
|
+
async updateKeyingMaterial(conversationId) {
|
2026
|
+
const ffiRet = await this.#cc.update_keying_material(conversationId);
|
2027
|
+
const ret = {
|
2028
|
+
welcome: ffiRet.welcome,
|
2029
|
+
commit: ffiRet.commit,
|
2030
|
+
publicGroupState: ffiRet.public_group_state
|
2031
|
+
};
|
2032
|
+
return ret;
|
2033
|
+
}
|
2034
|
+
/**
|
2035
|
+
* Commits the local pending proposals and returns the {@link CommitBundle} object containing what can result from this operation.
|
2036
|
+
*
|
2037
|
+
* **CAUTION**: {@link CoreCrypto.commitAccepted} **HAS TO** be called afterwards **ONLY IF** the Delivery Service responds
|
2038
|
+
* '200 OK' to the {@link CommitBundle} upload. It will "merge" the commit locally i.e. increment the local group
|
2039
|
+
* epoch, use new encryption secrets etc...
|
2040
|
+
*
|
2041
|
+
* @param conversationId - The ID of the conversation
|
2042
|
+
*
|
2043
|
+
* @returns A {@link CommitBundle}
|
2044
|
+
*/
|
2045
|
+
async commitPendingProposals(conversationId) {
|
2046
|
+
const ffiCommitBundle = await this.#cc.commit_pending_proposals(conversationId);
|
2047
|
+
const ret = {
|
2048
|
+
welcome: ffiCommitBundle.welcome,
|
2049
|
+
commit: ffiCommitBundle.commit,
|
2050
|
+
publicGroupState: ffiCommitBundle.public_group_state
|
2051
|
+
};
|
2052
|
+
return ret;
|
2053
|
+
}
|
2054
|
+
/**
|
2055
|
+
* Adds new clients to a conversation, assuming the current client has the right to add new clients to the conversation.
|
2056
|
+
* The returned {@link CommitBundle} is a TLS struct that needs to be fanned out to Delivery Service in order to validate the commit.
|
2057
|
+
* It also contains a Welcome message the Delivery Service will forward to invited clients and
|
2058
|
+
* an updated PublicGroupState required by clients willing to join the group by an external commit.
|
2059
|
+
*
|
2060
|
+
* **CAUTION**: {@link CoreCrypto.commitAccepted} **HAS TO** be called afterwards **ONLY IF** the Delivery Service responds
|
2061
|
+
* '200 OK' to the {@link CommitBundle} upload. It will "merge" the commit locally i.e. increment the local group
|
2062
|
+
* epoch, use new encryption secrets etc...
|
2063
|
+
*
|
2064
|
+
* @param conversationId - The ID of the conversation
|
2065
|
+
* @param clients - Array of {@link Invitee} (which are Client ID / KeyPackage pairs)
|
2066
|
+
*
|
2067
|
+
* @returns A {@link CommitBundle} byte array to fan out to the Delivery Service
|
2068
|
+
*/
|
2069
|
+
async finalAddClientsToConversation(conversationId, clients) {
|
2070
|
+
const ffiClients = clients.map((invitee) => new CoreCrypto.#module.Invitee(invitee.id, invitee.kp));
|
2071
|
+
const ret = await this.#cc.add_clients_to_conversation(conversationId, ffiClients);
|
2072
|
+
ffiClients.forEach(c => c.free());
|
2073
|
+
return ret;
|
2074
|
+
}
|
2075
|
+
/**
|
2076
|
+
* Removes the provided clients from a conversation; Assuming those clients exist and the current client is allowed
|
2077
|
+
* to do so, otherwise this operation does nothing.
|
2078
|
+
*
|
2079
|
+
* The returned {@link CommitBundle} is a TLS struct that needs to be fanned out to Delivery Service in order to validate the commit.
|
2080
|
+
* It also contains a Welcome message the Delivery Service will forward to invited clients and
|
2081
|
+
* an updated PublicGroupState required by clients willing to join the group by an external commit.
|
2082
|
+
*
|
2083
|
+
* **CAUTION**: {@link CoreCrypto.commitAccepted} **HAS TO** be called afterwards **ONLY IF** the Delivery Service responds
|
2084
|
+
* '200 OK' to the {@link CommitBundle} upload. It will "merge" the commit locally i.e. increment the local group
|
2085
|
+
* epoch, use new encryption secrets etc...
|
2086
|
+
*
|
2087
|
+
* @param conversationId - The ID of the conversation
|
2088
|
+
* @param clientIds - Array of Client IDs to remove.
|
2089
|
+
*
|
2090
|
+
* @returns A {@link CommitBundle} byte array to fan out to the Delivery Service, or `undefined` if for any reason, the operation would result in an empty commit
|
2091
|
+
*/
|
2092
|
+
async finalRemoveClientsFromConversation(conversationId, clientIds) {
|
2093
|
+
return await this.#cc.remove_clients_from_conversation(conversationId, clientIds);
|
2094
|
+
}
|
2095
|
+
/**
|
2096
|
+
* Creates an update commit which forces every client to update their keypackages in the conversation
|
2097
|
+
*
|
2098
|
+
* The returned {@link CommitBundle} is a TLS struct that needs to be fanned out to Delivery Service in order to validate the commit.
|
2099
|
+
* It also contains a Welcome message the Delivery Service will forward to invited clients and
|
2100
|
+
* an updated PublicGroupState required by clients willing to join the group by an external commit.
|
2101
|
+
*
|
2102
|
+
* **CAUTION**: {@link CoreCrypto.commitAccepted} **HAS TO** be called afterwards **ONLY IF** the Delivery Service responds
|
2103
|
+
* '200 OK' to the {@link CommitBundle} upload. It will "merge" the commit locally i.e. increment the local group
|
2104
|
+
* epoch, use new encryption secrets etc...
|
2105
|
+
*
|
2106
|
+
* @param conversationId - The ID of the conversation
|
2107
|
+
*
|
2108
|
+
* @returns A {@link CommitBundle} byte array to fan out to the Delivery Service
|
2109
|
+
*/
|
2110
|
+
async finalUpdateKeyingMaterial(conversationId) {
|
2111
|
+
return await this.#cc.update_keying_material(conversationId);
|
2112
|
+
}
|
2113
|
+
/**
|
2114
|
+
* Commits the local pending proposals and returns the {@link CommitBundle} object containing what can result from this operation.
|
2115
|
+
*
|
2116
|
+
* The returned {@link CommitBundle} is a TLS struct that needs to be fanned out to Delivery Service in order to validate the commit.
|
2117
|
+
* It also contains a Welcome message the Delivery Service will forward to invited clients and
|
2118
|
+
* an updated PublicGroupState required by clients willing to join the group by an external commit.
|
2119
|
+
*
|
2120
|
+
* **CAUTION**: {@link CoreCrypto.commitAccepted} **HAS TO** be called afterwards **ONLY IF** the Delivery Service responds
|
2121
|
+
* '200 OK' to the {@link CommitBundle} upload. It will "merge" the commit locally i.e. increment the local group
|
2122
|
+
* epoch, use new encryption secrets etc...
|
2123
|
+
*
|
2124
|
+
* @param conversationId - The ID of the conversation
|
2125
|
+
*
|
2126
|
+
* @returns A {@link CommitBundle} byte array to fan out to the Delivery Service
|
2127
|
+
*/
|
2128
|
+
async finalCommitPendingProposals(conversationId) {
|
2129
|
+
return await this.#cc.commit_pending_proposals(conversationId);
|
2130
|
+
}
|
2131
|
+
/**
|
2132
|
+
* Creates a new proposal for the provided Conversation ID
|
2133
|
+
*
|
2134
|
+
* @param proposalType - The type of proposal, see {@link ProposalType}
|
2135
|
+
* @param args - The arguments of the proposal, see {@link ProposalArgs}, {@link AddProposalArgs} or {@link RemoveProposalArgs}
|
2136
|
+
*
|
2137
|
+
* @returns A {@link ProposalBundle} containing the Proposal and its reference in order to roll it back if necessary
|
2138
|
+
*/
|
2139
|
+
async newProposal(proposalType, args) {
|
2140
|
+
switch (proposalType) {
|
2141
|
+
case 0 /* ProposalType.Add */: {
|
2142
|
+
if (!args.kp) {
|
2143
|
+
throw new Error("kp is not contained in the proposal arguments");
|
2144
|
+
}
|
2145
|
+
return await this.#cc.new_add_proposal(args.conversationId, args.kp);
|
2146
|
+
}
|
2147
|
+
case 1 /* ProposalType.Remove */: {
|
2148
|
+
if (!args.clientId) {
|
2149
|
+
throw new Error("clientId is not contained in the proposal arguments");
|
2150
|
+
}
|
2151
|
+
return await this.#cc.new_remove_proposal(args.conversationId, args.clientId);
|
2152
|
+
}
|
2153
|
+
case 2 /* ProposalType.Update */: {
|
2154
|
+
return await this.#cc.new_update_proposal(args.conversationId);
|
2155
|
+
}
|
2156
|
+
default:
|
2157
|
+
throw new Error("Invalid proposal type!");
|
2158
|
+
}
|
2159
|
+
}
|
2160
|
+
async newExternalProposal(externalProposalType, args) {
|
2161
|
+
switch (externalProposalType) {
|
2162
|
+
case 0 /* ExternalProposalType.Add */: {
|
2163
|
+
return await this.#cc.new_external_add_proposal(args.conversationId, args.epoch);
|
2164
|
+
}
|
2165
|
+
case 1 /* ExternalProposalType.Remove */: {
|
2166
|
+
if (!args.keyPackageRef) {
|
2167
|
+
throw new Error("keyPackageRef is not contained in the external proposal arguments");
|
2168
|
+
}
|
2169
|
+
return await this.#cc.new_external_remove_proposal(args.conversationId, args.epoch, args.keyPackageRef);
|
2170
|
+
}
|
2171
|
+
default:
|
2172
|
+
throw new Error("Invalid external proposal type!");
|
2173
|
+
}
|
2174
|
+
}
|
2175
|
+
/**
|
2176
|
+
* Exports public group state for use in external commits
|
2177
|
+
*
|
2178
|
+
* @param conversationId - MLS Conversation ID
|
2179
|
+
* @returns TLS-serialized MLS public group state
|
2180
|
+
*/
|
2181
|
+
async exportGroupState(conversationId) {
|
2182
|
+
return await this.#cc.export_group_state(conversationId);
|
2183
|
+
}
|
2184
|
+
/**
|
2185
|
+
* Allows to create an external commit to "apply" to join a group through its public group state
|
2186
|
+
*
|
2187
|
+
* Also see the second step of this process: {@link CoreCrypto.mergePendingGroupFromExternalCommit}
|
2188
|
+
*
|
2189
|
+
* @param publicGroupState - The public group state that can be fetched from the backend for a given conversation
|
2190
|
+
* @returns see {@link MlsConversationInitMessage}
|
2191
|
+
*/
|
2192
|
+
async joinByExternalCommit(publicGroupState) {
|
2193
|
+
const ffiInitMessage = await this.#cc.join_by_external_commit(publicGroupState);
|
2194
|
+
const ret = {
|
2195
|
+
group: ffiInitMessage.group,
|
2196
|
+
commit: ffiInitMessage.commit
|
2197
|
+
};
|
2198
|
+
return ret;
|
2199
|
+
}
|
2200
|
+
/**
|
2201
|
+
* This is the second step of the process of joining a group through an external commit
|
2202
|
+
*
|
2203
|
+
* This step makes the group operational and ready to encrypt/decrypt message
|
2204
|
+
*
|
2205
|
+
* @param conversationId - The ID of the conversation
|
2206
|
+
* @param configuration - Configuration of the group, see {@link ConversationConfiguration}
|
2207
|
+
*/
|
2208
|
+
async mergePendingGroupFromExternalCommit(conversationId, configuration) {
|
2209
|
+
const { admins, ciphersuite, keyRotationSpan, externalSenders } = configuration ?? {};
|
2210
|
+
const config = new CoreCrypto.#module.ConversationConfiguration(admins, ciphersuite, keyRotationSpan, externalSenders);
|
2211
|
+
return await this.#cc.merge_pending_group_from_external_commit(conversationId, config);
|
2212
|
+
}
|
2213
|
+
/**
|
2214
|
+
* Allows to mark the latest commit produced as "accepted" and be able to safely merge it
|
2215
|
+
* into the local group state
|
2216
|
+
*
|
2217
|
+
* @param conversationId - The group's ID
|
2218
|
+
*/
|
2219
|
+
async commitAccepted(conversationId) {
|
2220
|
+
return await this.#cc.commit_accepted(conversationId);
|
2221
|
+
}
|
2222
|
+
/**
|
2223
|
+
* Allows {@link CoreCrypto} to act as a CSPRNG provider
|
2224
|
+
* @note The underlying CSPRNG algorithm is ChaCha20 and takes in account the external seed provider either at init time or provided with {@link CoreCrypto.reseedRng}
|
2225
|
+
*
|
2226
|
+
* @param length - The number of bytes to be returned in the `Uint8Array`
|
2227
|
+
*
|
2228
|
+
* @returns A `Uint8Array` buffer that contains `length` cryptographically-secure random bytes
|
2229
|
+
*/
|
2230
|
+
async randomBytes(length) {
|
2231
|
+
return await this.#cc.random_bytes(length);
|
2232
|
+
}
|
2233
|
+
/**
|
2234
|
+
* Allows to reseed {@link CoreCrypto}'s internal CSPRNG with a new seed.
|
2235
|
+
*
|
2236
|
+
* @param seed - **exactly 32** bytes buffer seed
|
2237
|
+
*/
|
2238
|
+
async reseedRng(seed) {
|
2239
|
+
if (seed.length !== 32) {
|
2240
|
+
throw new Error(`The seed length needs to be exactly 32 bytes. ${seed.length} bytes provided.`);
|
2241
|
+
}
|
2242
|
+
return await this.#cc.reseed_rng(seed);
|
2243
|
+
}
|
2244
|
+
/**
|
2245
|
+
* Allows to remove a pending proposal (rollback). Use this when backend rejects the proposal you just sent e.g. if permissions
|
2246
|
+
* have changed meanwhile.
|
2247
|
+
*
|
2248
|
+
* **CAUTION**: only use this when you had an explicit response from the Delivery Service
|
2249
|
+
* e.g. 403 or 409. Do not use otherwise e.g. 5xx responses, timeout etc..
|
2250
|
+
*
|
2251
|
+
* @param conversationId - The group's ID
|
2252
|
+
* @param proposalRef - A reference to the proposal to delete. You get one when using {@link CoreCrypto.newProposal}
|
2253
|
+
*/
|
2254
|
+
async clear_pending_proposal(conversationId, proposalRef) {
|
2255
|
+
return await this.#cc.clear_pending_proposal(conversationId, proposalRef);
|
2256
|
+
}
|
2257
|
+
/**
|
2258
|
+
* Allows to remove a pending commit (rollback). Use this when backend rejects the commit you just sent e.g. if permissions
|
2259
|
+
* have changed meanwhile.
|
2260
|
+
*
|
2261
|
+
* **CAUTION**: only use this when you had an explicit response from the Delivery Service
|
2262
|
+
* e.g. 403. Do not use otherwise e.g. 5xx responses, timeout etc..
|
2263
|
+
* **DO NOT** use when Delivery Service responds 409, pending state will be renewed
|
2264
|
+
* in {@link CoreCrypto.decrypt_message}
|
2265
|
+
*
|
2266
|
+
* @param conversationId - The group's ID
|
2267
|
+
*/
|
2268
|
+
async clear_pending_commit(conversationId) {
|
2269
|
+
return await this.#cc.clear_pending_commit(conversationId);
|
2270
|
+
}
|
2271
|
+
/**
|
2272
|
+
* Returns the current version of {@link CoreCrypto}
|
2273
|
+
*
|
2274
|
+
* @returns The `core-crypto-ffi` version as defined in its `Cargo.toml` file
|
2275
|
+
*/
|
2276
|
+
static version() {
|
2277
|
+
if (!this.#module) {
|
2278
|
+
throw new Error("Internal module hasn't been initialized. Please use `await CoreCrypto.init(params)`!");
|
2279
|
+
}
|
2280
|
+
return this.#module.version();
|
2281
|
+
}
|
2282
|
+
}
|
2283
|
+
|
2284
|
+
export { CoreCrypto };
|