Revision control
Copy as Markdown
Other Tools
let imports = {};
imports['__wbindgen_placeholder__'] = module.exports;
let wasm;
let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
cachedTextDecoder.decode();
let cachedUint8ArrayMemory0 = null;
function getUint8ArrayMemory0() {
if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
}
return cachedUint8ArrayMemory0;
}
function getStringFromWasm0(ptr, len) {
ptr = ptr >>> 0;
return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
}
const heap = new Array(128).fill(undefined);
heap.push(undefined, null, true, false);
let heap_next = heap.length;
function addHeapObject(obj) {
if (heap_next === heap.length) heap.push(heap.length + 1);
const idx = heap_next;
heap_next = heap[idx];
heap[idx] = obj;
return idx;
}
function getObject(idx) { return heap[idx]; }
function dropObject(idx) {
if (idx < 132) return;
heap[idx] = heap_next;
heap_next = idx;
}
function takeObject(idx) {
const ret = getObject(idx);
dropObject(idx);
return ret;
}
let WASM_VECTOR_LEN = 0;
let cachedTextEncoder = new TextEncoder('utf-8');
const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
? function (arg, view) {
return cachedTextEncoder.encodeInto(arg, view);
}
: function (arg, view) {
const buf = cachedTextEncoder.encode(arg);
view.set(buf);
return {
read: arg.length,
written: buf.length
};
});
function passStringToWasm0(arg, malloc, realloc) {
if (realloc === undefined) {
const buf = cachedTextEncoder.encode(arg);
const ptr = malloc(buf.length, 1) >>> 0;
getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
WASM_VECTOR_LEN = buf.length;
return ptr;
}
let len = arg.length;
let ptr = malloc(len, 1) >>> 0;
const mem = getUint8ArrayMemory0();
let offset = 0;
for (; offset < len; offset++) {
const code = arg.charCodeAt(offset);
if (code > 0x7F) break;
mem[ptr + offset] = code;
}
if (offset !== len) {
if (offset !== 0) {
arg = arg.slice(offset);
}
ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
const ret = encodeString(arg, view);
offset += ret.written;
ptr = realloc(ptr, len, offset, 1) >>> 0;
}
WASM_VECTOR_LEN = offset;
return ptr;
}
function isLikeNone(x) {
return x === undefined || x === null;
}
let cachedDataViewMemory0 = null;
function getDataViewMemory0() {
if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
}
return cachedDataViewMemory0;
}
function debugString(val) {
// primitive types
const type = typeof val;
if (type == 'number' || type == 'boolean' || val == null) {
return `${val}`;
}
if (type == 'string') {
return `"${val}"`;
}
if (type == 'symbol') {
const description = val.description;
if (description == null) {
return 'Symbol';
} else {
return `Symbol(${description})`;
}
}
if (type == 'function') {
const name = val.name;
if (typeof name == 'string' && name.length > 0) {
return `Function(${name})`;
} else {
return 'Function';
}
}
// objects
if (Array.isArray(val)) {
const length = val.length;
let debug = '[';
if (length > 0) {
debug += debugString(val[0]);
}
for(let i = 1; i < length; i++) {
debug += ', ' + debugString(val[i]);
}
debug += ']';
return debug;
}
// Test for built-in
const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
let className;
if (builtInMatches.length > 1) {
className = builtInMatches[1];
} else {
// Failed to match the standard '[object ClassName]'
return toString.call(val);
}
if (className == 'Object') {
// we're a user defined class or Object
// JSON.stringify avoids problems with cycles, and is generally much
// easier than looping through ownProperties of `val`.
try {
return 'Object(' + JSON.stringify(val) + ')';
} catch (_) {
return 'Object';
}
}
// errors
if (val instanceof Error) {
return `${val.name}: ${val.message}\n${val.stack}`;
}
// TODO we could test for more things here, like `Set`s and `Map`s.
return className;
}
const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(state => {
wasm.__wbindgen_export_2.get(state.dtor)(state.a, state.b)
});
function makeMutClosure(arg0, arg1, dtor, f) {
const state = { a: arg0, b: arg1, cnt: 1, dtor };
const real = (...args) => {
// First up with a closure we increment the internal reference
// count. This ensures that the Rust closure environment won't
// be deallocated while we're invoking it.
state.cnt++;
const a = state.a;
state.a = 0;
try {
return f(a, state.b, ...args);
} finally {
if (--state.cnt === 0) {
wasm.__wbindgen_export_2.get(state.dtor)(a, state.b);
CLOSURE_DTORS.unregister(state);
} else {
state.a = a;
}
}
};
real.original = state;
CLOSURE_DTORS.register(real, state, state);
return real;
}
function __wbg_adapter_56(arg0, arg1, arg2) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h95a9e2867f61122c(retptr, arg0, arg1, addHeapObject(arg2));
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
if (r1) {
throw takeObject(r0);
}
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
function makeClosure(arg0, arg1, dtor, f) {
const state = { a: arg0, b: arg1, cnt: 1, dtor };
const real = (...args) => {
// First up with a closure we increment the internal reference
// count. This ensures that the Rust closure environment won't
// be deallocated while we're invoking it.
state.cnt++;
try {
return f(state.a, state.b, ...args);
} finally {
if (--state.cnt === 0) {
wasm.__wbindgen_export_2.get(state.dtor)(state.a, state.b);
state.a = 0;
CLOSURE_DTORS.unregister(state);
}
}
};
real.original = state;
CLOSURE_DTORS.register(real, state, state);
return real;
}
function __wbg_adapter_59(arg0, arg1) {
wasm._dyn_core__ops__function__Fn_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h973efdedfdd2a86f(arg0, arg1);
}
function __wbg_adapter_62(arg0, arg1, arg2) {
wasm._dyn_core__ops__function__Fn__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hd01c0f98de19fc7b(arg0, arg1, addHeapObject(arg2));
}
function __wbg_adapter_65(arg0, arg1, arg2) {
wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hbc1c09334b27c16a(arg0, arg1, addHeapObject(arg2));
}
function __wbg_adapter_68(arg0, arg1) {
wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h4bb0da6c50107183(arg0, arg1);
}
function passArray8ToWasm0(arg, malloc) {
const ptr = malloc(arg.length * 1, 1) >>> 0;
getUint8ArrayMemory0().set(arg, ptr / 1);
WASM_VECTOR_LEN = arg.length;
return ptr;
}
function _assertClass(instance, klass) {
if (!(instance instanceof klass)) {
throw new Error(`expected instance of ${klass.name}`);
}
return instance.ptr;
}
function getArrayU8FromWasm0(ptr, len) {
ptr = ptr >>> 0;
return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
}
function passArrayJsValueToWasm0(array, malloc) {
const ptr = malloc(array.length * 4, 4) >>> 0;
const mem = getDataViewMemory0();
for (let i = 0; i < array.length; i++) {
mem.setUint32(ptr + 4 * i, addHeapObject(array[i]), true);
}
WASM_VECTOR_LEN = array.length;
return ptr;
}
let stack_pointer = 128;
function addBorrowedObject(obj) {
if (stack_pointer == 1) throw new Error('out of js stack');
heap[--stack_pointer] = obj;
return stack_pointer;
}
function getArrayJsValueFromWasm0(ptr, len) {
ptr = ptr >>> 0;
const mem = getDataViewMemory0();
const result = [];
for (let i = ptr; i < ptr + 4 * len; i += 4) {
result.push(takeObject(mem.getUint32(i, true)));
}
return result;
}
/**
* Get the versions of the Rust libraries we are using.
* @returns {Versions}
*/
module.exports.getVersions = function() {
const ret = wasm.getVersions();
return Versions.__wrap(ret);
};
/**
* Run some stuff when the Wasm module is instantiated.
*
* Right now, it does the following:
*
* * Redirect Rust panics to JavaScript console.
*/
module.exports.start = function() {
wasm.start();
};
let cachedUint16ArrayMemory0 = null;
function getUint16ArrayMemory0() {
if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.byteLength === 0) {
cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
}
return cachedUint16ArrayMemory0;
}
function getArrayU16FromWasm0(ptr, len) {
ptr = ptr >>> 0;
return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
}
function handleError(f, args) {
try {
return f.apply(this, args);
} catch (e) {
wasm.__wbindgen_exn_store(addHeapObject(e));
}
}
function __wbg_adapter_892(arg0, arg1, arg2, arg3) {
wasm.wasm_bindgen__convert__closures__invoke2_mut__h4b2af4a28ee98ea7(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
}
/**
* The mode of the QR code login.
*
* The QR code login mechanism supports both, the new device, as well as the
* existing device to display the QR code.
*
* The different modes have an explicit one-byte identifier which gets added to
* the QR code data.
*/
module.exports.QrCodeMode = Object.freeze({
/**
* The new device is displaying the QR code.
*/
Login:0,"0":"Login",
/**
* The existing device is displaying the QR code.
*/
Reciprocate:1,"1":"Reciprocate", });
/**
* Decryption error codes
*/
module.exports.DecryptionErrorCode = Object.freeze({
/**
* The room key is not known
*/
MissingRoomKey:0,"0":"MissingRoomKey",
/**
* The room key is known but ratcheted
*/
UnknownMessageIndex:1,"1":"UnknownMessageIndex",
/**
* Decryption failed because of a mismatch between the identity keys of the
* device we received the room key from and the identity keys recorded in
* the plaintext of the room key to-device message.
*/
MismatchedIdentityKeys:2,"2":"MismatchedIdentityKeys",
/**
* We weren't able to link the message back to any known device.
*/
UnknownSenderDevice:3,"3":"UnknownSenderDevice",
/**
* The sender device is not cross-signed.
*/
UnsignedSenderDevice:4,"4":"UnsignedSenderDevice",
/**
* The sender's identity is unverified, but was previously verified.
*/
SenderIdentityPreviouslyVerified:5,"5":"SenderIdentityPreviouslyVerified",
/**
* Other failure.
*/
UnableToDecrypt:6,"6":"UnableToDecrypt", });
/**
* Represent the type of a request.
*/
module.exports.RequestType = Object.freeze({
/**
* Represents a `KeysUploadRequest`.
*/
KeysUpload:0,"0":"KeysUpload",
/**
* Represents a `KeysQueryRequest`.
*/
KeysQuery:1,"1":"KeysQuery",
/**
* Represents a `KeysClaimRequest`.
*/
KeysClaim:2,"2":"KeysClaim",
/**
* Represents a `ToDeviceRequest`.
*/
ToDevice:3,"3":"ToDevice",
/**
* Represents a `SignatureUploadRequest`.
*/
SignatureUpload:4,"4":"SignatureUpload",
/**
* Represents a `RoomMessageRequest`.
*/
RoomMessage:5,"5":"RoomMessage",
/**
* Represents a `KeysBackupRequest`.
*/
KeysBackup:6,"6":"KeysBackup", });
/**
* A machine-readable representation of the authenticity for a `ShieldState`.
*/
module.exports.ShieldStateCode = Object.freeze({
/**
* Not enough information available to check the authenticity.
*/
AuthenticityNotGuaranteed:0,"0":"AuthenticityNotGuaranteed",
/**
* The sending device isn't yet known by the Client.
*/
UnknownDevice:1,"1":"UnknownDevice",
/**
* The sending device hasn't been verified by the sender.
*/
UnsignedDevice:2,"2":"UnsignedDevice",
/**
* The sender hasn't been verified by the Client's user.
*/
UnverifiedIdentity:3,"3":"UnverifiedIdentity",
/**
* An unencrypted event in an encrypted room.
*/
SentInClear:4,"4":"SentInClear",
/**
* The sender was previously verified but changed their identity.
*/
PreviouslyVerified:5,"5":"PreviouslyVerified", });
/**
* List of available verification methods.
*/
module.exports.VerificationMethod = Object.freeze({
/**
* The `m.sas.v1` verification method.
*
* SAS means Short Authentication String.
*/
SasV1:0,"0":"SasV1",
/**
* The `m.qr_code.scan.v1` verification method.
*/
QrCodeScanV1:1,"1":"QrCodeScanV1",
/**
* The `m.qr_code.show.v1` verification method.
*/
QrCodeShowV1:2,"2":"QrCodeShowV1",
/**
* The `m.reciprocate.v1` verification method.
*/
ReciprocateV1:3,"3":"ReciprocateV1", });
/**
* An enum over the different key types a device can have.
*
* Currently devices have a curve25519 and ed25519 keypair. The keys
* transport format is a base64 encoded string, any unknown key type
* will be left as such a string.
*/
module.exports.DeviceKeyName = Object.freeze({
/**
* The curve25519 device key.
*/
Curve25519:0,"0":"Curve25519",
/**
* The ed25519 device key.
*/
Ed25519:1,"1":"Ed25519",
/**
* An unknown device key.
*/
Unknown:2,"2":"Unknown", });
/**
* Logger level.
*/
module.exports.LoggerLevel = Object.freeze({
/**
* `TRACE` level.
*
* Designate very low priority, often extremely verbose,
* information.
*/
Trace:0,"0":"Trace",
/**
* `DEBUG` level.
*
* Designate lower priority information.
*/
Debug:1,"1":"Debug",
/**
* `INFO` level.
*
* Designate useful information.
*/
Info:2,"2":"Info",
/**
* `WARN` level.
*
* Designate hazardous situations.
*/
Warn:3,"3":"Warn",
/**
* `ERROR` level.
*
* Designate very serious errors.
*/
Error:4,"4":"Error", });
/**
* The trust level required to decrypt an event
*/
module.exports.TrustRequirement = Object.freeze({
/**
* Decrypt events from everyone regardless of trust
*/
Untrusted:0,"0":"Untrusted",
/**
* Only decrypt events from cross-signed or legacy devices
*/
CrossSignedOrLegacy:1,"1":"CrossSignedOrLegacy",
/**
* Only decrypt events from cross-signed devices
*/
CrossSigned:2,"2":"CrossSigned", });
/**
* The basic key algorithm names in the specification.
*/
module.exports.DeviceKeyAlgorithmName = Object.freeze({
/**
* The Ed25519 signature algorithm.
*/
Ed25519:0,"0":"Ed25519",
/**
* The Curve25519 ECDH algorithm.
*/
Curve25519:1,"1":"Curve25519",
/**
* The Curve25519 ECDH algorithm, but the key also contains
* signatures.
*/
SignedCurve25519:2,"2":"SignedCurve25519",
/**
* An unknown device key algorithm.
*/
Unknown:3,"3":"Unknown", });
/**
* Take a look at [`matrix_sdk_common::deserialized_responses::ShieldState`]
* for more info.
*/
module.exports.ShieldColor = Object.freeze({
/**
* Important warning
*/
Red:0,"0":"Red",
/**
* Low warning
*/
Grey:1,"1":"Grey",
/**
* No warning
*/
None:2,"2":"None", });
/**
* List of VerificationRequestState phases
*/
module.exports.VerificationRequestPhase = Object.freeze({
/**
* The verification request has been newly created by us.
*/
Created:0,"0":"Created",
/**
* The verification request was received from the other party.
*/
Requested:1,"1":"Requested",
/**
* The verification request is ready to start a verification flow.
*/
Ready:2,"2":"Ready",
/**
* The verification request has transitioned into a concrete verification
* flow. For example it transitioned into the emoji based SAS
* verification.
*/
Transitioned:3,"3":"Transitioned",
/**
* The verification flow that was started with this request has finished.
*/
Done:4,"4":"Done",
/**
* The verification process has been cancelled.
*/
Cancelled:5,"5":"Cancelled", });
/**
* List of `Qr` states
*/
module.exports.QrState = Object.freeze({
/**
* We have received the other device's details (from the
* `m.key.verification.request` or `m.key.verification.ready`) and
* established the shared secret, so can
* display the QR code.
*/
Created:0,"0":"Created",
/**
* The other side has scanned our QR code and sent an
* `m.key.verification.start` message with `method: m.reciprocate.v1` with
* matching shared secret.
*/
Scanned:1,"1":"Scanned",
/**
* Our user has confirmed that the other device scanned successfully. We
* have sent an `m.key.verification.done`.
*/
Confirmed:2,"2":"Confirmed",
/**
* We have scanned the other side's QR code and are able to send a
* `m.key.verification.start` message with `method: m.reciprocate.v1`.
*
* Call `Qr::reciprocate` to build the start message.
*
* Note that, despite the name of this state, we have not necessarily
* yet sent the `m.reciprocate.v1` message.
*/
Reciprocated:3,"3":"Reciprocated",
/**
* Verification complete: we have received an `m.key.verification.done`
* from the other side.
*/
Done:4,"4":"Done",
/**
* Verification cancelled or failed.
*/
Cancelled:5,"5":"Cancelled", });
/**
* An encryption algorithm to be used to encrypt messages sent to a
* room.
*/
module.exports.EncryptionAlgorithm = Object.freeze({
/**
* Olm version 1 using Curve25519, AES-256, and SHA-256.
*/
OlmV1Curve25519AesSha2:0,"0":"OlmV1Curve25519AesSha2",
/**
* Megolm version 1 using AES-256 and SHA-256.
*/
MegolmV1AesSha2:1,"1":"MegolmV1AesSha2",
/**
* Unsupported algorithm.
*
* Applications should ignore this value if it is received, and should
* never set it.
*/
Unknown:2,"2":"Unknown", });
/**
* The local trust state of a device.
*/
module.exports.LocalTrust = Object.freeze({
/**
* The device has been verified and is trusted.
*/
Verified:0,"0":"Verified",
/**
* The device been blacklisted from communicating.
*/
BlackListed:1,"1":"BlackListed",
/**
* The trust state of the device is being ignored.
*/
Ignored:2,"2":"Ignored",
/**
* The trust state is unset.
*/
Unset:3,"3":"Unset", });
/**
* The result of a signature check.
*/
module.exports.SignatureState = Object.freeze({
/**
* The signature is missing.
*/
Missing:0,"0":"Missing",
/**
* The signature is invalid.
*/
Invalid:1,"1":"Invalid",
/**
* The signature is valid but the device or user identity that created the
* signature is not trusted.
*/
ValidButNotTrusted:2,"2":"ValidButNotTrusted",
/**
* The signature is valid and the device or user identity that created the
* signature is trusted.
*/
ValidAndTrusted:3,"3":"ValidAndTrusted", });
/**
* Who can see a room's history.
*/
module.exports.HistoryVisibility = Object.freeze({
/**
* Previous events are accessible to newly joined members from
* the point they were invited onwards.
*
* Events stop being accessible when the member's state changes
* to something other than *invite* or *join*.
*/
Invited:0,"0":"Invited",
/**
* Previous events are accessible to newly joined members from
* the point they joined the room onwards.
*
* Events stop being accessible when the member's state changes
* to something other than *join*.
*/
Joined:1,"1":"Joined",
/**
* Previous events are always accessible to newly joined members.
*
* All events in the room are accessible, even those sent when
* the member was not a part of the room.
*/
Shared:2,"2":"Shared",
/**
* All events while this is the `HistoryVisibility` value may be
* shared by any participating homeserver with anyone, regardless
* of whether they have ever joined the room.
*/
WorldReadable:3,"3":"WorldReadable", });
const AttachmentFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_attachment_free(ptr >>> 0, 1));
/**
* A type to encrypt and to decrypt anything that can fit in an
* `Uint8Array`, usually big buffer.
*/
class Attachment {
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
AttachmentFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_attachment_free(ptr, 0);
}
/**
* Encrypt the content of the `Uint8Array`.
*
* It produces an `EncryptedAttachment`, which can be used to
* retrieve the media encryption information, or the encrypted
* data.
* @param {Uint8Array} array
* @returns {EncryptedAttachment}
*/
static encrypt(array) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passArray8ToWasm0(array, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
wasm.attachment_encrypt(retptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return EncryptedAttachment.__wrap(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Decrypt an `EncryptedAttachment`.
*
* The encrypted attachment can be created manually, or from the
* `encrypt` method.
*
* **Warning**: The encrypted attachment can be used only
* **once**! The encrypted data will still be present, but the
* media encryption info (which contain secrets) will be
* destroyed. It is still possible to get a JSON-encoded backup
* by calling `EncryptedAttachment.mediaEncryptionInfo`.
* @param {EncryptedAttachment} attachment
* @returns {Uint8Array}
*/
static decrypt(attachment) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
_assertClass(attachment, EncryptedAttachment);
wasm.attachment_decrypt(retptr, attachment.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
if (r3) {
throw takeObject(r2);
}
var v1 = getArrayU8FromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
}
module.exports.Attachment = Attachment;
const BackupDecryptionKeyFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_backupdecryptionkey_free(ptr >>> 0, 1));
/**
* The private part of the backup key, the one used for recovery.
*/
class BackupDecryptionKey {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(BackupDecryptionKey.prototype);
obj.__wbg_ptr = ptr;
BackupDecryptionKeyFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
BackupDecryptionKeyFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_backupdecryptionkey_free(ptr, 0);
}
/**
* Create a new random [`BackupDecryptionKey`].
* @returns {BackupDecryptionKey}
*/
static createRandomKey() {
const ret = wasm.backupdecryptionkey_createRandomKey();
return BackupDecryptionKey.__wrap(ret);
}
/**
* Try to create a [`BackupDecryptionKey`] from a base 64 encoded string.
* @param {string} key
* @returns {BackupDecryptionKey}
*/
static fromBase64(key) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.backupdecryptionkey_fromBase64(retptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return BackupDecryptionKey.__wrap(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Convert the backup decryption key to a base 64 encoded string.
* @returns {string}
*/
toBase64() {
const ret = wasm.backupdecryptionkey_toBase64(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Get the public part of the backup key.
* @returns {MegolmV1BackupKey}
*/
get megolmV1PublicKey() {
const ret = wasm.backupdecryptionkey_megolmV1PublicKey(this.__wbg_ptr);
return MegolmV1BackupKey.__wrap(ret);
}
/**
* Try to decrypt a message that was encrypted using the public part of the
* backup key.
* @param {string} ephemeral_key
* @param {string} mac
* @param {string} ciphertext
* @returns {string}
*/
decryptV1(ephemeral_key, mac, ciphertext) {
let deferred5_0;
let deferred5_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(ephemeral_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ptr1 = passStringToWasm0(mac, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
const ptr2 = passStringToWasm0(ciphertext, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len2 = WASM_VECTOR_LEN;
wasm.backupdecryptionkey_decryptV1(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
var ptr4 = r0;
var len4 = r1;
if (r3) {
ptr4 = 0; len4 = 0;
throw takeObject(r2);
}
deferred5_0 = ptr4;
deferred5_1 = len4;
return getStringFromWasm0(ptr4, len4);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
}
}
}
module.exports.BackupDecryptionKey = BackupDecryptionKey;
const BackupKeysFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_backupkeys_free(ptr >>> 0, 1));
/**
* Stored versions of the backup keys.
*/
class BackupKeys {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(BackupKeys.prototype);
obj.__wbg_ptr = ptr;
BackupKeysFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
BackupKeysFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_backupkeys_free(ptr, 0);
}
/**
* The key used to decrypt backed up room keys
* @returns {BackupDecryptionKey | undefined}
*/
get decryptionKey() {
const ret = wasm.__wbg_get_backupkeys_decryptionKey(this.__wbg_ptr);
return ret === 0 ? undefined : BackupDecryptionKey.__wrap(ret);
}
/**
* The key used to decrypt backed up room keys
* @param {BackupDecryptionKey | undefined} [arg0]
*/
set decryptionKey(arg0) {
let ptr0 = 0;
if (!isLikeNone(arg0)) {
_assertClass(arg0, BackupDecryptionKey);
ptr0 = arg0.__destroy_into_raw();
}
wasm.__wbg_set_backupkeys_decryptionKey(this.__wbg_ptr, ptr0);
}
/**
* The version that we are using for backups.
* @returns {string | undefined}
*/
get backupVersion() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.__wbg_get_backupkeys_backupVersion(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
let v1;
if (r0 !== 0) {
v1 = getStringFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
}
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* The version that we are using for backups.
* @param {string | undefined} [arg0]
*/
set backupVersion(arg0) {
var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
var len0 = WASM_VECTOR_LEN;
wasm.__wbg_set_backupkeys_backupVersion(this.__wbg_ptr, ptr0, len0);
}
/**
* The key used to decrypt backed up room keys, encoded as base64
*
* @deprecated Use `BackupKeys.decryptionKey.toBase64()`
* @returns {string | undefined}
*/
get decryptionKeyBase64() {
const ret = wasm.backupkeys_decryptionKeyBase64(this.__wbg_ptr);
return takeObject(ret);
}
}
module.exports.BackupKeys = BackupKeys;
const BackupSecretsBundleFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_backupsecretsbundle_free(ptr >>> 0, 1));
/**
* The backup-specific parts of a secrets bundle.
*/
class BackupSecretsBundle {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(BackupSecretsBundle.prototype);
obj.__wbg_ptr = ptr;
BackupSecretsBundleFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
BackupSecretsBundleFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_backupsecretsbundle_free(ptr, 0);
}
/**
* The backup decryption key, encoded as unpadded base64.
* @returns {string}
*/
get key() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.__wbg_get_backupsecretsbundle_key(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* The backup decryption key, encoded as unpadded base64.
* @param {string} arg0
*/
set key(arg0) {
const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.__wbg_set_backupsecretsbundle_key(this.__wbg_ptr, ptr0, len0);
}
/**
* The backup version which this backup decryption key is used with.
* @returns {string}
*/
get backup_version() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.__wbg_get_backupsecretsbundle_backup_version(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* The backup version which this backup decryption key is used with.
* @param {string} arg0
*/
set backup_version(arg0) {
const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.__wbg_set_backupsecretsbundle_backup_version(this.__wbg_ptr, ptr0, len0);
}
}
module.exports.BackupSecretsBundle = BackupSecretsBundle;
const BaseMigrationDataFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_basemigrationdata_free(ptr >>> 0, 1));
/**
* The base dataset that is important to migrate to the Rust SDK.
*
* Can be imported into the rust store with {@link #migrateBaseData}.
*/
class BaseMigrationData {
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
BaseMigrationDataFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_basemigrationdata_free(ptr, 0);
}
/**
* The user id of the account owner.
* @returns {UserId | undefined}
*/
get userId() {
const ret = wasm.__wbg_get_basemigrationdata_userId(this.__wbg_ptr);
return ret === 0 ? undefined : UserId.__wrap(ret);
}
/**
* The user id of the account owner.
* @param {UserId | undefined} [arg0]
*/
set userId(arg0) {
let ptr0 = 0;
if (!isLikeNone(arg0)) {
_assertClass(arg0, UserId);
ptr0 = arg0.__destroy_into_raw();
}
wasm.__wbg_set_basemigrationdata_userId(this.__wbg_ptr, ptr0);
}
/**
* The device ID of the account owner.
* @returns {DeviceId | undefined}
*/
get deviceId() {
const ret = wasm.__wbg_get_basemigrationdata_deviceId(this.__wbg_ptr);
return ret === 0 ? undefined : DeviceId.__wrap(ret);
}
/**
* The device ID of the account owner.
* @param {DeviceId | undefined} [arg0]
*/
set deviceId(arg0) {
let ptr0 = 0;
if (!isLikeNone(arg0)) {
_assertClass(arg0, DeviceId);
ptr0 = arg0.__destroy_into_raw();
}
wasm.__wbg_set_basemigrationdata_deviceId(this.__wbg_ptr, ptr0);
}
/**
* The pickle string holding the Olm Account, as returned by
* `olm_pickle_account` in libolm.
* @returns {string}
*/
get pickledAccount() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.__wbg_get_basemigrationdata_pickledAccount(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* The pickle string holding the Olm Account, as returned by
* `olm_pickle_account` in libolm.
* @param {string} arg0
*/
set pickledAccount(arg0) {
const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.__wbg_set_basemigrationdata_pickledAccount(this.__wbg_ptr, ptr0, len0);
}
/**
* The backup version that is currently active.
* @returns {string | undefined}
*/
get backupVersion() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.__wbg_get_basemigrationdata_backupVersion(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
let v1;
if (r0 !== 0) {
v1 = getStringFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
}
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* The backup version that is currently active.
* @param {string | undefined} [arg0]
*/
set backupVersion(arg0) {
var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
var len0 = WASM_VECTOR_LEN;
wasm.__wbg_set_basemigrationdata_backupVersion(this.__wbg_ptr, ptr0, len0);
}
/**
* The backup recovery key, as a base64-encoded string.
* @returns {string | undefined}
*/
get backupRecoveryKey() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.__wbg_get_basemigrationdata_backupRecoveryKey(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
let v1;
if (r0 !== 0) {
v1 = getStringFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
}
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* The backup recovery key, as a base64-encoded string.
* @param {string | undefined} [arg0]
*/
set backupRecoveryKey(arg0) {
var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
var len0 = WASM_VECTOR_LEN;
wasm.__wbg_set_basemigrationdata_backupRecoveryKey(this.__wbg_ptr, ptr0, len0);
}
/**
* The private, base64-encoded, master cross-signing key.
* @returns {string | undefined}
*/
get privateCrossSigningMasterKey() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.__wbg_get_basemigrationdata_privateCrossSigningMasterKey(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
let v1;
if (r0 !== 0) {
v1 = getStringFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
}
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* The private, base64-encoded, master cross-signing key.
* @param {string | undefined} [arg0]
*/
set privateCrossSigningMasterKey(arg0) {
var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
var len0 = WASM_VECTOR_LEN;
wasm.__wbg_set_basemigrationdata_privateCrossSigningMasterKey(this.__wbg_ptr, ptr0, len0);
}
/**
* The private, base64-encoded, self-signing key.
* @returns {string | undefined}
*/
get privateCrossSigningSelfSigningKey() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.__wbg_get_basemigrationdata_privateCrossSigningSelfSigningKey(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
let v1;
if (r0 !== 0) {
v1 = getStringFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
}
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* The private, base64-encoded, self-signing key.
* @param {string | undefined} [arg0]
*/
set privateCrossSigningSelfSigningKey(arg0) {
var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
var len0 = WASM_VECTOR_LEN;
wasm.__wbg_set_basemigrationdata_privateCrossSigningSelfSigningKey(this.__wbg_ptr, ptr0, len0);
}
/**
* The private, base64-encoded, user-signing key.
* @returns {string | undefined}
*/
get privateCrossSigningUserSigningKey() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.__wbg_get_basemigrationdata_privateCrossSigningUserSigningKey(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
let v1;
if (r0 !== 0) {
v1 = getStringFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
}
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* The private, base64-encoded, user-signing key.
* @param {string | undefined} [arg0]
*/
set privateCrossSigningUserSigningKey(arg0) {
var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
var len0 = WASM_VECTOR_LEN;
wasm.__wbg_set_basemigrationdata_privateCrossSigningUserSigningKey(this.__wbg_ptr, ptr0, len0);
}
/**
* Create a new `BaseMigrationData` with default values.
*/
constructor() {
const ret = wasm.basemigrationdata_new();
this.__wbg_ptr = ret >>> 0;
BaseMigrationDataFinalization.register(this, this.__wbg_ptr, this);
return this;
}
}
module.exports.BaseMigrationData = BaseMigrationData;
const CancelInfoFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_cancelinfo_free(ptr >>> 0, 1));
/**
* Information about the cancellation of a verification request or
* verification flow.
*/
class CancelInfo {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(CancelInfo.prototype);
obj.__wbg_ptr = ptr;
CancelInfoFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
CancelInfoFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_cancelinfo_free(ptr, 0);
}
/**
* Get the human readable reason of the cancellation.
* @returns {string}
*/
reason() {
const ret = wasm.cancelinfo_reason(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Get the `code` (e.g. `m.user`) that was used to cancel the
* verification.
* @returns {string}
*/
cancelCode() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.cancelinfo_cancelCode(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* Was the verification cancelled by us?
* @returns {boolean}
*/
cancelledbyUs() {
const ret = wasm.cancelinfo_cancelledbyUs(this.__wbg_ptr);
return ret !== 0;
}
}
module.exports.CancelInfo = CancelInfo;
const CheckCodeFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_checkcode_free(ptr >>> 0, 1));
/**
* A check code that can be used to confirm that two [`EstablishedEcies`]
* objects share the same secret. This is supposed to be shared out-of-band to
* protect against active Man-in-the-middle (MITM) attacks.
*
* Since the initiator device can always tell whether a MITM attack is in
* progress after channel establishment, this code technically carries only a
* single bit of information, representing whether the initiator has determined
* that the channel is "secure" or "not secure".
*
* However, given this will need to be interactively confirmed by the user,
* there is risk that the user would confirm the dialogue without paying
* attention to its content. By expanding this single bit into a deterministic
* two-digit check code, the user is forced to pay more attention by having to
* enter it instead of just clicking through a dialogue.
*/
class CheckCode {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(CheckCode.prototype);
obj.__wbg_ptr = ptr;
CheckCodeFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
CheckCodeFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_checkcode_free(ptr, 0);
}
/**
* Convert the check code to an array of two bytes.
*
* The bytes can be converted to a more user-friendly representation. The
* [`CheckCode::to_digit`] converts the bytes to a two-digit number.
* @returns {Uint8Array}
*/
as_bytes() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.checkcode_as_bytes(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var v1 = getArrayU8FromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Convert the check code to two base-10 numbers.
*
* The number should be displayed with a leading 0 in case the first digit
* is a 0.
* @returns {number}
*/
to_digit() {
const ret = wasm.checkcode_to_digit(this.__wbg_ptr);
return ret;
}
}
module.exports.CheckCode = CheckCode;
const CollectStrategyFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_collectstrategy_free(ptr >>> 0, 1));
/**
* Strategy to collect the devices that should receive room keys for the
* current discussion.
*/
class CollectStrategy {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(CollectStrategy.prototype);
obj.__wbg_ptr = ptr;
CollectStrategyFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
CollectStrategyFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_collectstrategy_free(ptr, 0);
}
/**
* Tests for equality between two [`CollectStrategy`]s.
* @param {CollectStrategy} other
* @returns {boolean}
*/
eq(other) {
_assertClass(other, CollectStrategy);
const ret = wasm.collectstrategy_eq(this.__wbg_ptr, other.__wbg_ptr);
return ret !== 0;
}
/**
* Device based sharing strategy.
*
* If `only_allow_trusted_devices` is `true`, devices that are not trusted
* will be excluded from the conversation. A device is trusted if any of
* the following is true:
* - It was manually marked as trusted.
* - It was marked as verified via interactive verification.
* - It is signed by its owner identity, and this identity has been
* trusted via interactive verification.
* - It is the current own device of the user.
*
* If `error_on_verified_user` is `true`, and a verified user has an
* unsigned device, key sharing will fail with an error.
*
* If `error_on_verified_user` is `true`, and a verified user has replaced
* their identity, key sharing will fail with an error.
*
* Otherwise, keys are shared with unsigned devices as normal.
*
* Once the problematic devices are blacklisted or whitelisted the
* caller can retry to share a second time.
* @param {boolean} only_allow_trusted_devices
* @param {boolean} error_on_verified_user_problem
* @returns {CollectStrategy}
*/
static deviceBasedStrategy(only_allow_trusted_devices, error_on_verified_user_problem) {
const ret = wasm.collectstrategy_deviceBasedStrategy(only_allow_trusted_devices, error_on_verified_user_problem);
return CollectStrategy.__wrap(ret);
}
/**
* Share based on identity. Only distribute to devices signed by their
* owner. If a user has no published identity he will not receive
* any room keys.
* @returns {CollectStrategy}
*/
static identityBasedStrategy() {
const ret = wasm.collectstrategy_identityBasedStrategy();
return CollectStrategy.__wrap(ret);
}
}
module.exports.CollectStrategy = CollectStrategy;
const CrossSigningBootstrapRequestsFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_crosssigningbootstraprequests_free(ptr >>> 0, 1));
/**
* A set of requests to be executed when bootstrapping cross-signing using
* {@link OlmMachine.bootstrapCrossSigning}.
*/
class CrossSigningBootstrapRequests {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(CrossSigningBootstrapRequests.prototype);
obj.__wbg_ptr = ptr;
CrossSigningBootstrapRequestsFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
CrossSigningBootstrapRequestsFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_crosssigningbootstraprequests_free(ptr, 0);
}
/**
* An optional request to upload a device key.
*
* This will either be `undefined`, or an "outgoing request" as returned by
* {@link OlmMachine.outgoingRequests}.
*
* If it is defined, the request should be sent first, and the result sent
* back with {@link OlmMachine.markRequestAsSent}.
* @returns {any}
*/
get uploadKeysRequest() {
const ret = wasm.__wbg_get_crosssigningbootstraprequests_uploadKeysRequest(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Request to upload the cross-signing keys.
*
* Should be sent second.
* @returns {UploadSigningKeysRequest}
*/
get uploadSigningKeysRequest() {
const ret = wasm.__wbg_get_crosssigningbootstraprequests_uploadSigningKeysRequest(this.__wbg_ptr);
return UploadSigningKeysRequest.__wrap(ret);
}
/**
* Request to upload key signatures, including those for the cross-signing
* keys, and maybe some for the optional uploaded key too.
*
* Should be sent last.
* @returns {SignatureUploadRequest}
*/
get uploadSignaturesRequest() {
const ret = wasm.__wbg_get_crosssigningbootstraprequests_uploadSignaturesRequest(this.__wbg_ptr);
return SignatureUploadRequest.__wrap(ret);
}
}
module.exports.CrossSigningBootstrapRequests = CrossSigningBootstrapRequests;
const CrossSigningKeyExportFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_crosssigningkeyexport_free(ptr >>> 0, 1));
/**
* A struct containing private cross signing keys that can be backed
* up or uploaded to the secret store.
*/
class CrossSigningKeyExport {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(CrossSigningKeyExport.prototype);
obj.__wbg_ptr = ptr;
CrossSigningKeyExportFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
CrossSigningKeyExportFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_crosssigningkeyexport_free(ptr, 0);
}
/**
* The seed of the master key encoded as unpadded base64.
* @returns {string | undefined}
*/
get masterKey() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.crosssigningkeyexport_masterKey(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
let v1;
if (r0 !== 0) {
v1 = getStringFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
}
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* The seed of the self signing key encoded as unpadded base64.
* @returns {string | undefined}
*/
get self_signing_key() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.crosssigningkeyexport_self_signing_key(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
let v1;
if (r0 !== 0) {
v1 = getStringFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
}
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* The seed of the user signing key encoded as unpadded base64.
* @returns {string | undefined}
*/
get userSigningKey() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.crosssigningkeyexport_userSigningKey(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
let v1;
if (r0 !== 0) {
v1 = getStringFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
}
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
}
module.exports.CrossSigningKeyExport = CrossSigningKeyExport;
const CrossSigningStatusFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_crosssigningstatus_free(ptr >>> 0, 1));
/**
* Struct representing the state of our private cross signing keys,
* it shows which private cross signing keys we have locally stored.
*/
class CrossSigningStatus {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(CrossSigningStatus.prototype);
obj.__wbg_ptr = ptr;
CrossSigningStatusFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
CrossSigningStatusFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_crosssigningstatus_free(ptr, 0);
}
/**
* Do we have the master key?
* @returns {boolean}
*/
get hasMaster() {
const ret = wasm.crosssigningstatus_hasMaster(this.__wbg_ptr);
return ret !== 0;
}
/**
* Do we have the self signing key? This one is necessary to sign
* our own devices.
* @returns {boolean}
*/
get hasSelfSigning() {
const ret = wasm.crosssigningstatus_hasSelfSigning(this.__wbg_ptr);
return ret !== 0;
}
/**
* Do we have the user signing key? This one is necessary to sign
* other users.
* @returns {boolean}
*/
get hasUserSigning() {
const ret = wasm.crosssigningstatus_hasUserSigning(this.__wbg_ptr);
return ret !== 0;
}
}
module.exports.CrossSigningStatus = CrossSigningStatus;
const Curve25519PublicKeyFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_curve25519publickey_free(ptr >>> 0, 1));
/**
* A Curve25519 public key.
*/
class Curve25519PublicKey {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(Curve25519PublicKey.prototype);
obj.__wbg_ptr = ptr;
Curve25519PublicKeyFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
Curve25519PublicKeyFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_curve25519publickey_free(ptr, 0);
}
/**
* Create a new [`Curve25519PublicKey`] from a base64 encoded string.
* @param {string} key
*/
constructor(key) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.curve25519publickey_new(retptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
this.__wbg_ptr = r0 >>> 0;
Curve25519PublicKeyFinalization.register(this, this.__wbg_ptr, this);
return this;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* The number of bytes a Curve25519 public key has.
* @returns {number}
*/
get length() {
const ret = wasm.curve25519publickey_length(this.__wbg_ptr);
return ret >>> 0;
}
/**
* Serialize an Curve25519 public key to an unpadded base64
* representation.
* @returns {string}
*/
toBase64() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.curve25519publickey_toBase64(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
}
module.exports.Curve25519PublicKey = Curve25519PublicKey;
const DecryptedRoomEventFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_decryptedroomevent_free(ptr >>> 0, 1));
/**
* A decrypted room event.
*/
class DecryptedRoomEvent {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(DecryptedRoomEvent.prototype);
obj.__wbg_ptr = ptr;
DecryptedRoomEventFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
DecryptedRoomEventFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_decryptedroomevent_free(ptr, 0);
}
/**
* The JSON-encoded decrypted event.
* @returns {string}
*/
get event() {
const ret = wasm.__wbg_get_decryptedroomevent_event(this.__wbg_ptr);
return takeObject(ret);
}
/**
* The user ID of the event sender, note this is untrusted data
* unless the `verification_state` is as well trusted.
* @returns {UserId | undefined}
*/
get sender() {
const ret = wasm.decryptedroomevent_sender(this.__wbg_ptr);
return ret === 0 ? undefined : UserId.__wrap(ret);
}
/**
* The device ID of the device that sent us the event, note this
* is untrusted data unless `verification_state` is as well
* trusted.
* @returns {DeviceId | undefined}
*/
get senderDevice() {
const ret = wasm.decryptedroomevent_senderDevice(this.__wbg_ptr);
return ret === 0 ? undefined : DeviceId.__wrap(ret);
}
/**
* The Curve25519 key of the device that created the megolm
* decryption key originally.
* @returns {string | undefined}
*/
get senderCurve25519Key() {
const ret = wasm.decryptedroomevent_senderCurve25519Key(this.__wbg_ptr);
return takeObject(ret);
}
/**
* The signing Ed25519 key that have created the megolm key that
* was used to decrypt this session.
* @returns {string | undefined}
*/
get senderClaimedEd25519Key() {
const ret = wasm.decryptedroomevent_senderClaimedEd25519Key(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Returns an empty array
*
* Previously, this returned the chain of Curve25519 keys through which
* this session was forwarded, via `m.forwarded_room_key` events.
* However, that is not cryptographically reliable, and clients should not
* be using it.
*
* @returns {Array<any>}
*/
get forwardingCurve25519KeyChain() {
const ret = wasm.decryptedroomevent_forwardingCurve25519KeyChain(this.__wbg_ptr);
return takeObject(ret);
}
/**
* The verification state of the device that sent us the event.
* Note this is the state of the device at the time of
* decryption. It may change in the future if a device gets
* verified or deleted.
* @param {boolean} strict
* @returns {ShieldState | undefined}
*/
shieldState(strict) {
const ret = wasm.decryptedroomevent_shieldState(this.__wbg_ptr, strict);
return ret === 0 ? undefined : ShieldState.__wrap(ret);
}
}
module.exports.DecryptedRoomEvent = DecryptedRoomEvent;
const DecryptionSettingsFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_decryptionsettings_free(ptr >>> 0, 1));
/**
* Settings for decrypting messages
*/
class DecryptionSettings {
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
DecryptionSettingsFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_decryptionsettings_free(ptr, 0);
}
/**
* The trust level required to decrypt the event
* @returns {TrustRequirement}
*/
get sender_device_trust_requirement() {
const ret = wasm.__wbg_get_decryptionsettings_sender_device_trust_requirement(this.__wbg_ptr);
return ret;
}
/**
* The trust level required to decrypt the event
* @param {TrustRequirement} arg0
*/
set sender_device_trust_requirement(arg0) {
wasm.__wbg_set_decryptionsettings_sender_device_trust_requirement(this.__wbg_ptr, arg0);
}
/**
* Create a new `DecryptionSettings` with the given trust requirement.
* @param {TrustRequirement} sender_device_trust_requirement
*/
constructor(sender_device_trust_requirement) {
const ret = wasm.decryptionsettings_new(sender_device_trust_requirement);
this.__wbg_ptr = ret >>> 0;
DecryptionSettingsFinalization.register(this, this.__wbg_ptr, this);
return this;
}
}
module.exports.DecryptionSettings = DecryptionSettings;
const DehydratedDeviceFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_dehydrateddevice_free(ptr >>> 0, 1));
/**
* A dehydrated device that can be uploaded to the server
*/
class DehydratedDevice {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(DehydratedDevice.prototype);
obj.__wbg_ptr = ptr;
DehydratedDeviceFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
DehydratedDeviceFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_dehydrateddevice_free(ptr, 0);
}
/**
* Create the request to upload the dehydrated device
* @param {string} initial_device_display_name
* @param {Uint8Array} pickle_key
* @returns {Promise<PutDehydratedDeviceRequest>}
*/
keysForUpload(initial_device_display_name, pickle_key) {
const ret = wasm.dehydrateddevice_keysForUpload(this.__wbg_ptr, addHeapObject(initial_device_display_name), addHeapObject(pickle_key));
return takeObject(ret);
}
}
module.exports.DehydratedDevice = DehydratedDevice;
const DehydratedDevicesFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_dehydrateddevices_free(ptr >>> 0, 1));
/**
* Struct collecting methods to create and rehydrate dehydrated devices.
*/
class DehydratedDevices {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(DehydratedDevices.prototype);
obj.__wbg_ptr = ptr;
DehydratedDevicesFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
DehydratedDevicesFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_dehydrateddevices_free(ptr, 0);
}
/**
* Create a new [`DehydratedDevice`] which can be uploaded to the server.
* @returns {Promise<DehydratedDevice>}
*/
create() {
const ret = wasm.dehydrateddevices_create(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Rehydrate a dehydrated device.
* @param {Uint8Array} pickle_key
* @param {DeviceId} device_id
* @param {string} device_data
* @returns {Promise<RehydratedDevice>}
*/
rehydrate(pickle_key, device_id, device_data) {
_assertClass(device_id, DeviceId);
const ptr0 = passStringToWasm0(device_data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ret = wasm.dehydrateddevices_rehydrate(this.__wbg_ptr, addHeapObject(pickle_key), device_id.__wbg_ptr, ptr0, len0);
return takeObject(ret);
}
}
module.exports.DehydratedDevices = DehydratedDevices;
const DeviceFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_device_free(ptr >>> 0, 1));
/**
* A device represents a E2EE capable client of an user.
*/
class Device {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(Device.prototype);
obj.__wbg_ptr = ptr;
DeviceFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
DeviceFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_device_free(ptr, 0);
}
/**
* Request an interactive verification with this device.
*
* Returns a 2-element array `[VerificationRequest, ToDeviceRequest]`.
* @param {any[] | undefined} [methods]
* @returns {Array<any>}
*/
requestVerification(methods) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
var ptr0 = isLikeNone(methods) ? 0 : passArrayJsValueToWasm0(methods, wasm.__wbindgen_malloc);
var len0 = WASM_VECTOR_LEN;
wasm.device_requestVerification(retptr, this.__wbg_ptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Encrypt a to-device message to be sent to this device, using Olm
* encryption.
*
* Prior to calling this method you must ensure that an Olm session is
* available for the target device. This can be done by calling
* {@link OlmMachine.getMissingSessions}.
*
* The caller is responsible for sending the encrypted
* event to the target device. If multiple messages are
* encrypted for the same device using this method they should be sent in
* the same order as they are encrypted.
*
* # Returns
*
* Returns a promise for a JSON string containing the `content` of an
* encrypted event, which be used to create the payload for a
* `/sendToDevice` API.
* @param {string} event_type
* @param {any} content
* @returns {Promise<string>}
*/
encryptToDeviceEvent(event_type, content) {
const ptr0 = passStringToWasm0(event_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ret = wasm.device_encryptToDeviceEvent(this.__wbg_ptr, ptr0, len0, addHeapObject(content));
return takeObject(ret);
}
/**
* Is this device considered to be verified.
*
* This method returns true if either the `is_locally_trusted`
* method returns `true` or if the `is_cross_signing_trusted`
* method returns `true`.
* @returns {boolean}
*/
isVerified() {
const ret = wasm.device_isVerified(this.__wbg_ptr);
return ret !== 0;
}
/**
* Is this device considered to be verified using cross signing.
* @returns {boolean}
*/
isCrossSigningTrusted() {
const ret = wasm.device_isCrossSigningTrusted(this.__wbg_ptr);
return ret !== 0;
}
/**
* Is this device cross-signed by its owner?
* @returns {boolean}
*/
isCrossSignedByOwner() {
const ret = wasm.device_isCrossSignedByOwner(this.__wbg_ptr);
return ret !== 0;
}
/**
* Set the local trust state of the device to the given state.
*
* This won’t affect any cross signing trust state, this only
* sets a flag marking to have the given trust state.
*
* `trust_state` represents the new trust state that should be
* set for the device.
* @param {LocalTrust} local_state
* @returns {Promise<any>}
*/
setLocalTrust(local_state) {
const ret = wasm.device_setLocalTrust(this.__wbg_ptr, local_state);
return takeObject(ret);
}
/**
* The user ID of the device owner.
* @returns {UserId}
*/
get userId() {
const ret = wasm.device_userId(this.__wbg_ptr);
return UserId.__wrap(ret);
}
/**
* The unique ID of the device.
* @returns {DeviceId}
*/
get deviceId() {
const ret = wasm.device_deviceId(this.__wbg_ptr);
return DeviceId.__wrap(ret);
}
/**
* Get the human readable name of the device.
* @returns {string | undefined}
*/
get displayName() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.device_displayName(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
let v1;
if (r0 !== 0) {
v1 = getStringFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
}
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Get the key of the given key algorithm belonging to this device.
* @param {DeviceKeyAlgorithmName} algorithm
* @returns {DeviceKey | undefined}
*/
getKey(algorithm) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.device_getKey(retptr, this.__wbg_ptr, algorithm);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return r0 === 0 ? undefined : DeviceKey.__wrap(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Get the Curve25519 key of the given device.
* @returns {Curve25519PublicKey | undefined}
*/
get curve25519Key() {
const ret = wasm.device_curve25519Key(this.__wbg_ptr);
return ret === 0 ? undefined : Curve25519PublicKey.__wrap(ret);
}
/**
* Get the Ed25519 key of the given device.
* @returns {Ed25519PublicKey | undefined}
*/
get ed25519Key() {
const ret = wasm.device_ed25519Key(this.__wbg_ptr);
return ret === 0 ? undefined : Ed25519PublicKey.__wrap(ret);
}
/**
* Get a map containing all the device keys.
* @returns {Map<any, any>}
*/
get keys() {
const ret = wasm.device_keys(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Get the list of algorithms this device supports.
*
* Returns `Array<EncryptionAlgorithm>`.
* @returns {Array<any>}
*/
get algorithms() {
const ret = wasm.device_algorithms(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Get a map containing all the device signatures.
* @returns {Signatures}
*/
get signatures() {
const ret = wasm.device_signatures(this.__wbg_ptr);
return Signatures.__wrap(ret);
}
/**
* Get the trust state of the device.
* @returns {LocalTrust}
*/
get localTrustState() {
const ret = wasm.device_localTrustState(this.__wbg_ptr);
return ret;
}
/**
* Is the device locally marked as trusted?
* @returns {boolean}
*/
isLocallyTrusted() {
const ret = wasm.device_isLocallyTrusted(this.__wbg_ptr);
return ret !== 0;
}
/**
* Is the device locally marked as blacklisted?
*
* Blacklisted devices won’t receive any group sessions.
* @returns {boolean}
*/
isBlacklisted() {
const ret = wasm.device_isBlacklisted(this.__wbg_ptr);
return ret !== 0;
}
/**
* Is the device deleted?
* @returns {boolean}
*/
isDeleted() {
const ret = wasm.device_isDeleted(this.__wbg_ptr);
return ret !== 0;
}
/**
* Timestamp representing the first time this device has been seen (in
* milliseconds).
* @returns {bigint}
*/
firstTimeSeen() {
const ret = wasm.device_firstTimeSeen(this.__wbg_ptr);
return BigInt.asUintN(64, ret);
}
/**
* Mark this device as verified.
* Works only if the device is owned by the current user.
*
* Returns a signature upload request that needs to be sent out.
* @returns {Promise<any>}
*/
verify() {
const ret = wasm.device_verify(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Whether or not the device is a dehydrated device.
* @returns {boolean}
*/
get isDehydrated() {
const ret = wasm.device_isDehydrated(this.__wbg_ptr);
return ret !== 0;
}
}
module.exports.Device = Device;
const DeviceIdFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_deviceid_free(ptr >>> 0, 1));
/**
* A Matrix key ID.
*
* Device identifiers in Matrix are completely opaque character
* sequences. This type is provided simply for its semantic value.
*/
class DeviceId {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(DeviceId.prototype);
obj.__wbg_ptr = ptr;
DeviceIdFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
DeviceIdFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_deviceid_free(ptr, 0);
}
/**
* Create a new `DeviceId`.
* @param {string} id
*/
constructor(id) {
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ret = wasm.deviceid_new(ptr0, len0);
this.__wbg_ptr = ret >>> 0;
DeviceIdFinalization.register(this, this.__wbg_ptr, this);
return this;
}
/**
* Return the device ID as a string.
* @returns {string}
*/
toString() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.deviceid_toString(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
}
module.exports.DeviceId = DeviceId;
const DeviceKeyFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_devicekey_free(ptr >>> 0, 1));
/**
* An enum over the different key types a device can have.
*
* Currently devices have a curve25519 and ed25519 keypair. The keys
* transport format is a base64 encoded string, any unknown key type
* will be left as such a string.
*/
class DeviceKey {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(DeviceKey.prototype);
obj.__wbg_ptr = ptr;
DeviceKeyFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
DeviceKeyFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_devicekey_free(ptr, 0);
}
/**
* Get the name of the device key.
* @returns {DeviceKeyName}
*/
get name() {
const ret = wasm.devicekey_name(this.__wbg_ptr);
return ret;
}
/**
* Get the value associated to the `Curve25519` device key name.
* @returns {Curve25519PublicKey | undefined}
*/
get curve25519() {
const ret = wasm.devicekey_curve25519(this.__wbg_ptr);
return ret === 0 ? undefined : Curve25519PublicKey.__wrap(ret);
}
/**
* Get the value associated to the `Ed25519` device key name.
* @returns {Ed25519PublicKey | undefined}
*/
get ed25519() {
const ret = wasm.devicekey_ed25519(this.__wbg_ptr);
return ret === 0 ? undefined : Ed25519PublicKey.__wrap(ret);
}
/**
* Get the value associated to the `Unknown` device key name.
* @returns {string | undefined}
*/
get unknown() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.devicekey_unknown(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
let v1;
if (r0 !== 0) {
v1 = getStringFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
}
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Convert the `DeviceKey` into a base64 encoded string.
* @returns {string}
*/
toBase64() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.devicekey_toBase64(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
}
module.exports.DeviceKey = DeviceKey;
const DeviceKeyAlgorithmFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_devicekeyalgorithm_free(ptr >>> 0, 1));
/**
* The basic key algorithms in the specification.
*/
class DeviceKeyAlgorithm {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(DeviceKeyAlgorithm.prototype);
obj.__wbg_ptr = ptr;
DeviceKeyAlgorithmFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
DeviceKeyAlgorithmFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_devicekeyalgorithm_free(ptr, 0);
}
/**
* Read the device key algorithm's name. If the name is
* `Unknown`, one may be interested by the `to_string` method to
* read the original name.
* @returns {DeviceKeyAlgorithmName}
*/
get name() {
const ret = wasm.devicekeyalgorithm_name(this.__wbg_ptr);
return ret;
}
/**
* Return the device key algorithm as a string.
* @returns {string}
*/
toString() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.devicekeyalgorithm_toString(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
}
module.exports.DeviceKeyAlgorithm = DeviceKeyAlgorithm;
const DeviceKeyIdFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_devicekeyid_free(ptr >>> 0, 1));
/**
* A Matrix device key ID.
*
* A key algorithm and a device ID, combined with a ‘:’.
*/
class DeviceKeyId {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(DeviceKeyId.prototype);
obj.__wbg_ptr = ptr;
DeviceKeyIdFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
DeviceKeyIdFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_devicekeyid_free(ptr, 0);
}
/**
* Parse/validate and create a new `DeviceKeyId`.
* @param {string} id
*/
constructor(id) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.devicekeyid_new(retptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
this.__wbg_ptr = r0 >>> 0;
DeviceKeyIdFinalization.register(this, this.__wbg_ptr, this);
return this;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Returns key algorithm of the device key ID.
* @returns {DeviceKeyAlgorithm}
*/
get algorithm() {
const ret = wasm.devicekeyid_algorithm(this.__wbg_ptr);
return DeviceKeyAlgorithm.__wrap(ret);
}
/**
* Returns device ID of the device key ID.
* @returns {DeviceId}
*/
get deviceId() {
const ret = wasm.devicekeyid_deviceId(this.__wbg_ptr);
return DeviceId.__wrap(ret);
}
/**
* Return the device key ID as a string.
* @returns {string}
*/
toString() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.devicekeyid_toString(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
}
module.exports.DeviceKeyId = DeviceKeyId;
const DeviceListsFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_devicelists_free(ptr >>> 0, 1));
/**
* Information on E2E device updates.
*/
class DeviceLists {
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
DeviceListsFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_devicelists_free(ptr, 0);
}
/**
* Create an empty `DeviceLists`.
*
* `changed` and `left` must be an array of `UserId`.
*
* Items inside `changed` and `left` will be invalidated by this method. Be
* careful not to use the `UserId`s after this method has been called.
* @param {(UserId)[] | undefined} [changed]
* @param {(UserId)[] | undefined} [left]
*/
constructor(changed, left) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
var ptr0 = isLikeNone(changed) ? 0 : passArrayJsValueToWasm0(changed, wasm.__wbindgen_malloc);
var len0 = WASM_VECTOR_LEN;
var ptr1 = isLikeNone(left) ? 0 : passArrayJsValueToWasm0(left, wasm.__wbindgen_malloc);
var len1 = WASM_VECTOR_LEN;
wasm.devicelists_new(retptr, ptr0, len0, ptr1, len1);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
this.__wbg_ptr = r0 >>> 0;
DeviceListsFinalization.register(this, this.__wbg_ptr, this);
return this;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Returns true if there are no device list updates.
* @returns {boolean}
*/
isEmpty() {
const ret = wasm.devicelists_isEmpty(this.__wbg_ptr);
return ret !== 0;
}
/**
* List of users who have updated their device identity keys or
* who now share an encrypted room with the client since the
* previous sync
* @returns {(UserId)[]}
*/
get changed() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.devicelists_changed(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 4, 4);
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* List of users who no longer share encrypted rooms since the
* previous sync response.
* @returns {(UserId)[]}
*/
get left() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.devicelists_left(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 4, 4);
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
}
module.exports.DeviceLists = DeviceLists;
const EciesFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_ecies_free(ptr >>> 0, 1));
/**
* An unestablished ECIES session.
*/
class Ecies {
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
EciesFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_ecies_free(ptr, 0);
}
/**
* Create a new, random, unestablished ECIES session.
*
* This method will use the
* info for domain separation when creating the session.
*/
constructor() {
const ret = wasm.ecies_new();
this.__wbg_ptr = ret >>> 0;
EciesFinalization.register(this, this.__wbg_ptr, this);
return this;
}
/**
* Get our [`Curve25519PublicKey`].
*
* This public key needs to be sent to the other side to be able to
* establish an ECIES channel.
* @returns {Curve25519PublicKey}
*/
public_key() {
const ret = wasm.ecies_public_key(this.__wbg_ptr);
return Curve25519PublicKey.__wrap(ret);
}
/**
* Create a [`EstablishedEcies`] from an initial message encrypted by the
* other side.
* @param {string} initial_message
* @returns {InboundCreationResult}
*/
establish_inbound_channel(initial_message) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(initial_message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.ecies_establish_inbound_channel(retptr, this.__wbg_ptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return InboundCreationResult.__wrap(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Create an [`EstablishedEcies`] session using the other side's Curve25519
* public key and an initial plaintext.
*
* After the channel has been established, we can encrypt messages to send
* to the other side. The other side uses the initial message to
* establishes the same channel on its side.
* @param {Curve25519PublicKey} public_key
* @param {string} initial_message
* @returns {OutboundCreationResult}
*/
establish_outbound_channel(public_key, initial_message) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
_assertClass(public_key, Curve25519PublicKey);
const ptr0 = passStringToWasm0(initial_message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.ecies_establish_outbound_channel(retptr, this.__wbg_ptr, public_key.__wbg_ptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return OutboundCreationResult.__wrap(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
}
module.exports.Ecies = Ecies;
const Ed25519PublicKeyFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_ed25519publickey_free(ptr >>> 0, 1));
/**
* An Ed25519 public key, used to verify digital signatures.
*/
class Ed25519PublicKey {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(Ed25519PublicKey.prototype);
obj.__wbg_ptr = ptr;
Ed25519PublicKeyFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
Ed25519PublicKeyFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_ed25519publickey_free(ptr, 0);
}
/**
* The number of bytes an Ed25519 public key has.
* @returns {number}
*/
get length() {
const ret = wasm.ed25519publickey_length(this.__wbg_ptr);
return ret >>> 0;
}
/**
* Serialize an Ed25519 public key to an unpadded base64
* representation.
* @returns {string}
*/
toBase64() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ed25519publickey_toBase64(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
}
module.exports.Ed25519PublicKey = Ed25519PublicKey;
const Ed25519SignatureFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_ed25519signature_free(ptr >>> 0, 1));
/**
* An Ed25519 digital signature, can be used to verify the
* authenticity of a message.
*/
class Ed25519Signature {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(Ed25519Signature.prototype);
obj.__wbg_ptr = ptr;
Ed25519SignatureFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
Ed25519SignatureFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_ed25519signature_free(ptr, 0);
}
/**
* Try to create an Ed25519 signature from an unpadded base64
* representation.
* @param {string} signature
*/
constructor(signature) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(signature, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.ed25519signature_new(retptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
this.__wbg_ptr = r0 >>> 0;
Ed25519SignatureFinalization.register(this, this.__wbg_ptr, this);
return this;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Serialize a Ed25519 signature to an unpadded base64
* representation.
* @returns {string}
*/
toBase64() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ed25519signature_toBase64(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
}
module.exports.Ed25519Signature = Ed25519Signature;
const EmojiFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_emoji_free(ptr >>> 0, 1));
/**
* An emoji that is used for interactive verification using a short
* auth string.
*
* This will contain a single emoji and description from the list of
* emojis from [the specification].
*
*/
class Emoji {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(Emoji.prototype);
obj.__wbg_ptr = ptr;
EmojiFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
EmojiFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_emoji_free(ptr, 0);
}
/**
* The emoji symbol that represents a part of the short auth
* string, for example: 🐶
* @returns {string}
*/
get symbol() {
const ret = wasm.emoji_symbol(this.__wbg_ptr);
return takeObject(ret);
}
/**
* The description of the emoji, for example ‘Dog’.
* @returns {string}
*/
get description() {
const ret = wasm.emoji_description(this.__wbg_ptr);
return takeObject(ret);
}
}
module.exports.Emoji = Emoji;
const EncryptedAttachmentFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_encryptedattachment_free(ptr >>> 0, 1));
/**
* An encrypted attachment, usually created from `Attachment.encrypt`.
*/
class EncryptedAttachment {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(EncryptedAttachment.prototype);
obj.__wbg_ptr = ptr;
EncryptedAttachmentFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
EncryptedAttachmentFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_encryptedattachment_free(ptr, 0);
}
/**
* Create a new encrypted attachment manually.
*
* It needs encrypted data, stored in an `Uint8Array`, and a
* [media encryption
* information](https://docs.rs/matrix-sdk-crypto/latest/matrix_sdk_crypto/struct.MediaEncryptionInfo.html),
* as a JSON-encoded string.
*
* The media encryption information aren't stored as a string:
* they are parsed, validated and fully deserialized.
*
* See [the specification to learn
* @param {Uint8Array} encrypted_data
* @param {string} media_encryption_info
*/
constructor(encrypted_data, media_encryption_info) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passArray8ToWasm0(encrypted_data, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
const ptr1 = passStringToWasm0(media_encryption_info, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
wasm.encryptedattachment_new(retptr, ptr0, len0, ptr1, len1);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
this.__wbg_ptr = r0 >>> 0;
EncryptedAttachmentFinalization.register(this, this.__wbg_ptr, this);
return this;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* The actual encrypted data.
*
* **Warning**: It returns a **copy** of the entire encrypted
* data; be nice with your memory.
* @returns {Uint8Array}
*/
get encryptedData() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.encryptedattachment_encryptedData(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var v1 = getArrayU8FromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Return the media encryption info as a JSON-encoded string. The
* structure is fully valid.
*
* If the media encryption info have been consumed already, it
* will return `null`.
* @returns {string | undefined}
*/
get mediaEncryptionInfo() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.encryptedattachment_mediaEncryptionInfo(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
let v1;
if (r0 !== 0) {
v1 = getStringFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
}
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Check whether the media encryption info has been consumed by
* `Attachment.decrypt` already.
* @returns {boolean}
*/
get hasMediaEncryptionInfoBeenConsumed() {
const ret = wasm.encryptedattachment_hasMediaEncryptionInfoBeenConsumed(this.__wbg_ptr);
return ret !== 0;
}
}
module.exports.EncryptedAttachment = EncryptedAttachment;
const EncryptionInfoFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_encryptioninfo_free(ptr >>> 0, 1));
/**
* Struct containing information on how an event was decrypted.
*/
class EncryptionInfo {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(EncryptionInfo.prototype);
obj.__wbg_ptr = ptr;
EncryptionInfoFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
EncryptionInfoFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_encryptioninfo_free(ptr, 0);
}
/**
* The user ID of the event sender. Note this is untrusted data
* unless `verification_state` is also trusted.
* @returns {UserId}
*/
get sender() {
const ret = wasm.encryptioninfo_sender(this.__wbg_ptr);
return UserId.__wrap(ret);
}
/**
* The device ID of the device that sent us the event. Note this
* is untrusted data unless `verification_state` is also
* trusted.
* @returns {DeviceId | undefined}
*/
get senderDevice() {
const ret = wasm.encryptioninfo_senderDevice(this.__wbg_ptr);
return ret === 0 ? undefined : DeviceId.__wrap(ret);
}
/**
* The Curve25519 key of the device that created the megolm
* decryption key originally.
* @returns {string | undefined}
*/
get senderCurve25519Key() {
const ret = wasm.encryptioninfo_senderCurve25519Key(this.__wbg_ptr);
return takeObject(ret);
}
/**
* The signing Ed25519 key that created the megolm key that
* was used to decrypt this session.
* @returns {string | undefined}
*/
get senderClaimedEd25519Key() {
const ret = wasm.encryptioninfo_senderClaimedEd25519Key(this.__wbg_ptr);
return takeObject(ret);
}
/**
* The verification state of the device that sent us the event.
* Note this is the state of the device at the time of
* decryption. It may change in the future if a device gets
* verified or deleted.
*
* # Arguments
*
* * `strict` - whether to enable "strict mode" verification. In non-strict
* mode, unverified users are given no shield, and keys that have been
* forwarded or restored from an insecure backup are given a grey shield
* (both get a red shield in strict mode).
* @param {boolean} strict
* @returns {ShieldState}
*/
shieldState(strict) {
const ret = wasm.encryptioninfo_shieldState(this.__wbg_ptr, strict);
return ShieldState.__wrap(ret);
}
}
module.exports.EncryptionInfo = EncryptionInfo;
const EncryptionSettingsFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_encryptionsettings_free(ptr >>> 0, 1));
/**
* Settings for an encrypted room.
*
* This determines the algorithm and rotation periods of a group
* session.
*/
class EncryptionSettings {
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
EncryptionSettingsFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_encryptionsettings_free(ptr, 0);
}
/**
* The encryption algorithm that should be used in the room.
* @returns {EncryptionAlgorithm}
*/
get algorithm() {
const ret = wasm.__wbg_get_encryptionsettings_algorithm(this.__wbg_ptr);
return ret;
}
/**
* The encryption algorithm that should be used in the room.
* @param {EncryptionAlgorithm} arg0
*/
set algorithm(arg0) {
wasm.__wbg_set_encryptionsettings_algorithm(this.__wbg_ptr, arg0);
}
/**
* How long the session should be used before changing it,
* expressed in microseconds.
* @returns {bigint}
*/
get rotationPeriod() {
const ret = wasm.__wbg_get_encryptionsettings_rotationPeriod(this.__wbg_ptr);
return BigInt.asUintN(64, ret);
}
/**
* How long the session should be used before changing it,
* expressed in microseconds.
* @param {bigint} arg0
*/
set rotationPeriod(arg0) {
wasm.__wbg_set_encryptionsettings_rotationPeriod(this.__wbg_ptr, arg0);
}
/**
* How many messages should be sent before changing the session.
* @returns {bigint}
*/
get rotationPeriodMessages() {
const ret = wasm.__wbg_get_encryptionsettings_rotationPeriodMessages(this.__wbg_ptr);
return BigInt.asUintN(64, ret);
}
/**
* How many messages should be sent before changing the session.
* @param {bigint} arg0
*/
set rotationPeriodMessages(arg0) {
wasm.__wbg_set_encryptionsettings_rotationPeriodMessages(this.__wbg_ptr, arg0);
}
/**
* The history visibility of the room when the session was
* created.
* @returns {HistoryVisibility}
*/
get historyVisibility() {
const ret = wasm.__wbg_get_encryptionsettings_historyVisibility(this.__wbg_ptr);
return ret;
}
/**
* The history visibility of the room when the session was
* created.
* @param {HistoryVisibility} arg0
*/
set historyVisibility(arg0) {
wasm.__wbg_set_encryptionsettings_historyVisibility(this.__wbg_ptr, arg0);
}
/**
* Should untrusted devices receive the room key, or should they be
* excluded from the conversation.
* @returns {CollectStrategy}
*/
get sharingStrategy() {
const ret = wasm.__wbg_get_encryptionsettings_sharingStrategy(this.__wbg_ptr);
return CollectStrategy.__wrap(ret);
}
/**
* Should untrusted devices receive the room key, or should they be
* excluded from the conversation.
* @param {CollectStrategy} arg0
*/
set sharingStrategy(arg0) {
_assertClass(arg0, CollectStrategy);
var ptr0 = arg0.__destroy_into_raw();
wasm.__wbg_set_encryptionsettings_sharingStrategy(this.__wbg_ptr, ptr0);
}
/**
* Create a new `EncryptionSettings` with default values.
*/
constructor() {
const ret = wasm.encryptionsettings_new();
this.__wbg_ptr = ret >>> 0;
EncryptionSettingsFinalization.register(this, this.__wbg_ptr, this);
return this;
}
}
module.exports.EncryptionSettings = EncryptionSettings;
const EstablishedEciesFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_establishedecies_free(ptr >>> 0, 1));
/**
* An established ECIES session.
*
* This session can be used to encrypt and decrypt messages between the two
* sides of the channel.
*/
class EstablishedEcies {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(EstablishedEcies.prototype);
obj.__wbg_ptr = ptr;
EstablishedEciesFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
EstablishedEciesFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_establishedecies_free(ptr, 0);
}
/**
* Get our [`Curve25519PublicKey`].
*
* This public key needs to be sent to the other side so that it can
* complete the ECIES channel establishment.
* @returns {Curve25519PublicKey}
*/
public_key() {
const ret = wasm.establishedecies_public_key(this.__wbg_ptr);
return Curve25519PublicKey.__wrap(ret);
}
/**
* Encrypt the given plaintext using this [`EstablishedEcies`] session.
* @param {string} message
* @returns {string}
*/
encrypt(message) {
let deferred2_0;
let deferred2_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.establishedecies_encrypt(retptr, this.__wbg_ptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred2_0 = r0;
deferred2_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
}
}
/**
* Decrypt the given message using this [`EstablishedEcies`] session.
* @param {string} message
* @returns {string}
*/
decrypt(message) {
let deferred3_0;
let deferred3_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.establishedecies_decrypt(retptr, this.__wbg_ptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
var ptr2 = r0;
var len2 = r1;
if (r3) {
ptr2 = 0; len2 = 0;
throw takeObject(r2);
}
deferred3_0 = ptr2;
deferred3_1 = len2;
return getStringFromWasm0(ptr2, len2);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
}
}
/**
* Get the [`CheckCode`] which uniquely identifies this
* [`EstablishedEcies`] session.
*
* This check code can be used to verify and confirm that both sides of the
* session are indeed using the same shared secret.
* @returns {CheckCode}
*/
check_code() {
const ret = wasm.establishedecies_check_code(this.__wbg_ptr);
return CheckCode.__wrap(ret);
}
}
module.exports.EstablishedEcies = EstablishedEcies;
const EventIdFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_eventid_free(ptr >>> 0, 1));
/**
* A Matrix [event ID].
*
* An `EventId` is generated randomly or converted from a string
* slice, and can be converted back into a string as needed.
*
*/
class EventId {
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
EventIdFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_eventid_free(ptr, 0);
}
/**
* Parse/validate and create a new `EventId`.
* @param {string} id
*/
constructor(id) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.eventid_new(retptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
this.__wbg_ptr = r0 >>> 0;
EventIdFinalization.register(this, this.__wbg_ptr, this);
return this;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Returns the event's localpart.
* @returns {string}
*/
get localpart() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.eventid_localpart(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* Returns the server name of the event ID.
* @returns {ServerName | undefined}
*/
get serverName() {
const ret = wasm.eventid_serverName(this.__wbg_ptr);
return ret === 0 ? undefined : ServerName.__wrap(ret);
}
/**
* Return the event ID as a string.
* @returns {string}
*/
toString() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.eventid_toString(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
}
module.exports.EventId = EventId;
const IdentityKeysFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_identitykeys_free(ptr >>> 0, 1));
/**
* Struct holding the two public identity keys of an account.
*/
class IdentityKeys {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(IdentityKeys.prototype);
obj.__wbg_ptr = ptr;
IdentityKeysFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
IdentityKeysFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_identitykeys_free(ptr, 0);
}
/**
* The Ed25519 public key, used for signing.
* @returns {Ed25519PublicKey}
*/
get ed25519() {
const ret = wasm.__wbg_get_identitykeys_ed25519(this.__wbg_ptr);
return Ed25519PublicKey.__wrap(ret);
}
/**
* The Ed25519 public key, used for signing.
* @param {Ed25519PublicKey} arg0
*/
set ed25519(arg0) {
_assertClass(arg0, Ed25519PublicKey);
var ptr0 = arg0.__destroy_into_raw();
wasm.__wbg_set_identitykeys_ed25519(this.__wbg_ptr, ptr0);
}
/**
* The Curve25519 public key, used for establish shared secrets.
* @returns {Curve25519PublicKey}
*/
get curve25519() {
const ret = wasm.__wbg_get_identitykeys_curve25519(this.__wbg_ptr);
return Curve25519PublicKey.__wrap(ret);
}
/**
* The Curve25519 public key, used for establish shared secrets.
* @param {Curve25519PublicKey} arg0
*/
set curve25519(arg0) {
_assertClass(arg0, Curve25519PublicKey);
var ptr0 = arg0.__destroy_into_raw();
wasm.__wbg_set_identitykeys_curve25519(this.__wbg_ptr, ptr0);
}
}
module.exports.IdentityKeys = IdentityKeys;
const InboundCreationResultFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_inboundcreationresult_free(ptr >>> 0, 1));
/**
* The result of an inbound ECIES channel establishment.
*/
class InboundCreationResult {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(InboundCreationResult.prototype);
obj.__wbg_ptr = ptr;
InboundCreationResultFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
InboundCreationResultFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_inboundcreationresult_free(ptr, 0);
}
/**
* The established ECIES channel.
* @returns {EstablishedEcies}
*/
get channel() {
const ret = wasm.__wbg_get_inboundcreationresult_channel(this.__wbg_ptr);
return EstablishedEcies.__wrap(ret);
}
/**
* The established ECIES channel.
* @param {EstablishedEcies} arg0
*/
set channel(arg0) {
_assertClass(arg0, EstablishedEcies);
var ptr0 = arg0.__destroy_into_raw();
wasm.__wbg_set_inboundcreationresult_channel(this.__wbg_ptr, ptr0);
}
/**
* The plaintext of the initial message.
* @returns {string}
*/
get message() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.__wbg_get_backupsecretsbundle_key(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* The plaintext of the initial message.
* @param {string} arg0
*/
set message(arg0) {
const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.__wbg_set_backupsecretsbundle_key(this.__wbg_ptr, ptr0, len0);
}
}
module.exports.InboundCreationResult = InboundCreationResult;
const InboundGroupSessionFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_inboundgroupsession_free(ptr >>> 0, 1));
/**
* Inbound group session.
*
* Inbound group sessions are used to exchange room messages between a group of
* participants. Inbound group sessions are used to decrypt the room messages.
*/
class InboundGroupSession {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(InboundGroupSession.prototype);
obj.__wbg_ptr = ptr;
InboundGroupSessionFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
InboundGroupSessionFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_inboundgroupsession_free(ptr, 0);
}
/**
* The room where this session is used in.
* @returns {RoomId}
*/
get roomId() {
const ret = wasm.inboundgroupsession_roomId(this.__wbg_ptr);
return RoomId.__wrap(ret);
}
/**
* The Curve25519 key of the sender of this session, as a
* [Curve25519PublicKey].
* @returns {Curve25519PublicKey}
*/
get senderKey() {
const ret = wasm.inboundgroupsession_senderKey(this.__wbg_ptr);
return Curve25519PublicKey.__wrap(ret);
}
/**
* Returns the unique identifier for this session.
* @returns {string}
*/
get sessionId() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.inboundgroupsession_sessionId(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* Has the session been imported from a file or server-side backup? As
* opposed to being directly received as an `m.room_key` event.
* @returns {boolean}
*/
hasBeenImported() {
const ret = wasm.inboundgroupsession_hasBeenImported(this.__wbg_ptr);
return ret !== 0;
}
}
module.exports.InboundGroupSession = InboundGroupSession;
const KeysBackupRequestFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_keysbackuprequest_free(ptr >>> 0, 1));
/**
* A request that will back up a batch of room keys to the server
* ([specification]).
*
* [specification]: https://spec.matrix.org/unstable/client-server-api/#put_matrixclientv3room_keyskeys
*/
class KeysBackupRequest {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(KeysBackupRequest.prototype);
obj.__wbg_ptr = ptr;
KeysBackupRequestFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
KeysBackupRequestFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_keysbackuprequest_free(ptr, 0);
}
/**
* The request ID.
* @returns {string}
*/
get id() {
const ret = wasm.__wbg_get_keysbackuprequest_id(this.__wbg_ptr);
return takeObject(ret);
}
/**
* A JSON-encoded string containing the rest of the payload: `rooms`.
*
* It represents the body of the HTTP request.
* @returns {string}
*/
get body() {
const ret = wasm.__wbg_get_keysbackuprequest_body(this.__wbg_ptr);
return takeObject(ret);
}
/**
* The backup version that these room keys should be part of.
* @returns {string}
*/
get version() {
const ret = wasm.__wbg_get_keysbackuprequest_version(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Create a new `KeysBackupRequest`.
* @param {string} id
* @param {string} body
* @param {string} version
*/
constructor(id, body, version) {
const ret = wasm.keysbackuprequest_new(addHeapObject(id), addHeapObject(body), addHeapObject(version));
this.__wbg_ptr = ret >>> 0;
KeysBackupRequestFinalization.register(this, this.__wbg_ptr, this);
return this;
}
/**
* Get its request type.
* @returns {RequestType}
*/
get type() {
const ret = wasm.keysbackuprequest_type(this.__wbg_ptr);
return ret;
}
}
module.exports.KeysBackupRequest = KeysBackupRequest;
const KeysClaimRequestFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_keysclaimrequest_free(ptr >>> 0, 1));
/**
* Data for a request to the `/keys/claim` API endpoint
* ([specification]).
*
* Claims one-time keys that can be used to establish 1-to-1 E2EE
* sessions.
*
*/
class KeysClaimRequest {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(KeysClaimRequest.prototype);
obj.__wbg_ptr = ptr;
KeysClaimRequestFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
KeysClaimRequestFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_keysclaimrequest_free(ptr, 0);
}
/**
* The request ID.
* @returns {string}
*/
get id() {
const ret = wasm.__wbg_get_keysclaimrequest_id(this.__wbg_ptr);
return takeObject(ret);
}
/**
* A JSON-encoded string containing the rest of the payload: `timeout`,
* `one_time_keys`.
*
* It represents the body of the HTTP request.
* @returns {string}
*/
get body() {
const ret = wasm.__wbg_get_keysclaimrequest_body(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Create a new `KeysClaimRequest`.
* @param {string} id
* @param {string} body
*/
constructor(id, body) {
const ret = wasm.keysclaimrequest_new(addHeapObject(id), addHeapObject(body));
this.__wbg_ptr = ret >>> 0;
KeysClaimRequestFinalization.register(this, this.__wbg_ptr, this);
return this;
}
/**
* Get its request type.
* @returns {RequestType}
*/
get type() {
const ret = wasm.keysclaimrequest_type(this.__wbg_ptr);
return ret;
}
}
module.exports.KeysClaimRequest = KeysClaimRequest;
const KeysQueryRequestFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_keysqueryrequest_free(ptr >>> 0, 1));
/**
* Data for a request to the `/keys/query` API endpoint
* ([specification]).
*
* Returns the current devices and identity keys for the given users.
*
*/
class KeysQueryRequest {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(KeysQueryRequest.prototype);
obj.__wbg_ptr = ptr;
KeysQueryRequestFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
KeysQueryRequestFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_keysqueryrequest_free(ptr, 0);
}
/**
* The request ID.
* @returns {string}
*/
get id() {
const ret = wasm.__wbg_get_keysqueryrequest_id(this.__wbg_ptr);
return takeObject(ret);
}
/**
* A JSON-encoded string containing the rest of the payload: `timeout`,
* `device_keys`, `token`.
*
* It represents the body of the HTTP request.
* @returns {string}
*/
get body() {
const ret = wasm.__wbg_get_keysqueryrequest_body(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Create a new `KeysQueryRequest`.
* @param {string} id
* @param {string} body
*/
constructor(id, body) {
const ret = wasm.keysqueryrequest_new(addHeapObject(id), addHeapObject(body));
this.__wbg_ptr = ret >>> 0;
KeysQueryRequestFinalization.register(this, this.__wbg_ptr, this);
return this;
}
/**
* Get its request type.
* @returns {RequestType}
*/
get type() {
const ret = wasm.keysqueryrequest_type(this.__wbg_ptr);
return ret;
}
}
module.exports.KeysQueryRequest = KeysQueryRequest;
const KeysUploadRequestFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_keysuploadrequest_free(ptr >>> 0, 1));
/**
* Outgoing Requests *
* Data for a request to the `/keys/upload` API endpoint
* ([specification]).
*
* Publishes end-to-end encryption keys for the device.
*
* [specification]: https://spec.matrix.org/unstable/client-server-api/#post_matrixclientv3keysupload
*/
class KeysUploadRequest {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(KeysUploadRequest.prototype);
obj.__wbg_ptr = ptr;
KeysUploadRequestFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
KeysUploadRequestFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_keysuploadrequest_free(ptr, 0);
}
/**
* The request ID.
* @returns {string}
*/
get id() {
const ret = wasm.__wbg_get_keysuploadrequest_id(this.__wbg_ptr);
return takeObject(ret);
}
/**
* A JSON-encoded string containing the rest of the payload: `device_keys`,
* `one_time_keys`, `fallback_keys`.
*
* It represents the body of the HTTP request.
* @returns {string}
*/
get body() {
const ret = wasm.__wbg_get_keysuploadrequest_body(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Create a new `KeysUploadRequest`.
* @param {string} id
* @param {string} body
*/
constructor(id, body) {
const ret = wasm.keysuploadrequest_new(addHeapObject(id), addHeapObject(body));
this.__wbg_ptr = ret >>> 0;
KeysUploadRequestFinalization.register(this, this.__wbg_ptr, this);
return this;
}
/**
* Get its request type.
* @returns {RequestType}
*/
get type() {
const ret = wasm.keysuploadrequest_type(this.__wbg_ptr);
return ret;
}
}
module.exports.KeysUploadRequest = KeysUploadRequest;
const MaybeSignatureFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_maybesignature_free(ptr >>> 0, 1));
/**
* Represents a signature that is either valid _or_ that could not be
* decoded.
*/
class MaybeSignature {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(MaybeSignature.prototype);
obj.__wbg_ptr = ptr;
MaybeSignatureFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
MaybeSignatureFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_maybesignature_free(ptr, 0);
}
/**
* Check whether the signature has been successfully decoded.
* @returns {boolean}
*/
isValid() {
const ret = wasm.maybesignature_isValid(this.__wbg_ptr);
return ret !== 0;
}
/**
* Check whether the signature could not be successfully decoded.
* @returns {boolean}
*/
isInvalid() {
const ret = wasm.maybesignature_isInvalid(this.__wbg_ptr);
return ret !== 0;
}
/**
* The signature, if successfully decoded.
* @returns {Signature | undefined}
*/
get signature() {
const ret = wasm.maybesignature_signature(this.__wbg_ptr);
return ret === 0 ? undefined : Signature.__wrap(ret);
}
/**
* The base64 encoded string that is claimed to contain a
* signature but could not be decoded, if any.
* @returns {string | undefined}
*/
get invalidSignatureSource() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.maybesignature_invalidSignatureSource(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
let v1;
if (r0 !== 0) {
v1 = getStringFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
}
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
}
module.exports.MaybeSignature = MaybeSignature;
const MegolmDecryptionErrorFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_megolmdecryptionerror_free(ptr >>> 0, 1));
/**
* Js Decryption error with code.
*/
class MegolmDecryptionError {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(MegolmDecryptionError.prototype);
obj.__wbg_ptr = ptr;
MegolmDecryptionErrorFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
MegolmDecryptionErrorFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_megolmdecryptionerror_free(ptr, 0);
}
/**
* Description code for the error. See `DecryptionErrorCode`
* @returns {DecryptionErrorCode}
*/
get code() {
const ret = wasm.__wbg_get_megolmdecryptionerror_code(this.__wbg_ptr);
return ret;
}
/**
* detailed description
* @returns {string}
*/
get description() {
const ret = wasm.__wbg_get_megolmdecryptionerror_description(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Withheld code if any. Only for `UnknownMessageIndex` error code
* @returns {string | undefined}
*/
get maybe_withheld() {
const ret = wasm.__wbg_get_megolmdecryptionerror_maybe_withheld(this.__wbg_ptr);
return takeObject(ret);
}
}
module.exports.MegolmDecryptionError = MegolmDecryptionError;
const MegolmV1BackupKeyFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_megolmv1backupkey_free(ptr >>> 0, 1));
/**
* The public part of the backup key.
*/
class MegolmV1BackupKey {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(MegolmV1BackupKey.prototype);
obj.__wbg_ptr = ptr;
MegolmV1BackupKeyFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
MegolmV1BackupKeyFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_megolmv1backupkey_free(ptr, 0);
}
/**
* The actual base64 encoded public key.
* @returns {string}
*/
get publicKeyBase64() {
const ret = wasm.megolmv1backupkey_publicKeyBase64(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Get the full name of the backup algorithm this backup key supports.
* @returns {string}
*/
get algorithm() {
const ret = wasm.megolmv1backupkey_algorithm(this.__wbg_ptr);
return takeObject(ret);
}
}
module.exports.MegolmV1BackupKey = MegolmV1BackupKey;
const MigrationFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_migration_free(ptr >>> 0, 1));
/**
* Migration routines
*
* The public methods are exposed as static methods on this class, for
* namespacing and to enable easier mocking in unit tests.
*/
class Migration {
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
MigrationFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_migration_free(ptr, 0);
}
/**
* Import the base dataset from a libolm-based setup to a vodozemac-based
* setup stored in IndexedDB.
*
* Populates the user credentials, Olm account, backup data, etc. This is
* the first step in the migration process. Once this base data is
* imported, further data can be imported with {@link
* #migrateOlmSessions}, {@link #migrateMegolmSessions}, and TODO room settings.
*
* # Arguments
*
* * `data` - The data to be migrated
* * `pickle_key` - The libolm pickle key that was used to pickle the olm
* account objects.
* * `store_handle` - A connection to the CryptoStore which will be used to
* store the vodozemac data.
* @param {BaseMigrationData} data
* @param {Uint8Array} pickle_key
* @param {StoreHandle} store_handle
* @returns {Promise<any>}
*/
static migrateBaseData(data, pickle_key, store_handle) {
_assertClass(data, BaseMigrationData);
_assertClass(store_handle, StoreHandle);
const ret = wasm.migration_migrateBaseData(data.__wbg_ptr, addHeapObject(pickle_key), store_handle.__wbg_ptr);
return takeObject(ret);
}
/**
* Migrate Olm sessions of a libolm-based setup to a vodozemac-based setup
* stored in an indexedDB crypto store.
*
* Before this method can be used, {@link #migrateBaseData} must be used to
* import the base data into the crypto store.
*
* This method should be called a number of times, with separate batches of
* `sessions`. If a progress display is given, it can be updated after
* each batch is successfully imported.
*
* # Arguments
*
* * `sessions` - An `Array` of {@link PickledSession}s to import. Items
* inside `sessions` will be invalidated by this method.
* * `pickle_key` - The libolm pickle key that was used to pickle the olm
* session objects.
* * `store_handle` - A connection to the CryptoStore which will be used to
* store the vodozemac data.
* @param {(PickledSession)[]} sessions
* @param {Uint8Array} pickle_key
* @param {StoreHandle} store_handle
* @returns {Promise<any>}
*/
static migrateOlmSessions(sessions, pickle_key, store_handle) {
const ptr0 = passArrayJsValueToWasm0(sessions, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
_assertClass(store_handle, StoreHandle);
const ret = wasm.migration_migrateOlmSessions(ptr0, len0, addHeapObject(pickle_key), store_handle.__wbg_ptr);
return takeObject(ret);
}
/**
* Migrate Megolm sessions of a libolm-based setup to a vodozemac-based
* setup stored in an indexedDB crypto store.
*
* Before this method can be used, {@link #migrateBaseData} must be used to
* import the base data into the crypto store.
*
* This method should be called a number of times, with separate batches of
* `sessions`. If a progress display is given, it can be updated after
* each batch is successfully imported.
*
* # Arguments
*
* * `sessions` - An `Array` of {@link PickledInboundGroupSession}s to
* import. Items inside `sessions` will be invalidated by this method.
* * `pickle_key` - The libolm pickle key that was used to pickle the
* megolm session objects.
* * `store_handle` - A connection to the CryptoStore which will be used to
* store the vodozemac data.
* @param {(PickledInboundGroupSession)[]} sessions
* @param {Uint8Array} pickle_key
* @param {StoreHandle} store_handle
* @returns {Promise<any>}
*/
static migrateMegolmSessions(sessions, pickle_key, store_handle) {
const ptr0 = passArrayJsValueToWasm0(sessions, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
_assertClass(store_handle, StoreHandle);
const ret = wasm.migration_migrateMegolmSessions(ptr0, len0, addHeapObject(pickle_key), store_handle.__wbg_ptr);
return takeObject(ret);
}
}
module.exports.Migration = Migration;
const OlmMachineFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_olmmachine_free(ptr >>> 0, 1));
/**
* State machine implementation of the Olm/Megolm encryption protocol
* used for Matrix end to end encryption.
*/
class OlmMachine {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(OlmMachine.prototype);
obj.__wbg_ptr = ptr;
OlmMachineFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
OlmMachineFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_olmmachine_free(ptr, 0);
}
/**
* Constructor will always fail. To create a new `OlmMachine`, please use
* the `initialize` method.
*
* Why this pattern? `initialize` returns a `Promise`. Returning a
*/
constructor() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.olmmachine_new(retptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
this.__wbg_ptr = r0 >>> 0;
OlmMachineFinalization.register(this, this.__wbg_ptr, this);
return this;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Create a new `OlmMachine`.
*
* The created machine will keep the encryption keys either in a IndexedDB
* based store, or in a memory store and once the objects is dropped,
* the keys will be lost.
*
* # Arguments
*
* * `user_id` - represents the unique ID of the user that owns this
* machine.
*
* * `device_id` - represents the unique ID of the device
* that owns this machine.
*
* * `store_name` - The name that should be used to open the IndexedDB
* based database. If this isn't provided, a memory-only store will be
* used. *Note* the memory-only store will lose your E2EE keys when the
* `OlmMachine` gets dropped.
*
* * `store_passphrase` - The passphrase that should be used to encrypt the
* IndexedDB-based store.
* @param {UserId} user_id
* @param {DeviceId} device_id
* @param {string | undefined} [store_name]
* @param {string | undefined} [store_passphrase]
* @returns {Promise<any>}
*/
static initialize(user_id, device_id, store_name, store_passphrase) {
_assertClass(user_id, UserId);
_assertClass(device_id, DeviceId);
var ptr0 = isLikeNone(store_name) ? 0 : passStringToWasm0(store_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
var len0 = WASM_VECTOR_LEN;
var ptr1 = isLikeNone(store_passphrase) ? 0 : passStringToWasm0(store_passphrase, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
var len1 = WASM_VECTOR_LEN;
const ret = wasm.olmmachine_initialize(user_id.__wbg_ptr, device_id.__wbg_ptr, ptr0, len0, ptr1, len1);
return takeObject(ret);
}
/**
* Create a new `OlmMachine` backed by an existing store.
*
* # Arguments
*
* * `user_id` - represents the unique ID of the user that owns this
* machine.
*
* * `device_id` - represents the unique ID of the device
* that owns this machine.
*
* * `store_handle` - the connection to the crypto store to be used for
* this machine.
* @param {UserId} user_id
* @param {DeviceId} device_id
* @param {StoreHandle} store_handle
* @returns {Promise<any>}
*/
static initFromStore(user_id, device_id, store_handle) {
_assertClass(user_id, UserId);
_assertClass(device_id, DeviceId);
_assertClass(store_handle, StoreHandle);
const ret = wasm.olmmachine_initFromStore(user_id.__wbg_ptr, device_id.__wbg_ptr, store_handle.__wbg_ptr);
return takeObject(ret);
}
/**
* The unique user ID that owns this `OlmMachine` instance.
* @returns {UserId}
*/
get userId() {
const ret = wasm.olmmachine_userId(this.__wbg_ptr);
return UserId.__wrap(ret);
}
/**
* The unique device ID that identifies this `OlmMachine`.
* @returns {DeviceId}
*/
get deviceId() {
const ret = wasm.olmmachine_deviceId(this.__wbg_ptr);
return DeviceId.__wrap(ret);
}
/**
* The time, in milliseconds since the unix epoch, at which the `Account`
* backing this `OlmMachine` was created.
*
* An `Account` is created when an `OlmMachine` is first instantiated
* against a given `Store`, at which point it creates identity keys etc.
* This method returns the timestamp, according to the local clock, at
* which that happened.
* @returns {number}
*/
get deviceCreationTimeMs() {
const ret = wasm.olmmachine_deviceCreationTimeMs(this.__wbg_ptr);
return ret;
}
/**
* Get the public parts of our Olm identity keys.
* @returns {IdentityKeys}
*/
get identityKeys() {
const ret = wasm.olmmachine_identityKeys(this.__wbg_ptr);
return IdentityKeys.__wrap(ret);
}
/**
* Get the display name of our own device.
* @returns {Promise<any>}
*/
get displayName() {
const ret = wasm.olmmachine_displayName(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Whether automatic transmission of room key requests is enabled.
*
* Room key requests allow the device to request room keys that it might
* have missed in the original share using `m.room_key_request`
* events.
* @returns {boolean}
*/
get roomKeyRequestsEnabled() {
const ret = wasm.olmmachine_roomKeyRequestsEnabled(this.__wbg_ptr);
return ret !== 0;
}
/**
* Enable or disable automatic transmission of room key requests.
* @param {boolean} enabled
*/
set roomKeyRequestsEnabled(enabled) {
wasm.olmmachine_set_roomKeyRequestsEnabled(this.__wbg_ptr, enabled);
}
/**
* Whether room key forwarding is enabled.
*
* If room key forwarding is enabled, we will automatically reply to
* incoming `m.room_key_request` messages from verified devices by
* forwarding the requested key (if we have it).
* @returns {boolean}
*/
get roomKeyForwardingEnabled() {
const ret = wasm.olmmachine_roomKeyForwardingEnabled(this.__wbg_ptr);
return ret !== 0;
}
/**
* Enable or disable room key forwarding.
* @param {boolean} enabled
*/
set roomKeyForwardingEnabled(enabled) {
wasm.olmmachine_set_roomKeyForwardingEnabled(this.__wbg_ptr, enabled);
}
/**
* Get the list of users whose devices we are currently tracking.
*
* A user can be marked for tracking using the
* [`update_tracked_users`](#method.update_tracked_users) method.
*
* Returns a `Set<UserId>`.
* @returns {Promise<any>}
*/
trackedUsers() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.olmmachine_trackedUsers(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Update the list of tracked users.
*
* The OlmMachine maintains a list of users whose devices we are keeping
* track of: these are known as "tracked users". These must be users
* that we share a room with, so that the server sends us updates for
* their device lists.
*
* # Arguments
*
* * `users` - An array of user ids that should be added to the list of
* tracked users
*
* Any users that hadn't been seen before will be flagged for a key query
* immediately, and whenever `receive_sync_changes` receives a
* "changed" notification for that user in the future.
*
* Users that were already in the list are unaffected.
*
* Items inside `users` will be invalidated by this method. Be careful not
* to use the `UserId`s after this method has been called.
* @param {(UserId)[]} users
* @returns {Promise<any>}
*/
updateTrackedUsers(users) {
const ptr0 = passArrayJsValueToWasm0(users, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
const ret = wasm.olmmachine_updateTrackedUsers(this.__wbg_ptr, ptr0, len0);
return takeObject(ret);
}
/**
* Mark all tracked users as dirty.
*
* All users *whose device lists we are tracking* are flagged as needing a
* key query. Users whose devices we are not tracking are ignored.
* @returns {Promise<void>}
*/
markAllTrackedUsersAsDirty() {
const ret = wasm.olmmachine_markAllTrackedUsersAsDirty(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Handle to-device events and one-time key counts from a sync
* response.
*
* This will decrypt and handle to-device events returning the
* decrypted versions of them.
*
* To decrypt an event from the room timeline call
* `decrypt_room_event`.
*
* # Arguments
*
* * `to_device_events`: the JSON-encoded to-device evens from the `/sync`
* response
* * `changed_devices`: the mapping of changed and left devices, from the
* `/sync` response
* * `one_time_keys_counts`: The number of one-time keys on the server,
* from the `/sync` response. A `Map` from string (encryption algorithm)
* to number (number of keys).
* * `unused_fallback_keys`: Optionally, a `Set` of unused fallback keys on
* the server, from the `/sync` response. If this is set, it is used to
* determine if new fallback keys should be uploaded.
*
* # Returns
*
* A list of JSON strings, containing the decrypted to-device events.
* @param {string} to_device_events
* @param {DeviceLists} changed_devices
* @param {Map<any, any>} one_time_keys_counts
* @param {Set<any> | undefined} [unused_fallback_keys]
* @returns {Promise<any>}
*/
receiveSyncChanges(to_device_events, changed_devices, one_time_keys_counts, unused_fallback_keys) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(to_device_events, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
_assertClass(changed_devices, DeviceLists);
wasm.olmmachine_receiveSyncChanges(retptr, this.__wbg_ptr, ptr0, len0, changed_devices.__wbg_ptr, addBorrowedObject(one_time_keys_counts), isLikeNone(unused_fallback_keys) ? 0 : addHeapObject(unused_fallback_keys));
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
heap[stack_pointer++] = undefined;
}
}
/**
* Get the outgoing requests that need to be sent out.
*
* This returns a list of values, each of which can be any of:
* * {@link KeysUploadRequest},
* * {@link KeysQueryRequest},
* * {@link KeysClaimRequest},
* * {@link ToDeviceRequest},
* * {@link SignatureUploadRequest},
* * {@link RoomMessageRequest}, or
* * {@link KeysBackupRequest}.
*
* Those requests need to be sent out to the server and the
* responses need to be passed back to the state machine
* using {@link OlmMachine.markRequestAsSent}.
* @returns {Promise<any>}
*/
outgoingRequests() {
const ret = wasm.olmmachine_outgoingRequests(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Mark the request with the given request ID as sent (see
* `outgoing_requests`).
*
* Arguments are:
*
* * `request_id` represents the unique ID of the request that was sent
* out. This is needed to couple the response with the now sent out
* request.
* * `response_type` represents the type of the request that was sent out.
* * `response` represents the response that was received from the server
* after the outgoing request was sent out.
* @param {string} request_id
* @param {RequestType} request_type
* @param {string} response
* @returns {Promise<any>}
*/
markRequestAsSent(request_id, request_type, response) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ptr1 = passStringToWasm0(response, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
wasm.olmmachine_markRequestAsSent(retptr, this.__wbg_ptr, ptr0, len0, request_type, ptr1, len1);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Encrypt a room message for the given room.
*
* **Note**: A room key needs to be shared with the group of users that are
* members in the given room. If this is not done this method will panic.
*
* The usual flow to encrypt an event using this state machine is as
* follows:
*
* 1. Get the one-time key claim request to establish 1:1 Olm sessions for
* the room members of the room we wish to participate in. This is done
* using the [`get_missing_sessions()`](Self::get_missing_sessions)
* method. This method call should be locked per call.
*
* 2. Share a room key with all the room members using the
* [`share_room_key()`](Self::share_room_key). This method call should
* be locked per room.
*
* 3. Encrypt the event using this method.
*
* 4. Send the encrypted event to the server.
*
* After the room key is shared steps 1 and 2 will become noops, unless
* there's some changes in the room membership or in the list of devices a
* member has.
*
*
* `room_id` is the ID of the room for which the message should
* be encrypted. `event_type` is the type of the event. `content`
* is the plaintext content of the message that should be
* encrypted.
*
* # Panics
*
* Panics if a group session for the given room wasn't shared
* beforehand.
* @param {RoomId} room_id
* @param {string} event_type
* @param {string} content
* @returns {Promise<any>}
*/
encryptRoomEvent(room_id, event_type, content) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
_assertClass(room_id, RoomId);
const ptr0 = passStringToWasm0(event_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ptr1 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
wasm.olmmachine_encryptRoomEvent(retptr, this.__wbg_ptr, room_id.__wbg_ptr, ptr0, len0, ptr1, len1);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Decrypt an event from a room timeline.
*
* # Arguments
*
* * `event`, the event that should be decrypted.
* * `room_id`, the ID of the room where the event was sent to.
*
* # Returns
*
* A `Promise` which resolves to a {@link DecryptedRoomEvent} instance, or
* rejects with a {@link MegolmDecryptionError} instance.
* @param {string} event
* @param {RoomId} room_id
* @param {DecryptionSettings} decryption_settings
* @returns {Promise<any>}
*/
decryptRoomEvent(event, room_id, decryption_settings) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(event, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
_assertClass(room_id, RoomId);
_assertClass(decryption_settings, DecryptionSettings);
wasm.olmmachine_decryptRoomEvent(retptr, this.__wbg_ptr, ptr0, len0, room_id.__wbg_ptr, decryption_settings.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Get encryption info for a decrypted timeline event.
*
* This recalculates the `EncryptionInfo` data that is returned by
* `decryptRoomEvent`, based on the current
* verification status of the sender, etc.
*
* Returns an error for an unencrypted event.
*
* # Arguments
*
* * `event` - The event to get information for.
* * `room_id` - The ID of the room where the event was sent to.
*
* # Returns
*
* {@link EncryptionInfo}
* @param {string} event
* @param {RoomId} room_id
* @returns {Promise<any>}
*/
getRoomEventEncryptionInfo(event, room_id) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(event, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
_assertClass(room_id, RoomId);
wasm.olmmachine_getRoomEventEncryptionInfo(retptr, this.__wbg_ptr, ptr0, len0, room_id.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Get the status of the private cross signing keys.
*
* This can be used to check which private cross signing keys we
* have stored locally.
* @returns {Promise<any>}
*/
crossSigningStatus() {
const ret = wasm.olmmachine_crossSigningStatus(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Export all the secrets we have in the store into a {@link
* SecretsBundle}.
*
* This method will export all the private cross-signing keys and, if
* available, the private part of a backup key and its accompanying
* version.
*
* The method will fail if we don't have all three private cross-signing
* keys available.
*
* **Warning**: Only export this and share it with a trusted recipient,
* i.e. if an existing device is sharing this with a new device.
* @returns {Promise<SecretsBundle>}
*/
exportSecretsBundle() {
const ret = wasm.olmmachine_exportSecretsBundle(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Import and persists secrets from a {@link SecretsBundle}.
*
* This method will import all the private cross-signing keys and, if
* available, the private part of a backup key and its accompanying
* version into the store.
*
* **Warning**: Only import this from a trusted source, i.e. if an existing
* device is sharing this with a new device. The imported cross-signing
* keys will create a {@link OwnUserIdentity} and mark it as verified.
*
* The backup key will be persisted in the store and can be enabled using
* the {@link BackupMachine}.
*
* The provided `SecretsBundle` is freed by this method; be careful not to
* use it once this method has been called.
* @param {SecretsBundle} bundle
* @returns {Promise<void>}
*/
importSecretsBundle(bundle) {
_assertClass(bundle, SecretsBundle);
var ptr0 = bundle.__destroy_into_raw();
const ret = wasm.olmmachine_importSecretsBundle(this.__wbg_ptr, ptr0);
return takeObject(ret);
}
/**
* Export all the private cross signing keys we have.
*
* The export will contain the seeds for the ed25519 keys as
* unpadded base64 encoded strings.
*
* Returns `null` if we don’t have any private cross signing keys;
* otherwise returns a `CrossSigningKeyExport`.
* @returns {Promise<any>}
*/
exportCrossSigningKeys() {
const ret = wasm.olmmachine_exportCrossSigningKeys(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Import our private cross signing keys.
*
* The keys should be provided as unpadded-base64-encoded strings.
*
* Returns a `CrossSigningStatus`.
* @param {string | undefined} [master_key]
* @param {string | undefined} [self_signing_key]
* @param {string | undefined} [user_signing_key]
* @returns {Promise<any>}
*/
importCrossSigningKeys(master_key, self_signing_key, user_signing_key) {
var ptr0 = isLikeNone(master_key) ? 0 : passStringToWasm0(master_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
var len0 = WASM_VECTOR_LEN;
var ptr1 = isLikeNone(self_signing_key) ? 0 : passStringToWasm0(self_signing_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
var len1 = WASM_VECTOR_LEN;
var ptr2 = isLikeNone(user_signing_key) ? 0 : passStringToWasm0(user_signing_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
var len2 = WASM_VECTOR_LEN;
const ret = wasm.olmmachine_importCrossSigningKeys(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
return takeObject(ret);
}
/**
* Create a new cross signing identity and get the upload request
* to push the new public keys to the server.
*
* Warning: This will delete any existing cross signing keys that
* might exist on the server and thus will reset the trust
* between all the devices.
*
* Uploading these keys will require user interactive auth.
*
* # Arguments
*
* * `reset`, whether the method should create a new identity or use the
* existing one during the request. If set to true, the request will
* attempt to upload a new identity. If set to false, the request will
* attempt to upload the existing identity. Since the uploading process
* requires user interactive authentication, which involves sending out
* the same request multiple times, setting this argument to false
* enables you to reuse the same request.
*
* Returns a {@link CrossSigningBootstrapRequests}.
* @param {boolean} reset
* @returns {Promise<any>}
*/
bootstrapCrossSigning(reset) {
const ret = wasm.olmmachine_bootstrapCrossSigning(this.__wbg_ptr, reset);
return takeObject(ret);
}
/**
* Get the cross signing user identity of a user.
*
* Returns a promise for an `OwnUserIdentity`, a `UserIdentity`, or
* `undefined`.
* @param {UserId} user_id
* @returns {Promise<any>}
*/
getIdentity(user_id) {
_assertClass(user_id, UserId);
const ret = wasm.olmmachine_getIdentity(this.__wbg_ptr, user_id.__wbg_ptr);
return takeObject(ret);
}
/**
* Sign the given message using our device key and if available
* cross-signing master key.
* @param {string} message
* @returns {Promise<any>}
*/
sign(message) {
const ptr0 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ret = wasm.olmmachine_sign(this.__wbg_ptr, ptr0, len0);
return takeObject(ret);
}
/**
* Invalidate the currently active outbound group session for the
* given room.
*
* Returns true if a session was invalidated, false if there was
* no session to invalidate.
* @param {RoomId} room_id
* @returns {Promise<any>}
*/
invalidateGroupSession(room_id) {
_assertClass(room_id, RoomId);
const ret = wasm.olmmachine_invalidateGroupSession(this.__wbg_ptr, room_id.__wbg_ptr);
return takeObject(ret);
}
/**
* Get to-device requests to share a room key with users in a room.
*
* `room_id` is the room ID. `users` is an array of `UserId`
* objects. `encryption_settings` are an `EncryptionSettings`
* object.
*
* Note: Care should be taken that only one such request at a
* time is in flight for the same room, e.g. using a lock.
*
* Returns an array of `ToDeviceRequest`s.
*
* Items inside `users` will be invalidated by this method. Be careful not
* to use the `UserId`s after this method has been called.
* @param {RoomId} room_id
* @param {(UserId)[]} users
* @param {EncryptionSettings} encryption_settings
* @returns {Promise<any>}
*/
shareRoomKey(room_id, users, encryption_settings) {
_assertClass(room_id, RoomId);
const ptr0 = passArrayJsValueToWasm0(users, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
_assertClass(encryption_settings, EncryptionSettings);
const ret = wasm.olmmachine_shareRoomKey(this.__wbg_ptr, room_id.__wbg_ptr, ptr0, len0, encryption_settings.__wbg_ptr);
return takeObject(ret);
}
/**
* Generate an "out-of-band" key query request for the given set of users.
*
* This can be useful if we need the results from `getIdentity` or
* `getUserDevices` to be as up-to-date as possible.
*
* Returns a `KeysQueryRequest` object. The response of the request should
* be passed to the `OlmMachine` with the `mark_request_as_sent`.
*
* Items inside `users` will be invalidated by this method. Be careful not
* to use the `UserId`s after this method has been called.
* @param {(UserId)[]} users
* @returns {KeysQueryRequest}
*/
queryKeysForUsers(users) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passArrayJsValueToWasm0(users, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
wasm.olmmachine_queryKeysForUsers(retptr, this.__wbg_ptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return KeysQueryRequest.__wrap(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Get the a key claiming request for the user/device pairs that
* we are missing Olm sessions for.
*
* Returns `null` if no key claiming request needs to be sent
* out, otherwise it returns a `KeysClaimRequest` object.
*
* Sessions need to be established between devices so group
* sessions for a room can be shared with them.
*
* This should be called every time a group session needs to be
* shared as well as between sync calls. After a sync some
* devices may request room keys without us having a valid Olm
* session with them, making it impossible to server the room key
* request, thus it’s necessary to check for missing sessions
* between sync as well.
*
* Note: Care should be taken that only one such request at a
* time is in flight, e.g. using a lock.
*
* The response of a successful key claiming requests needs to be
* passed to the `OlmMachine` with the `mark_request_as_sent`.
*
* `users` represents the list of users that we should check if
* we lack a session with one of their devices. This can be an
* empty iterator when calling this method between sync requests.
*
* Items inside `users` will be invalidated by this method. Be careful not
* to use the `UserId`s after this method has been called.
* @param {(UserId)[]} users
* @returns {Promise<any>}
*/
getMissingSessions(users) {
const ptr0 = passArrayJsValueToWasm0(users, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
const ret = wasm.olmmachine_getMissingSessions(this.__wbg_ptr, ptr0, len0);
return takeObject(ret);
}
/**
* Get a map holding all the devices of a user.
*
* ### Parameters
*
* * `user_id` - The unique ID of the user that the device belongs to.
*
* * `timeout_secs` - The amount of time we should wait for a `/keys/query`
* response before returning if the user's device list has been marked as
* stale. **Note**, this assumes that the requests from {@link
* OlmMachine.outgoingRequests} are being processed and sent out.
*
* If unset, we will return immediately even if the device list is stale.
*
* ### Returns
*
* A {@link UserDevices} object.
* @param {UserId} user_id
* @param {number | undefined} [timeout_secs]
* @returns {Promise<any>}
*/
getUserDevices(user_id, timeout_secs) {
_assertClass(user_id, UserId);
const ret = wasm.olmmachine_getUserDevices(this.__wbg_ptr, user_id.__wbg_ptr, !isLikeNone(timeout_secs), isLikeNone(timeout_secs) ? 0 : timeout_secs);
return takeObject(ret);
}
/**
* Get a specific device of a user.
*
* ### Parameters
*
* * `user_id` - The unique ID of the user that the device belongs to.
*
* * `device_id` - The unique ID of the device.
*
* * `timeout_secs` - The amount of time we should wait for a `/keys/query`
* response before returning if the user's device list has been marked as
* stale. **Note**, this assumes that the requests from {@link
* OlmMachine.outgoingRequests} are being processed and sent out.
*
* If unset, we will return immediately even if the device list is stale.
*
* ### Returns
*
* If the device is known, a {@link Device}. Otherwise, `undefined`.
* @param {UserId} user_id
* @param {DeviceId} device_id
* @param {number | undefined} [timeout_secs]
* @returns {Promise<any>}
*/
getDevice(user_id, device_id, timeout_secs) {
_assertClass(user_id, UserId);
_assertClass(device_id, DeviceId);
const ret = wasm.olmmachine_getDevice(this.__wbg_ptr, user_id.__wbg_ptr, device_id.__wbg_ptr, !isLikeNone(timeout_secs), isLikeNone(timeout_secs) ? 0 : timeout_secs);
return takeObject(ret);
}
/**
* Get a verification object for the given user ID with the given
* flow ID (a to-device request ID if the verification has been
* requested by a to-device request, or a room event ID if the
* verification has been requested by a room event).
*
* It returns a “`Verification` object”, which is either a `Sas`
* or `Qr` object.
* @param {UserId} user_id
* @param {string} flow_id
* @returns {any}
*/
getVerification(user_id, flow_id) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
_assertClass(user_id, UserId);
const ptr0 = passStringToWasm0(flow_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.olmmachine_getVerification(retptr, this.__wbg_ptr, user_id.__wbg_ptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Get a verification request object with the given flow ID.
* @param {UserId} user_id
* @param {string} flow_id
* @returns {VerificationRequest | undefined}
*/
getVerificationRequest(user_id, flow_id) {
_assertClass(user_id, UserId);
const ptr0 = passStringToWasm0(flow_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ret = wasm.olmmachine_getVerificationRequest(this.__wbg_ptr, user_id.__wbg_ptr, ptr0, len0);
return ret === 0 ? undefined : VerificationRequest.__wrap(ret);
}
/**
* Get all the verification requests of a given user.
* @param {UserId} user_id
* @returns {Array<any>}
*/
getVerificationRequests(user_id) {
_assertClass(user_id, UserId);
const ret = wasm.olmmachine_getVerificationRequests(this.__wbg_ptr, user_id.__wbg_ptr);
return takeObject(ret);
}
/**
* Receive a verification event.
*
* This method can be used to pass verification events that are happening
* in rooms to the `OlmMachine`. The event should be in the decrypted form.
* @param {string} event
* @param {RoomId} room_id
* @returns {Promise<any>}
*/
receiveVerificationEvent(event, room_id) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(event, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
_assertClass(room_id, RoomId);
wasm.olmmachine_receiveVerificationEvent(retptr, this.__wbg_ptr, ptr0, len0, room_id.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Export the keys that match the given predicate.
*
* `predicate` is a closure that will be called for every known
* `InboundGroupSession`, which represents a room key. If the closure
* returns `true`, the `InboundGroupSession` will be included in the
* export; otherwise it won't.
*
* Returns a Promise containing a Result containing a String which is a
* JSON-encoded array of ExportedRoomKey objects.
* @param {Function} predicate
* @returns {Promise<any>}
*/
exportRoomKeys(predicate) {
const ret = wasm.olmmachine_exportRoomKeys(this.__wbg_ptr, addHeapObject(predicate));
return takeObject(ret);
}
/**
* Import the given room keys into our store.
*
* Mostly, a deprecated alias for `importExportedRoomKeys`, though the
* return type is different.
*
* Returns a String containing a JSON-encoded object, holding three
* properties:
* * `total_count` (the total number of keys found in the export data).
* * `imported_count` (the number of keys that were imported).
* * `keys` (the keys that were imported; a map from room id to a map of
* the sender key to a list of session ids).
*
* @deprecated Use `importExportedRoomKeys` or `importBackedUpRoomKeys`.
* @param {string} exported_room_keys
* @param {Function} progress_listener
* @returns {Promise<any>}
*/
importRoomKeys(exported_room_keys, progress_listener) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(exported_room_keys, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.olmmachine_importRoomKeys(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(progress_listener));
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Import the given room keys into our store.
*
* `exported_keys` is a JSON-encoded list of previously exported keys that
* should be imported into our store. If we already have a better
* version of a key, the key will _not_ be imported.
*
* `progress_listener` is a closure that takes 2 `BigInt` arguments:
* `progress` and `total`, and returns nothing.
*
* Returns a {@link RoomKeyImportResult}.
* @param {string} exported_room_keys
* @param {Function} progress_listener
* @returns {Promise<any>}
*/
importExportedRoomKeys(exported_room_keys, progress_listener) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(exported_room_keys, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.olmmachine_importExportedRoomKeys(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(progress_listener));
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Import the given room keys into our store.
*
* # Arguments
*
* * `backed_up_room_keys`: keys that were retrieved from backup and that
* should be added to our store (provided they are better than our
* current versions of those keys). Specifically, it should be a Map from
* {@link RoomId}, to a Map from session ID to a (decrypted) session data
* structure.
*
* * `progress_listener`: an optional callback that takes 3 arguments:
* `progress` (the number of keys that have successfully been imported),
* `total` (the total number of keys), and `failures` (the number of keys
* that failed to import), and returns nothing.
*
* # Returns
*
* A {@link RoomKeyImportResult}.
* @param {Map<any, any>} backed_up_room_keys
* @param {Function | undefined} progress_listener
* @param {string} backup_version
* @returns {Promise<any>}
*/
importBackedUpRoomKeys(backed_up_room_keys, progress_listener, backup_version) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(backup_version, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.olmmachine_importBackedUpRoomKeys(retptr, this.__wbg_ptr, addBorrowedObject(backed_up_room_keys), isLikeNone(progress_listener) ? 0 : addHeapObject(progress_listener), ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
heap[stack_pointer++] = undefined;
}
}
/**
* Store the backup decryption key in the crypto store.
*
* This is useful if the client wants to support gossiping of the backup
* key.
*
* Returns `Promise<void>`.
* @param {BackupDecryptionKey} decryption_key
* @param {string} version
* @returns {Promise<any>}
*/
saveBackupDecryptionKey(decryption_key, version) {
_assertClass(decryption_key, BackupDecryptionKey);
const ptr0 = passStringToWasm0(version, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ret = wasm.olmmachine_saveBackupDecryptionKey(this.__wbg_ptr, decryption_key.__wbg_ptr, ptr0, len0);
return takeObject(ret);
}
/**
* Get the backup keys we have saved in our store.
* Returns a `Promise` for {@link BackupKeys}.
* @returns {Promise<any>}
*/
getBackupKeys() {
const ret = wasm.olmmachine_getBackupKeys(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Check if the given backup has been verified by us or by another of our
* devices that we trust.
*
* The `backup_info` should be a Javascript object with the following
* format:
*
* ```json
* {
* "algorithm": "m.megolm_backup.v1.curve25519-aes-sha2",
* "auth_data": {
* "public_key":"XjhWTCjW7l59pbfx9tlCBQolfnIQWARoKOzjTOPSlWM",
* "signatures": {}
* }
* }
* ```
*
* Returns a {@link SignatureVerification} object.
* @param {any} backup_info
* @returns {Promise<any>}
*/
verifyBackup(backup_info) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.olmmachine_verifyBackup(retptr, this.__wbg_ptr, addHeapObject(backup_info));
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Activate the given backup key to be used with the given backup version.
*
* **Warning**: The caller needs to make sure that the given `BackupKey` is
* trusted, otherwise we might be encrypting room keys that a malicious
* party could decrypt.
*
* The {@link #verifyBackup} method can be used to do so.
*
* Returns `Promise<void>`.
* @param {string} public_key_base_64
* @param {string} version
* @returns {Promise<any>}
*/
enableBackupV1(public_key_base_64, version) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(public_key_base_64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ptr1 = passStringToWasm0(version, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
wasm.olmmachine_enableBackupV1(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Are we able to encrypt room keys.
*
* This returns true if we have an active `BackupKey` and backup version
* registered with the state machine.
*
* Returns `Promise<bool>`.
* @returns {Promise<any>}
*/
isBackupEnabled() {
const ret = wasm.olmmachine_isBackupEnabled(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Disable and reset our backup state.
*
* This will remove any pending backup request, remove the backup key and
* reset the backup state of each room key we have.
*
* Returns `Promise<void>`.
* @returns {Promise<any>}
*/
disableBackup() {
const ret = wasm.olmmachine_disableBackup(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Encrypt a batch of room keys and return a request that needs to be sent
* out to backup the room keys.
*
* Returns an optional {@link KeysBackupRequest}.
* @returns {Promise<any>}
*/
backupRoomKeys() {
const ret = wasm.olmmachine_backupRoomKeys(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Get the number of backed up room keys and the total number of room keys.
* Returns a {@link RoomKeyCounts}.
* @returns {Promise<any>}
*/
roomKeyCounts() {
const ret = wasm.olmmachine_roomKeyCounts(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Encrypt the list of exported room keys using the given passphrase.
*
* `exported_room_keys` is a list of sessions that should be encrypted
* (it's generally returned by `export_room_keys`). `passphrase` is the
* passphrase that will be used to encrypt the exported room keys. And
* `rounds` is the number of rounds that should be used for the key
* derivation when the passphrase gets turned into an AES key. More rounds
* are increasingly computationnally intensive and as such help against
* brute-force attacks. Should be at least `10_000`, while values in the
* `100_000` ranges should be preferred.
* @param {string} exported_room_keys
* @param {string} passphrase
* @param {number} rounds
* @returns {string}
*/
static encryptExportedRoomKeys(exported_room_keys, passphrase, rounds) {
let deferred4_0;
let deferred4_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(exported_room_keys, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ptr1 = passStringToWasm0(passphrase, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
wasm.olmmachine_encryptExportedRoomKeys(retptr, ptr0, len0, ptr1, len1, rounds);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
var ptr3 = r0;
var len3 = r1;
if (r3) {
ptr3 = 0; len3 = 0;
throw takeObject(r2);
}
deferred4_0 = ptr3;
deferred4_1 = len3;
return getStringFromWasm0(ptr3, len3);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
}
}
/**
* Try to decrypt a reader into a list of exported room keys.
*
* `encrypted_exported_room_keys` is the result from
* `encrypt_exported_room_keys`. `passphrase` is the passphrase that was
* used when calling `encrypt_exported_room_keys`.
* @param {string} encrypted_exported_room_keys
* @param {string} passphrase
* @returns {string}
*/
static decryptExportedRoomKeys(encrypted_exported_room_keys, passphrase) {
let deferred4_0;
let deferred4_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(encrypted_exported_room_keys, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ptr1 = passStringToWasm0(passphrase, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
wasm.olmmachine_decryptExportedRoomKeys(retptr, ptr0, len0, ptr1, len1);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
var ptr3 = r0;
var len3 = r1;
if (r3) {
ptr3 = 0; len3 = 0;
throw takeObject(r2);
}
deferred4_0 = ptr3;
deferred4_1 = len3;
return getStringFromWasm0(ptr3, len3);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
}
}
/**
* Register a callback which will be called whenever there is an update to
* a room key.
*
* `callback` should be a function that takes a single argument (an array
* of {@link RoomKeyInfo}) and returns a Promise.
* @param {Function} callback
* @returns {Promise<void>}
*/
registerRoomKeyUpdatedCallback(callback) {
const ret = wasm.olmmachine_registerRoomKeyUpdatedCallback(this.__wbg_ptr, addHeapObject(callback));
return takeObject(ret);
}
/**
* Register a callback which will be called whenever we receive a
* notification that some room keys have been withheld.
*
* `callback` should be a function that takes a single argument (an array
* of {@link RoomKeyWithheldInfo}) and returns a Promise.
* @param {Function} callback
* @returns {Promise<void>}
*/
registerRoomKeysWithheldCallback(callback) {
const ret = wasm.olmmachine_registerRoomKeysWithheldCallback(this.__wbg_ptr, addHeapObject(callback));
return takeObject(ret);
}
/**
* Register a callback which will be called whenever there is an update to
* a user identity.
*
* `callback` should be a function that takes a single argument (a {@link
* UserId}) and returns a Promise.
* @param {Function} callback
* @returns {Promise<void>}
*/
registerUserIdentityUpdatedCallback(callback) {
const ret = wasm.olmmachine_registerUserIdentityUpdatedCallback(this.__wbg_ptr, addHeapObject(callback));
return takeObject(ret);
}
/**
* Register a callback which will be called whenever there is an update to
* a device.
*
* `callback` should be a function that takes a single argument (an array
* of user IDs as strings) and returns a Promise.
* @param {Function} callback
* @returns {Promise<void>}
*/
registerDevicesUpdatedCallback(callback) {
const ret = wasm.olmmachine_registerDevicesUpdatedCallback(this.__wbg_ptr, addHeapObject(callback));
return takeObject(ret);
}
/**
* Register a callback which will be called whenever a secret
* (`m.secret.send`) is received.
*
* The only secret this will currently broadcast is the
* `m.megolm_backup.v1` (the cross signing secrets are handled internally).
*
* To request a secret from other devices, a client sends an
* `m.secret.request` device event with `action` set to `request` and
* `name` set to the identifier of the secret. A device that wishes to
* share the secret will reply with an `m.secret.send` event, encrypted
* using olm.
*
* The secrets are guaranteed to have been received over a 1-to-1 encrypted
* to_device message from a one of the user's own verified devices.
*
* See https://matrix-org.github.io/matrix-rust-sdk/matrix_sdk_crypto/store/struct.Store.html#method.secrets_stream for more information.
*
* `callback` should be a function that takes 2 arguments: the secret name
* (string) and value (string).
*
* **Note**: if the secret is valid and handled on the javascript side, the
* secret inbox should be cleared by calling
* `delete_secrets_from_inbox`.
* @param {Function} callback
* @returns {Promise<void>}
*/
registerReceiveSecretCallback(callback) {
const ret = wasm.olmmachine_registerReceiveSecretCallback(this.__wbg_ptr, addHeapObject(callback));
return takeObject(ret);
}
/**
* Get all the secrets with the given secret_name we have currently
* stored.
* The only secret this will currently return is the
* `m.megolm_backup.v1` secret.
*
* Usually you would just register a callback with
* [`register_receive_secret_callback`], but if the client is shut down
* before handling them, this method can be used to retrieve them.
* This method should therefore be called at client startup to retrieve any
* secrets received during the previous session.
*
* The secrets are guaranteed to have been received over a 1-to-1 encrypted
* to_device message from one of the user's own verified devices.
*
* Returns a `Promise` for a `Set` of `String` corresponding to the secret
* values.
*
* If the secret is valid and handled, the secret inbox should be cleared
* by calling `delete_secrets_from_inbox`.
* @param {string} secret_name
* @returns {Promise<Promise<any>>}
*/
getSecretsFromInbox(secret_name) {
const ptr0 = passStringToWasm0(secret_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ret = wasm.olmmachine_getSecretsFromInbox(this.__wbg_ptr, ptr0, len0);
return takeObject(ret);
}
/**
* Delete all secrets with the given secret name from the inbox.
*
* Should be called after handling the secrets with
* `get_secrets_from_inbox`.
*
* # Arguments
*
* * `secret_name` - The name of the secret to delete.
* @param {string} secret_name
* @returns {Promise<Promise<any>>}
*/
deleteSecretsFromInbox(secret_name) {
const ptr0 = passStringToWasm0(secret_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ret = wasm.olmmachine_deleteSecretsFromInbox(this.__wbg_ptr, ptr0, len0);
return takeObject(ret);
}
/**
* Request missing local secrets from our other trusted devices.
*
* "Local secrets" refers to secrets which can be shared between trusted
* devices, such as private cross-signing keys, and the megolm backup
* decryption key.
*
* This method will cause the sdk to generated outgoing secret requests
* (`m.secret.request`) to get the missing secrets. These requests will
* then be returned by a future call to {@link
* OlmMachine#outgoing_requests}.
*
* # Returns
*
* A `Promise` for a `bool` result, which will be true if secrets were
* missing, and a request was generated.
* @returns {Promise<Promise<any>>}
*/
requestMissingSecretsIfNeeded() {
const ret = wasm.olmmachine_requestMissingSecretsIfNeeded(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Get the stored room settings, such as the encryption algorithm or
* whether to encrypt only for trusted devices.
*
* These settings can be modified via {@link #setRoomSettings}.
*
* # Returns
*
* `Promise<RoomSettings|undefined>`
* @param {RoomId} room_id
* @returns {Promise<any>}
*/
getRoomSettings(room_id) {
_assertClass(room_id, RoomId);
const ret = wasm.olmmachine_getRoomSettings(this.__wbg_ptr, room_id.__wbg_ptr);
return takeObject(ret);
}
/**
* Store encryption settings for the given room.
*
* This method checks if the new settings are "safe" -- ie, that they do
* not represent a downgrade in encryption security from any previous
* settings. Attempts to downgrade security will result in an error.
*
* If the settings are valid, they will be persisted to the crypto store.
* These settings are not used directly by this library, but the saved
* settings can be retrieved via {@link #getRoomSettings}.
* @param {RoomId} room_id
* @param {RoomSettings} room_settings
* @returns {Promise<void>}
*/
setRoomSettings(room_id, room_settings) {
_assertClass(room_id, RoomId);
_assertClass(room_settings, RoomSettings);
const ret = wasm.olmmachine_setRoomSettings(this.__wbg_ptr, room_id.__wbg_ptr, room_settings.__wbg_ptr);
return takeObject(ret);
}
/**
* Manage dehydrated devices
* @returns {DehydratedDevices}
*/
dehydratedDevices() {
const ret = wasm.olmmachine_dehydratedDevices(this.__wbg_ptr);
return DehydratedDevices.__wrap(ret);
}
/**
* Shut down the `OlmMachine`.
*
* The `OlmMachine` cannot be used after this method has been called.
*
* All associated resources will be closed too, like IndexedDB
* connections.
*/
close() {
const ptr = this.__destroy_into_raw();
wasm.olmmachine_close(ptr);
}
}
module.exports.OlmMachine = OlmMachine;
const OutboundCreationResultFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_outboundcreationresult_free(ptr >>> 0, 1));
/**
* The result of an outbound ECIES channel establishment.
*/
class OutboundCreationResult {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(OutboundCreationResult.prototype);
obj.__wbg_ptr = ptr;
OutboundCreationResultFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
OutboundCreationResultFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_outboundcreationresult_free(ptr, 0);
}
/**
* The established ECIES channel.
* @returns {EstablishedEcies}
*/
get channel() {
const ret = wasm.__wbg_get_inboundcreationresult_channel(this.__wbg_ptr);
return EstablishedEcies.__wrap(ret);
}
/**
* The established ECIES channel.
* @param {EstablishedEcies} arg0
*/
set channel(arg0) {
_assertClass(arg0, EstablishedEcies);
var ptr0 = arg0.__destroy_into_raw();
wasm.__wbg_set_inboundcreationresult_channel(this.__wbg_ptr, ptr0);
}
/**
* The initial encrypted message.
* @returns {string}
*/
get initial_message() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.__wbg_get_backupsecretsbundle_key(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* The initial encrypted message.
* @param {string} arg0
*/
set initial_message(arg0) {
const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.__wbg_set_backupsecretsbundle_key(this.__wbg_ptr, ptr0, len0);
}
}
module.exports.OutboundCreationResult = OutboundCreationResult;
const OwnUserIdentityFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_ownuseridentity_free(ptr >>> 0, 1));
/**
* Struct representing a cross signing identity of a user.
*
* This is the user identity of a user that is our own.
*/
class OwnUserIdentity {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(OwnUserIdentity.prototype);
obj.__wbg_ptr = ptr;
OwnUserIdentityFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
OwnUserIdentityFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_ownuseridentity_free(ptr, 0);
}
/**
* Is this user identity verified?
* @returns {boolean}
*/
isVerified() {
const ret = wasm.ownuseridentity_isVerified(this.__wbg_ptr);
return ret !== 0;
}
/**
* Mark our user identity as verified.
*
* This will mark the identity locally as verified and sign it with our own
* device.
*
* Returns a signature upload request that needs to be sent out.
* @returns {Promise<any>}
*/
verify() {
const ret = wasm.ownuseridentity_verify(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Send a verification request to our other devices.
* @param {any[] | undefined} [methods]
* @returns {Promise<any>}
*/
requestVerification(methods) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
var ptr0 = isLikeNone(methods) ? 0 : passArrayJsValueToWasm0(methods, wasm.__wbindgen_malloc);
var len0 = WASM_VECTOR_LEN;
wasm.ownuseridentity_requestVerification(retptr, this.__wbg_ptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Does our user identity trust our own device, i.e. have we signed our own
* device keys with our self-signing key?
* @returns {Promise<any>}
*/
trustsOurOwnDevice() {
const ret = wasm.ownuseridentity_trustsOurOwnDevice(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Get the master key of the identity.
* @returns {string}
*/
get masterKey() {
let deferred2_0;
let deferred2_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ownuseridentity_masterKey(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
var ptr1 = r0;
var len1 = r1;
if (r3) {
ptr1 = 0; len1 = 0;
throw takeObject(r2);
}
deferred2_0 = ptr1;
deferred2_1 = len1;
return getStringFromWasm0(ptr1, len1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
}
}
/**
* Get the self-signing key of the identity.
* @returns {string}
*/
get selfSigningKey() {
let deferred2_0;
let deferred2_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ownuseridentity_selfSigningKey(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
var ptr1 = r0;
var len1 = r1;
if (r3) {
ptr1 = 0; len1 = 0;
throw takeObject(r2);
}
deferred2_0 = ptr1;
deferred2_1 = len1;
return getStringFromWasm0(ptr1, len1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
}
}
/**
* Get the user-signing key of the identity. This is only present for our
* own user identity.
* @returns {string}
*/
get userSigningKey() {
let deferred2_0;
let deferred2_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ownuseridentity_userSigningKey(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
var ptr1 = r0;
var len1 = r1;
if (r3) {
ptr1 = 0; len1 = 0;
throw takeObject(r2);
}
deferred2_0 = ptr1;
deferred2_1 = len1;
return getStringFromWasm0(ptr1, len1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
}
}
/**
* True if we verified our own identity at some point in the past.
*
* To reset this latch back to `false`, call {@link withdrawVerification}.
* @returns {boolean}
*/
wasPreviouslyVerified() {
const ret = wasm.ownuseridentity_wasPreviouslyVerified(this.__wbg_ptr);
return ret !== 0;
}
/**
* Remove the requirement for this identity to be verified.
*
* If an identity was previously verified and is not any longer, it will be
* reported to the user. In order to remove this notice users have to
* verify again or to withdraw the verification requirement.
* @returns {Promise<any>}
*/
withdrawVerification() {
const ret = wasm.ownuseridentity_withdrawVerification(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Was this identity verified since initial observation and is not anymore?
*
* Such a violation should be reported to the local user by the
* application, and resolved by
*
* - Verifying the new identity with {@link requestVerification}, or:
* - Withdrawing the verification requirement with {@link
* withdrawVerification}.
* @returns {boolean}
*/
hasVerificationViolation() {
const ret = wasm.ownuseridentity_hasVerificationViolation(this.__wbg_ptr);
return ret !== 0;
}
}
module.exports.OwnUserIdentity = OwnUserIdentity;
const PickledInboundGroupSessionFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_pickledinboundgroupsession_free(ptr >>> 0, 1));
/**
* A pickled version of an `InboundGroupSession`.
*
* Holds all the information that needs to be stored in a database to restore
* an InboundGroupSession.
*/
class PickledInboundGroupSession {
static __unwrap(jsValue) {
if (!(jsValue instanceof PickledInboundGroupSession)) {
return 0;
}
return jsValue.__destroy_into_raw();
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
PickledInboundGroupSessionFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_pickledinboundgroupsession_free(ptr, 0);
}
/**
* The pickle string holding the Megolm Session, as returned by
* `olm_pickle_inbound_group_session` in libolm.
* @returns {string}
*/
get pickle() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.__wbg_get_pickledinboundgroupsession_pickle(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* The pickle string holding the Megolm Session, as returned by
* `olm_pickle_inbound_group_session` in libolm.
* @param {string} arg0
*/
set pickle(arg0) {
const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.__wbg_set_pickledinboundgroupsession_pickle(this.__wbg_ptr, ptr0, len0);
}
/**
* The public curve25519 key of the account that sent us the session.
* @returns {string}
*/
get senderKey() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.__wbg_get_pickledinboundgroupsession_senderKey(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* The public curve25519 key of the account that sent us the session.
* @param {string} arg0
*/
set senderKey(arg0) {
const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.__wbg_set_pickledinboundgroupsession_senderKey(this.__wbg_ptr, ptr0, len0);
}
/**
* The public ed25519 key of the account that is believed to have initiated
* the session, if known.
*
* If the session was received directly from the creator via an
* Olm-encrypted `m.room_key` event, this value is taken from the `keys`
* property of the plaintext payload of that event (see
* [`m.olm.v1.curve25519-aes-sha2`]).
*
* If the session was forwarded to us using an [`m.forwarded_room_key`],
* this value is a copy of the `sender_claimed_ed25519_key` from the
* content of the event.
*
* [`m.olm.v1.curve25519-aes-sha2`]: https://spec.matrix.org/v1.9/client-server-api/#molmv1curve25519-aes-sha2
* @returns {string | undefined}
*/
get senderSigningKey() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.__wbg_get_pickledinboundgroupsession_senderSigningKey(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
let v1;
if (r0 !== 0) {
v1 = getStringFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
}
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* The public ed25519 key of the account that is believed to have initiated
* the session, if known.
*
* If the session was received directly from the creator via an
* Olm-encrypted `m.room_key` event, this value is taken from the `keys`
* property of the plaintext payload of that event (see
* [`m.olm.v1.curve25519-aes-sha2`]).
*
* If the session was forwarded to us using an [`m.forwarded_room_key`],
* this value is a copy of the `sender_claimed_ed25519_key` from the
* content of the event.
*
* [`m.olm.v1.curve25519-aes-sha2`]: https://spec.matrix.org/v1.9/client-server-api/#molmv1curve25519-aes-sha2
* @param {string | undefined} [arg0]
*/
set senderSigningKey(arg0) {
var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
var len0 = WASM_VECTOR_LEN;
wasm.__wbg_set_pickledinboundgroupsession_senderSigningKey(this.__wbg_ptr, ptr0, len0);
}
/**
* The id of the room that the session is used in.
*
* Nullable so that a `PickledInboundGroupSession` can be constructed
* incrementally. Must be populated!
* @returns {RoomId | undefined}
*/
get roomId() {
const ret = wasm.__wbg_get_pickledinboundgroupsession_roomId(this.__wbg_ptr);
return ret === 0 ? undefined : RoomId.__wrap(ret);
}
/**
* The id of the room that the session is used in.
*
* Nullable so that a `PickledInboundGroupSession` can be constructed
* incrementally. Must be populated!
* @param {RoomId | undefined} [arg0]
*/
set roomId(arg0) {
let ptr0 = 0;
if (!isLikeNone(arg0)) {
_assertClass(arg0, RoomId);
ptr0 = arg0.__destroy_into_raw();
}
wasm.__wbg_set_pickledinboundgroupsession_roomId(this.__wbg_ptr, ptr0);
}
/**
* Flag remembering if the session was directly sent to us by the sender
* or if it was imported.
* @returns {boolean}
*/
get imported() {
const ret = wasm.__wbg_get_pickledinboundgroupsession_imported(this.__wbg_ptr);
return ret !== 0;
}
/**
* Flag remembering if the session was directly sent to us by the sender
* or if it was imported.
* @param {boolean} arg0
*/
set imported(arg0) {
wasm.__wbg_set_pickledinboundgroupsession_imported(this.__wbg_ptr, arg0);
}
/**
* Flag remembering if the session has been backed up.
* @returns {boolean}
*/
get backedUp() {
const ret = wasm.__wbg_get_pickledinboundgroupsession_backedUp(this.__wbg_ptr);
return ret !== 0;
}
/**
* Flag remembering if the session has been backed up.
* @param {boolean} arg0
*/
set backedUp(arg0) {
wasm.__wbg_set_pickledinboundgroupsession_backedUp(this.__wbg_ptr, arg0);
}
/**
* Construct a new `PickledInboundGroupSession`, with default values.
*/
constructor() {
const ret = wasm.pickledinboundgroupsession_new();
this.__wbg_ptr = ret >>> 0;
PickledInboundGroupSessionFinalization.register(this, this.__wbg_ptr, this);
return this;
}
}
module.exports.PickledInboundGroupSession = PickledInboundGroupSession;
const PickledSessionFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_pickledsession_free(ptr >>> 0, 1));
/**
* A pickled version of a `Session`.
*
* Holds all the information that needs to be stored in a database to restore
* an Olm Session. Can be imported into the rust store with {@link
* #migrateOlmSessions}.
*/
class PickledSession {
static __unwrap(jsValue) {
if (!(jsValue instanceof PickledSession)) {
return 0;
}
return jsValue.__destroy_into_raw();
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
PickledSessionFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_pickledsession_free(ptr, 0);
}
/**
* The pickle string holding the Olm Session, as returned by
* `olm_pickle_session` in libolm.
* @returns {string}
*/
get pickle() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.__wbg_get_pickledsession_pickle(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* The pickle string holding the Olm Session, as returned by
* `olm_pickle_session` in libolm.
* @param {string} arg0
*/
set pickle(arg0) {
const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.__wbg_set_pickledsession_pickle(this.__wbg_ptr, ptr0, len0);
}
/**
* The base64-encoded public curve25519 key of the other user that we share
* this session with.
* @returns {string}
*/
get senderKey() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.__wbg_get_pickledsession_senderKey(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* The base64-encoded public curve25519 key of the other user that we share
* this session with.
* @param {string} arg0
*/
set senderKey(arg0) {
const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.__wbg_set_pickledsession_senderKey(this.__wbg_ptr, ptr0, len0);
}
/**
* Was the session created using a fallback key?
* @returns {boolean}
*/
get createdUsingFallbackKey() {
const ret = wasm.__wbg_get_pickledsession_createdUsingFallbackKey(this.__wbg_ptr);
return ret !== 0;
}
/**
* Was the session created using a fallback key?
* @param {boolean} arg0
*/
set createdUsingFallbackKey(arg0) {
wasm.__wbg_set_pickledsession_createdUsingFallbackKey(this.__wbg_ptr, arg0);
}
/**
* When the session was created.
* @returns {Date}
*/
get creationTime() {
const ret = wasm.__wbg_get_pickledsession_creationTime(this.__wbg_ptr);
return takeObject(ret);
}
/**
* When the session was created.
* @param {Date} arg0
*/
set creationTime(arg0) {
wasm.__wbg_set_pickledsession_creationTime(this.__wbg_ptr, addHeapObject(arg0));
}
/**
* When the session was last used.
* @returns {Date}
*/
get lastUseTime() {
const ret = wasm.__wbg_get_pickledsession_lastUseTime(this.__wbg_ptr);
return takeObject(ret);
}
/**
* When the session was last used.
* @param {Date} arg0
*/
set lastUseTime(arg0) {
wasm.__wbg_set_pickledsession_lastUseTime(this.__wbg_ptr, addHeapObject(arg0));
}
/**
* Construct a new `PickledSession`, with default values.
*/
constructor() {
const ret = wasm.pickledsession_new();
this.__wbg_ptr = ret >>> 0;
PickledSessionFinalization.register(this, this.__wbg_ptr, this);
return this;
}
}
module.exports.PickledSession = PickledSession;
const PutDehydratedDeviceRequestFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_putdehydrateddevicerequest_free(ptr >>> 0, 1));
/**
* A request that will upload a dehydrated device to the server.
*/
class PutDehydratedDeviceRequest {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(PutDehydratedDeviceRequest.prototype);
obj.__wbg_ptr = ptr;
PutDehydratedDeviceRequestFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
PutDehydratedDeviceRequestFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_putdehydrateddevicerequest_free(ptr, 0);
}
/**
* A JSON-encoded string containing the rest of the payload: `rooms`.
*
* It represents the body of the HTTP request.
* @returns {string}
*/
get body() {
const ret = wasm.__wbg_get_putdehydrateddevicerequest_body(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Create a new `PutDehydratedDeviceRequest`
* @param {string} body
*/
constructor(body) {
const ret = wasm.putdehydrateddevicerequest_new(addHeapObject(body));
this.__wbg_ptr = ret >>> 0;
PutDehydratedDeviceRequestFinalization.register(this, this.__wbg_ptr, this);
return this;
}
}
module.exports.PutDehydratedDeviceRequest = PutDehydratedDeviceRequest;
const QrFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_qr_free(ptr >>> 0, 1));
/**
* QR code based verification.
*/
class Qr {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(Qr.prototype);
obj.__wbg_ptr = ptr;
QrFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
QrFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_qr_free(ptr, 0);
}
/**
* Get the current state of this request.
*
* Returns a `QrState`.
* @returns {QrState}
*/
state() {
const ret = wasm.qr_state(this.__wbg_ptr);
return ret;
}
/**
* Has the QR verification been scanned by the other side.
*
* When the verification object is in this state it’s required
* that the user confirms that the other side has scanned the QR
* code.
* @returns {boolean}
*/
hasBeenScanned() {
const ret = wasm.qr_hasBeenScanned(this.__wbg_ptr);
return ret !== 0;
}
/**
* Has the scanning of the QR code been confirmed by us?
* @returns {boolean}
*/
hasBeenConfirmed() {
const ret = wasm.qr_hasBeenConfirmed(this.__wbg_ptr);
return ret !== 0;
}
/**
* Get our own user ID.
* @returns {UserId}
*/
get userId() {
const ret = wasm.qr_userId(this.__wbg_ptr);
return UserId.__wrap(ret);
}
/**
* Get the user id of the other user that is participating in
* this verification flow.
* @returns {UserId}
*/
get otherUserId() {
const ret = wasm.qr_otherUserId(this.__wbg_ptr);
return UserId.__wrap(ret);
}
/**
* Get the device ID of the other side.
* @returns {DeviceId}
*/
get otherDeviceId() {
const ret = wasm.qr_otherDeviceId(this.__wbg_ptr);
return DeviceId.__wrap(ret);
}
/**
* Did we initiate the verification request?
* @returns {boolean}
*/
weStarted() {
const ret = wasm.qr_weStarted(this.__wbg_ptr);
return ret !== 0;
}
/**
* Get info about the cancellation if the verification flow has
* been cancelled.
* @returns {CancelInfo | undefined}
*/
cancelInfo() {
const ret = wasm.qr_cancelInfo(this.__wbg_ptr);
return ret === 0 ? undefined : CancelInfo.__wrap(ret);
}
/**
* Has the verification flow completed?
* @returns {boolean}
*/
isDone() {
const ret = wasm.qr_isDone(this.__wbg_ptr);
return ret !== 0;
}
/**
* Has the verification flow been cancelled?
* @returns {boolean}
*/
isCancelled() {
const ret = wasm.qr_isCancelled(this.__wbg_ptr);
return ret !== 0;
}
/**
* Is this a verification that is verifying one of our own devices?
* @returns {boolean}
*/
isSelfVerification() {
const ret = wasm.qr_isSelfVerification(this.__wbg_ptr);
return ret !== 0;
}
/**
* Have we successfully scanned the QR code and are able to send
* a reciprocation event?
* @returns {boolean}
*/
reciprocated() {
const ret = wasm.qr_reciprocated(this.__wbg_ptr);
return ret !== 0;
}
/**
* Get the unique ID that identifies this QR verification flow,
* be either a to-device request ID or a room event ID.
* @returns {string}
*/
get flowId() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.qr_flowId(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* Get the room id if the verification is happening inside a
* room.
* @returns {RoomId | undefined}
*/
get roomId() {
const ret = wasm.qr_roomId(this.__wbg_ptr);
return ret === 0 ? undefined : RoomId.__wrap(ret);
}
/**
* Generate a QR code object that is representing this
* verification flow.
*
* The QrCode can then be rendered as an image or as an unicode
* string.
*
* The `to_bytes` method can be used to instead output the raw
* bytes that should be encoded as a QR code.
*
* Returns a `QrCode`.
* @returns {QrCode}
*/
toQrCode() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.qr_toQrCode(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return QrCode.__wrap(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Generate a the raw bytes that should be encoded as a QR code
* is representing this verification flow.
*
* The `to_qr_code` method can be used to instead output a QrCode
* object that can be rendered.
* @returns {Uint8ClampedArray}
*/
toBytes() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.qr_toBytes(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Notify the other side that we have successfully scanned the QR
* code and that the QR verification flow can start.
*
* This will return some OutgoingContent if the object is in the
* correct state to start the verification flow, otherwise None.
* @returns {any}
*/
reciprocate() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.qr_reciprocate(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Confirm that the other side has scanned our QR code.
*
* Returns either an `OutgoingRequest` which should be sent out, or
* `undefined` if the verification is already confirmed.
* @returns {any}
*/
confirmScanning() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.qr_confirmScanning(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Cancel the verification flow.
*
* Returns either an `OutgoingRequest` which should be sent out, or
* `undefined` if the verification is already cancelled.
* @returns {any}
*/
cancel() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.qr_cancel(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Cancel the verification.
*
* This cancels the verification with given code (e.g. `m.user`).
*
* Returns either an `OutgoingRequest` which should be sent out, or
* `undefined` if the verification is already cancelled.
* @param {string} code
* @returns {any}
*/
cancelWithCode(code) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.qr_cancelWithCode(retptr, this.__wbg_ptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Register a callback which will be called whenever there is an update to
* the request
*
* The `callback` is called with no parameters.
* @param {Function} callback
*/
registerChangesCallback(callback) {
wasm.qr_registerChangesCallback(this.__wbg_ptr, addHeapObject(callback));
}
}
module.exports.Qr = Qr;
const QrCodeFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_qrcode_free(ptr >>> 0, 1));
/**
* A QR code.
*/
class QrCode {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(QrCode.prototype);
obj.__wbg_ptr = ptr;
QrCodeFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
QrCodeFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_qrcode_free(ptr, 0);
}
/**
* Render the QR code into a `Uint8ClampedArray` where 1 represents a
* dark pixel and 0 a white pixel.
* @returns {Uint8ClampedArray}
*/
renderIntoBuffer() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.qrcode_renderIntoBuffer(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
}
module.exports.QrCode = QrCode;
const QrCodeDataFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_qrcodedata_free(ptr >>> 0, 1));
/**
* Data for the QR code login mechanism.
*
* The {@link QrCodeData} can be serialized and encoded as a QR code or it can
* be decoded from a QR code.
*/
class QrCodeData {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(QrCodeData.prototype);
obj.__wbg_ptr = ptr;
QrCodeDataFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
QrCodeDataFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_qrcodedata_free(ptr, 0);
}
/**
* Create new {@link QrCodeData} from a given public key, a rendezvous URL
* and, optionally, a server name for the homeserver.
*
* If a server name is given, then the {@link QrCodeData} mode will be
* {@link QrCodeMode.Reciprocate}, i.e. the QR code will contain data for
* the existing device to display the QR code.
*
* If no server name is given, the {@link QrCodeData} mode will be
* {@link QrCodeMode.Login}, i.e. the QR code will contain data for the
* new device to display the QR code.
* @param {Curve25519PublicKey} public_key
* @param {string} rendezvous_url
* @param {string | undefined} [server_name]
*/
constructor(public_key, rendezvous_url, server_name) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
_assertClass(public_key, Curve25519PublicKey);
var ptr0 = public_key.__destroy_into_raw();
const ptr1 = passStringToWasm0(rendezvous_url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
var ptr2 = isLikeNone(server_name) ? 0 : passStringToWasm0(server_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
var len2 = WASM_VECTOR_LEN;
wasm.qrcodedata_new(retptr, ptr0, ptr1, len1, ptr2, len2);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
this.__wbg_ptr = r0 >>> 0;
QrCodeDataFinalization.register(this, this.__wbg_ptr, this);
return this;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Attempt to decode a slice of bytes into a {@link QrCodeData} object.
*
* The slice of bytes would generally be returned by a QR code decoder.
* @param {Uint8Array} bytes
* @returns {QrCodeData}
*/
static fromBytes(bytes) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
wasm.qrcodedata_fromBytes(retptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return QrCodeData.__wrap(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Encode the {@link QrCodeData} into a list of bytes.
*
* The list of bytes can be used by a QR code generator to create an image
* containing a QR code.
* @returns {Uint8Array}
*/
toBytes() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.qrcodedata_toBytes(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var v1 = getArrayU8FromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Attempt to decode a base64 encoded string into a {@link QrCodeData}
* object.
* @param {string} data
* @returns {QrCodeData}
*/
static fromBase64(data) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.qrcodedata_fromBase64(retptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return QrCodeData.__wrap(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Encode the {@link QrCodeData} into a string using base64.
*
* This format can be used for debugging purposes and the
* [`QrcodeData::from_base64()`] method can be used to parse the string
* again.
* @returns {string}
*/
toBase64() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.qrcodedata_toBase64(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* Get the Curve25519 public key embedded in the {@link QrCodeData}.
*
* This Curve25519 public key should be used to establish an
* (Elliptic Curve Integrated Encryption Scheme) channel with the other
* device.
* @returns {Curve25519PublicKey}
*/
get publicKey() {
const ret = wasm.qrcodedata_publicKey(this.__wbg_ptr);
return Curve25519PublicKey.__wrap(ret);
}
/**
* Get the URL of the rendezvous server which will be used to exchange
* messages between the two devices.
* @returns {string}
*/
get rendezvousUrl() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.qrcodedata_rendezvousUrl(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* Get the server name of the homeserver which the new device will be
* logged in to.
*
* This will be only available if the existing device has generated the QR
* code and the new device is the one scanning the QR code.
* @returns {string | undefined}
*/
get serverName() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.qrcodedata_serverName(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
let v1;
if (r0 !== 0) {
v1 = getStringFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
}
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Get the mode of this {@link QrCodeData} instance.
* @returns {QrCodeMode}
*/
get mode() {
const ret = wasm.qrcodedata_mode(this.__wbg_ptr);
return ret;
}
}
module.exports.QrCodeData = QrCodeData;
const QrCodeScanFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_qrcodescan_free(ptr >>> 0, 1));
/**
* A scanned QR code.
*/
class QrCodeScan {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(QrCodeScan.prototype);
obj.__wbg_ptr = ptr;
QrCodeScanFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
QrCodeScanFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_qrcodescan_free(ptr, 0);
}
/**
* Parse the decoded payload of a QR code in byte slice form.
*
* This method is useful if you would like to do your own custom QR code
* decoding.
* @param {Uint8ClampedArray} buffer
* @returns {QrCodeScan}
*/
static fromBytes(buffer) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.qrcodescan_fromBytes(retptr, addBorrowedObject(buffer));
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return QrCodeScan.__wrap(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
heap[stack_pointer++] = undefined;
}
}
}
module.exports.QrCodeScan = QrCodeScan;
const RehydratedDeviceFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_rehydrateddevice_free(ptr >>> 0, 1));
/**
* A rehydrated device
*
* This device can receive to-device events to get room keys that were send to
* it.
*/
class RehydratedDevice {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(RehydratedDevice.prototype);
obj.__wbg_ptr = ptr;
RehydratedDeviceFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
RehydratedDeviceFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_rehydrateddevice_free(ptr, 0);
}
/**
* Receive the to-device events that sent to the dehydrated device
*
* The rehydrated device will decrypt the events and pass the room keys
* into the `OlmMachine`.
*
* `to_device_events` is a JSON-encoded result of the `events` array from
* `/dehydrated_device/{device_id}/events`.
*
* Returns an array of `RoomKeyInfo`, indicating the room keys that were
* received.
* @param {string} to_device_events
* @returns {Promise<Array<any>>}
*/
receiveEvents(to_device_events) {
const ptr0 = passStringToWasm0(to_device_events, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ret = wasm.rehydrateddevice_receiveEvents(this.__wbg_ptr, ptr0, len0);
return takeObject(ret);
}
}
module.exports.RehydratedDevice = RehydratedDevice;
const RoomIdFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_roomid_free(ptr >>> 0, 1));
/**
* A Matrix [room ID].
*
*/
class RoomId {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(RoomId.prototype);
obj.__wbg_ptr = ptr;
RoomIdFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
static __unwrap(jsValue) {
if (!(jsValue instanceof RoomId)) {
return 0;
}
return jsValue.__destroy_into_raw();
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
RoomIdFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_roomid_free(ptr, 0);
}
/**
* Parse/validate and create a new `RoomId`.
* @param {string} id
*/
constructor(id) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.roomid_new(retptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
this.__wbg_ptr = r0 >>> 0;
RoomIdFinalization.register(this, this.__wbg_ptr, this);
return this;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Return the room ID as a string.
* @returns {string}
*/
toString() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.roomid_toString(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
}
module.exports.RoomId = RoomId;
const RoomKeyCountsFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_roomkeycounts_free(ptr >>> 0, 1));
/**
* Struct holding the number of room keys we have.
*/
class RoomKeyCounts {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(RoomKeyCounts.prototype);
obj.__wbg_ptr = ptr;
RoomKeyCountsFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
RoomKeyCountsFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_roomkeycounts_free(ptr, 0);
}
/**
* The total number of room keys.
* @returns {number}
*/
get total() {
const ret = wasm.__wbg_get_roomkeycounts_total(this.__wbg_ptr);
return ret;
}
/**
* The total number of room keys.
* @param {number} arg0
*/
set total(arg0) {
wasm.__wbg_set_roomkeycounts_total(this.__wbg_ptr, arg0);
}
/**
* The number of backed up room keys.
* @returns {number}
*/
get backedUp() {
const ret = wasm.__wbg_get_roomkeycounts_backedUp(this.__wbg_ptr);
return ret;
}
/**
* The number of backed up room keys.
* @param {number} arg0
*/
set backedUp(arg0) {
wasm.__wbg_set_roomkeycounts_backedUp(this.__wbg_ptr, arg0);
}
}
module.exports.RoomKeyCounts = RoomKeyCounts;
const RoomKeyImportResultFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_roomkeyimportresult_free(ptr >>> 0, 1));
/**
* The result of a call to {@link OlmMachine.importExportedRoomKeys} or
* {@link OlmMachine.importBackedUpRoomKeys}.
*/
class RoomKeyImportResult {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(RoomKeyImportResult.prototype);
obj.__wbg_ptr = ptr;
RoomKeyImportResultFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
RoomKeyImportResultFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_roomkeyimportresult_free(ptr, 0);
}
/**
* The number of room keys that were imported.
* @returns {number}
*/
get importedCount() {
const ret = wasm.__wbg_get_roomkeyimportresult_importedCount(this.__wbg_ptr);
return ret >>> 0;
}
/**
* The total number of room keys that were found in the export.
* @returns {number}
*/
get totalCount() {
const ret = wasm.__wbg_get_roomkeyimportresult_totalCount(this.__wbg_ptr);
return ret >>> 0;
}
/**
* The keys that were imported.
*
* A Map from room id to a Map of the sender key to a Set of session ids.
*
* Typescript type: `Map<string, Map<string, Set<string>>`.
* @returns {Map<any, any>}
*/
keys() {
const ret = wasm.roomkeyimportresult_keys(this.__wbg_ptr);
return takeObject(ret);
}
}
module.exports.RoomKeyImportResult = RoomKeyImportResult;
const RoomKeyInfoFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_roomkeyinfo_free(ptr >>> 0, 1));
/**
* Information on a room key that has been received or imported.
*/
class RoomKeyInfo {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(RoomKeyInfo.prototype);
obj.__wbg_ptr = ptr;
RoomKeyInfoFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
RoomKeyInfoFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_roomkeyinfo_free(ptr, 0);
}
/**
* The {@link EncryptionAlgorithm} that this key is used for. Will be one
* of the `m.megolm.*` algorithms.
* @returns {EncryptionAlgorithm}
*/
get algorithm() {
const ret = wasm.roomkeyinfo_algorithm(this.__wbg_ptr);
return ret;
}
/**
* The room where the key is used.
* @returns {RoomId}
*/
get roomId() {
const ret = wasm.roomkeyinfo_roomId(this.__wbg_ptr);
return RoomId.__wrap(ret);
}
/**
* The Curve25519 key of the device which initiated the session originally.
* @returns {Curve25519PublicKey}
*/
get senderKey() {
const ret = wasm.roomkeyinfo_senderKey(this.__wbg_ptr);
return Curve25519PublicKey.__wrap(ret);
}
/**
* The ID of the session that the key is for.
* @returns {string}
*/
get sessionId() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.roomkeyinfo_sessionId(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
}
module.exports.RoomKeyInfo = RoomKeyInfo;
const RoomKeyWithheldInfoFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_roomkeywithheldinfo_free(ptr >>> 0, 1));
/**
* Information on a received `m.room_key.withheld` event.
*/
class RoomKeyWithheldInfo {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(RoomKeyWithheldInfo.prototype);
obj.__wbg_ptr = ptr;
RoomKeyWithheldInfoFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
RoomKeyWithheldInfoFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_roomkeywithheldinfo_free(ptr, 0);
}
/**
* The User ID of the user that sent us the `m.room_key.withheld` message.
* @returns {UserId}
*/
get sender() {
const ret = wasm.roomkeywithheldinfo_sender(this.__wbg_ptr);
return UserId.__wrap(ret);
}
/**
* The encryption algorithm of the session that is being withheld.
* @returns {EncryptionAlgorithm}
*/
get algorithm() {
const ret = wasm.roomkeywithheldinfo_algorithm(this.__wbg_ptr);
return ret;
}
/**
* The `code` from the `m.room_key.withheld` message, such as
* `m.unverified`.
* @returns {string}
*/
get withheldCode() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.roomkeywithheldinfo_withheldCode(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* The room ID of the session that is being withheld.
* @returns {RoomId}
*/
get roomId() {
const ret = wasm.roomkeywithheldinfo_roomId(this.__wbg_ptr);
return RoomId.__wrap(ret);
}
/**
* The session ID of the session that is being withheld.
* @returns {string}
*/
get sessionId() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.roomkeywithheldinfo_sessionId(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
}
module.exports.RoomKeyWithheldInfo = RoomKeyWithheldInfo;
const RoomMessageRequestFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_roommessagerequest_free(ptr >>> 0, 1));
/**
* A customized owned request type for sending out room messages
* ([specification]).
*
* [specification]: https://spec.matrix.org/unstable/client-server-api/#put_matrixclientv3roomsroomidsendeventtypetxnid
*/
class RoomMessageRequest {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(RoomMessageRequest.prototype);
obj.__wbg_ptr = ptr;
RoomMessageRequestFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
RoomMessageRequestFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_roommessagerequest_free(ptr, 0);
}
/**
* The request ID.
* @returns {string}
*/
get id() {
const ret = wasm.__wbg_get_roommessagerequest_id(this.__wbg_ptr);
return takeObject(ret);
}
/**
* A string representing the room to send the event to.
* @returns {string}
*/
get room_id() {
const ret = wasm.__wbg_get_roommessagerequest_room_id(this.__wbg_ptr);
return takeObject(ret);
}
/**
* A string representing the transaction ID for this event.
*
* Clients should generate an ID unique across requests with the same
* access token; it will be used by the server to ensure idempotency of
* requests.
* @returns {string}
*/
get txn_id() {
const ret = wasm.__wbg_get_roommessagerequest_txn_id(this.__wbg_ptr);
return takeObject(ret);
}
/**
* A string representing the type of event to be sent.
* @returns {string}
*/
get event_type() {
const ret = wasm.__wbg_get_roommessagerequest_event_type(this.__wbg_ptr);
return takeObject(ret);
}
/**
* A JSON-encoded string containing the message's content.
* @returns {string}
*/
get body() {
const ret = wasm.__wbg_get_roommessagerequest_body(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Create a new `RoomMessageRequest`.
* @param {string} id
* @param {string} room_id
* @param {string} txn_id
* @param {string} event_type
* @param {string} content
*/
constructor(id, room_id, txn_id, event_type, content) {
const ret = wasm.roommessagerequest_new(addHeapObject(id), addHeapObject(room_id), addHeapObject(txn_id), addHeapObject(event_type), addHeapObject(content));
this.__wbg_ptr = ret >>> 0;
RoomMessageRequestFinalization.register(this, this.__wbg_ptr, this);
return this;
}
/**
* Get its request type.
* @returns {RequestType}
*/
get type() {
const ret = wasm.roommessagerequest_type(this.__wbg_ptr);
return ret;
}
}
module.exports.RoomMessageRequest = RoomMessageRequest;
const RoomSettingsFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_roomsettings_free(ptr >>> 0, 1));
/**
* Room encryption settings which are modified by state events or user options
*/
class RoomSettings {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(RoomSettings.prototype);
obj.__wbg_ptr = ptr;
RoomSettingsFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
RoomSettingsFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_roomsettings_free(ptr, 0);
}
/**
* The encryption algorithm that should be used in the room.
*
* Should be one of the members of {@link EncryptionAlgorithm}.
* @returns {EncryptionAlgorithm}
*/
get algorithm() {
const ret = wasm.__wbg_get_roomsettings_algorithm(this.__wbg_ptr);
return ret;
}
/**
* The encryption algorithm that should be used in the room.
*
* Should be one of the members of {@link EncryptionAlgorithm}.
* @param {EncryptionAlgorithm} arg0
*/
set algorithm(arg0) {
wasm.__wbg_set_roomsettings_algorithm(this.__wbg_ptr, arg0);
}
/**
* Whether untrusted devices should receive room keys. If this is `false`,
* they will be excluded from the conversation.
* @returns {boolean}
*/
get onlyAllowTrustedDevices() {
const ret = wasm.__wbg_get_roomsettings_onlyAllowTrustedDevices(this.__wbg_ptr);
return ret !== 0;
}
/**
* Whether untrusted devices should receive room keys. If this is `false`,
* they will be excluded from the conversation.
* @param {boolean} arg0
*/
set onlyAllowTrustedDevices(arg0) {
wasm.__wbg_set_roomsettings_onlyAllowTrustedDevices(this.__wbg_ptr, arg0);
}
/**
* The maximum time, in milliseconds, that an encryption session should be
* used for, before it is rotated.
* @returns {number | undefined}
*/
get sessionRotationPeriodMs() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.__wbg_get_roomsettings_sessionRotationPeriodMs(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
return r0 === 0 ? undefined : r2;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* The maximum time, in milliseconds, that an encryption session should be
* used for, before it is rotated.
* @param {number | undefined} [arg0]
*/
set sessionRotationPeriodMs(arg0) {
wasm.__wbg_set_roomsettings_sessionRotationPeriodMs(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? 0 : arg0);
}
/**
* The maximum number of messages an encryption session should be used for,
* before it is rotated.
* @returns {number | undefined}
*/
get sessionRotationPeriodMessages() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.__wbg_get_roomsettings_sessionRotationPeriodMessages(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
return r0 === 0 ? undefined : r2;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* The maximum number of messages an encryption session should be used for,
* before it is rotated.
* @param {number | undefined} [arg0]
*/
set sessionRotationPeriodMessages(arg0) {
wasm.__wbg_set_roomsettings_sessionRotationPeriodMessages(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? 0 : arg0);
}
/**
* Create a new `RoomSettings` with default values.
*/
constructor() {
const ret = wasm.roomsettings_new();
this.__wbg_ptr = ret >>> 0;
RoomSettingsFinalization.register(this, this.__wbg_ptr, this);
return this;
}
}
module.exports.RoomSettings = RoomSettings;
const SasFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_sas_free(ptr >>> 0, 1));
/**
* Short Authentication String (SAS) verification.
*/
class Sas {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(Sas.prototype);
obj.__wbg_ptr = ptr;
SasFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
SasFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_sas_free(ptr, 0);
}
/**
* Get our own user ID.
* @returns {UserId}
*/
get userId() {
const ret = wasm.sas_userId(this.__wbg_ptr);
return UserId.__wrap(ret);
}
/**
* Get our own device ID.
* @returns {DeviceId}
*/
get deviceId() {
const ret = wasm.sas_deviceId(this.__wbg_ptr);
return DeviceId.__wrap(ret);
}
/**
* Get the user id of the other side.
* @returns {UserId}
*/
get otherUserId() {
const ret = wasm.sas_otherUserId(this.__wbg_ptr);
return UserId.__wrap(ret);
}
/**
* Get the device ID of the other side.
* @returns {DeviceId}
*/
get otherDeviceId() {
const ret = wasm.sas_otherDeviceId(this.__wbg_ptr);
return DeviceId.__wrap(ret);
}
/**
* Get the unique ID that identifies this SAS verification flow,
* be either a to-device request ID or a room event ID.
* @returns {string}
*/
get flowId() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.sas_flowId(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* Get the room ID if the verification is happening inside a
* room.
* @returns {RoomId | undefined}
*/
get roomId() {
const ret = wasm.sas_roomId(this.__wbg_ptr);
return ret === 0 ? undefined : RoomId.__wrap(ret);
}
/**
* Does this verification flow support displaying emoji for the
* short authentication string?
* @returns {boolean}
*/
supportsEmoji() {
const ret = wasm.sas_supportsEmoji(this.__wbg_ptr);
return ret !== 0;
}
/**
* Did this verification flow start from a verification request?
* @returns {boolean}
*/
startedFromRequest() {
const ret = wasm.sas_startedFromRequest(this.__wbg_ptr);
return ret !== 0;
}
/**
* Is this a verification that is verifying one of our own
* devices?
* @returns {boolean}
*/
isSelfVerification() {
const ret = wasm.sas_isSelfVerification(this.__wbg_ptr);
return ret !== 0;
}
/**
* Have we confirmed that the short auth string matches?
* @returns {boolean}
*/
haveWeConfirmed() {
const ret = wasm.sas_haveWeConfirmed(this.__wbg_ptr);
return ret !== 0;
}
/**
* Has the verification been accepted by both parties?
* @returns {boolean}
*/
hasBeenAccepted() {
const ret = wasm.sas_hasBeenAccepted(this.__wbg_ptr);
return ret !== 0;
}
/**
* Get info about the cancellation if the verification flow has
* been cancelled.
* @returns {CancelInfo | undefined}
*/
cancelInfo() {
const ret = wasm.sas_cancelInfo(this.__wbg_ptr);
return ret === 0 ? undefined : CancelInfo.__wrap(ret);
}
/**
* True if we initiated the verification flow (ie, we sent the
* `m.key.verification.request`).
* @returns {boolean}
*/
weStarted() {
const ret = wasm.sas_weStarted(this.__wbg_ptr);
return ret !== 0;
}
/**
* Accept the SAS verification.
*
* This does nothing (and returns `undefined`) if the verification was
* already accepted, otherwise it returns an `OutgoingRequest`
* that needs to be sent out.
* @returns {any}
*/
accept() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.sas_accept(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Confirm the SAS verification.
*
* This confirms that the short auth strings match on both sides.
*
* Does nothing if we’re not in a state where we can confirm the
* short auth string.
*
* Returns a `Promise` for an array of `OutgoingRequest`s.
* @returns {Promise<any>}
*/
confirm() {
const ret = wasm.sas_confirm(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Cancel the verification.
*
* Returns either an `OutgoingRequest` which should be sent out, or
* `undefined` if the verification is already cancelled.
* @returns {any}
*/
cancel() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.sas_cancel(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Cancel the verification.
*
* This cancels the verification with given code (e.g. `m.user`).
*
* Returns either an `OutgoingRequest` which should be sent out, or
* `undefined` if the verification is already cancelled.
* @param {string} code
* @returns {any}
*/
cancelWithCode(code) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.sas_cancelWithCode(retptr, this.__wbg_ptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Has the SAS verification flow timed out?
* @returns {boolean}
*/
timedOut() {
const ret = wasm.sas_timedOut(this.__wbg_ptr);
return ret !== 0;
}
/**
* Are we in a state where we can show the short auth string?
* @returns {boolean}
*/
canBePresented() {
const ret = wasm.sas_canBePresented(this.__wbg_ptr);
return ret !== 0;
}
/**
* Is the SAS flow done?
* @returns {boolean}
*/
isDone() {
const ret = wasm.sas_isDone(this.__wbg_ptr);
return ret !== 0;
}
/**
* Is the SAS flow cancelled?
* @returns {boolean}
*/
isCancelled() {
const ret = wasm.sas_isCancelled(this.__wbg_ptr);
return ret !== 0;
}
/**
* Get the emoji version of the short auth string.
*
* Returns `undefined` if we can't yet present the short auth string,
* otherwise an array of seven `Emoji` objects.
* @returns {(Emoji)[] | undefined}
*/
emoji() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.sas_emoji(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
let v1;
if (r0 !== 0) {
v1 = getArrayJsValueFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 4, 4);
}
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Get the index of the emoji representing the short auth string
*
* Returns `undefined` if we can’t yet present the short auth
* string, otherwise seven `u8` numbers in the range from 0 to 63
* inclusive which can be converted to an emoji using [the
* relevant specification
* @returns {Uint8Array | undefined}
*/
emojiIndex() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.sas_emojiIndex(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
let v1;
if (r0 !== 0) {
v1 = getArrayU8FromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
}
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Get the decimal version of the short auth string.
*
* Returns None if we can’t yet present the short auth string,
* otherwise a tuple containing three 4-digit integers that
* represent the short auth string.
* @returns {Uint16Array | undefined}
*/
decimals() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.sas_decimals(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
let v1;
if (r0 !== 0) {
v1 = getArrayU16FromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 2, 2);
}
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Register a callback which will be called whenever there is an update to
* the request.
*
* The `callback` is called with no parameters.
* @param {Function} callback
*/
registerChangesCallback(callback) {
wasm.sas_registerChangesCallback(this.__wbg_ptr, addHeapObject(callback));
}
}
module.exports.Sas = Sas;
const SecretsBundleFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_secretsbundle_free(ptr >>> 0, 1));
/**
* Struct containing the bundle of secrets to fully activate a new device for
* end-to-end encryption.
*/
class SecretsBundle {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(SecretsBundle.prototype);
obj.__wbg_ptr = ptr;
SecretsBundleFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
SecretsBundleFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_secretsbundle_free(ptr, 0);
}
/**
* The seed of the master key encoded as unpadded base64.
* @returns {string}
*/
get masterKey() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.secretsbundle_masterKey(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* The seed of the self signing key encoded as unpadded base64.
* @returns {string}
*/
get selfSigningKey() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.secretsbundle_selfSigningKey(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* The seed of the user signing key encoded as unpadded base64.
* @returns {string}
*/
get userSigningKey() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.secretsbundle_userSigningKey(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* The bundle of the backup decryption key and backup version if any.
* @returns {BackupSecretsBundle | undefined}
*/
get backupBundle() {
const ret = wasm.secretsbundle_backupBundle(this.__wbg_ptr);
return ret === 0 ? undefined : BackupSecretsBundle.__wrap(ret);
}
/**
* Serialize the [`SecretsBundle`] to a JSON object.
* @returns {any}
*/
to_json() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.secretsbundle_to_json(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Deserialize the [`SecretsBundle`] from a JSON object.
* @param {any} json
* @returns {SecretsBundle}
*/
static from_json(json) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.secretsbundle_from_json(retptr, addHeapObject(json));
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return SecretsBundle.__wrap(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
}
module.exports.SecretsBundle = SecretsBundle;
const ServerNameFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_servername_free(ptr >>> 0, 1));
/**
* A Matrix-spec compliant [server name].
*
* It consists of a host and an optional port (separated by a colon if
* present).
*
*/
class ServerName {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(ServerName.prototype);
obj.__wbg_ptr = ptr;
ServerNameFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
ServerNameFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_servername_free(ptr, 0);
}
/**
* Parse/validate and create a new `ServerName`.
* @param {string} name
*/
constructor(name) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.servername_new(retptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
this.__wbg_ptr = r0 >>> 0;
ServerNameFinalization.register(this, this.__wbg_ptr, this);
return this;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Returns the host of the server name.
*
* That is: Return the part of the server before `:<port>` or the
* full server name if there is no port.
* @returns {string}
*/
get host() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.servername_host(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* Returns the port of the server name if any.
* @returns {number | undefined}
*/
get port() {
const ret = wasm.servername_port(this.__wbg_ptr);
return ret === 0xFFFFFF ? undefined : ret;
}
/**
* Returns true if and only if the server name is an IPv4 or IPv6
* address.
* @returns {boolean}
*/
isIpLiteral() {
const ret = wasm.servername_isIpLiteral(this.__wbg_ptr);
return ret !== 0;
}
}
module.exports.ServerName = ServerName;
const ShieldStateFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_shieldstate_free(ptr >>> 0, 1));
/**
* Take a look at [`matrix_sdk_common::deserialized_responses::ShieldState`]
* for more info.
*/
class ShieldState {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(ShieldState.prototype);
obj.__wbg_ptr = ptr;
ShieldStateFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
ShieldStateFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_shieldstate_free(ptr, 0);
}
/**
* The shield color
* @returns {ShieldColor}
*/
get color() {
const ret = wasm.__wbg_get_shieldstate_color(this.__wbg_ptr);
return ret;
}
/**
* The shield color
* @param {ShieldColor} arg0
*/
set color(arg0) {
wasm.__wbg_set_shieldstate_color(this.__wbg_ptr, arg0);
}
/**
* A machine-readable representation of the authenticity for a
* `ShieldState`.
* @returns {ShieldStateCode | undefined}
*/
get code() {
const ret = wasm.__wbg_get_shieldstate_code(this.__wbg_ptr);
return ret === 6 ? undefined : ret;
}
/**
* A machine-readable representation of the authenticity for a
* `ShieldState`.
* @param {ShieldStateCode | undefined} [arg0]
*/
set code(arg0) {
wasm.__wbg_set_shieldstate_code(this.__wbg_ptr, isLikeNone(arg0) ? 6 : arg0);
}
/**
* Error message that can be displayed as a tooltip
* @returns {string | undefined}
*/
get message() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.shieldstate_message(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
let v1;
if (r0 !== 0) {
v1 = getStringFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
}
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
}
module.exports.ShieldState = ShieldState;
const SignatureFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_signature_free(ptr >>> 0, 1));
/**
* Represents a potentially decoded signature (but not a validated
* one).
*/
class Signature {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(Signature.prototype);
obj.__wbg_ptr = ptr;
SignatureFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
SignatureFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_signature_free(ptr, 0);
}
/**
* Get the Ed25519 signature, if this is one.
* @returns {Ed25519Signature | undefined}
*/
get ed25519() {
const ret = wasm.signature_ed25519(this.__wbg_ptr);
return ret === 0 ? undefined : Ed25519Signature.__wrap(ret);
}
/**
* Convert the signature to a base64 encoded string.
* @returns {string}
*/
toBase64() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.signature_toBase64(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
}
module.exports.Signature = Signature;
const SignatureUploadRequestFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_signatureuploadrequest_free(ptr >>> 0, 1));
/**
* Data for a request to the `/keys/signatures/upload` API endpoint
* ([specification]).
*
* Publishes cross-signing signatures for the user.
*
* [specification]: https://spec.matrix.org/unstable/client-server-api/#post_matrixclientv3keyssignaturesupload
*/
class SignatureUploadRequest {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(SignatureUploadRequest.prototype);
obj.__wbg_ptr = ptr;
SignatureUploadRequestFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
SignatureUploadRequestFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_signatureuploadrequest_free(ptr, 0);
}
/**
* The request ID.
* Some signature upload will have to an `id` field, some won't.
* They have one when they are created automatically during an interactive
* verification, otherwise they don't.
* @returns {string | undefined}
*/
get id() {
const ret = wasm.__wbg_get_signatureuploadrequest_id(this.__wbg_ptr);
return takeObject(ret);
}
/**
* A JSON-encoded string containing the payload of the request
*
* It represents the body of the HTTP request.
* @returns {string}
*/
get body() {
const ret = wasm.__wbg_get_signatureuploadrequest_body(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Create a new `SignatureUploadRequest`.
* @param {string} id
* @param {string} signed_keys
*/
constructor(id, signed_keys) {
const ret = wasm.signatureuploadrequest_new(addHeapObject(id), addHeapObject(signed_keys));
this.__wbg_ptr = ret >>> 0;
SignatureUploadRequestFinalization.register(this, this.__wbg_ptr, this);
return this;
}
/**
* Get its request type.
* @returns {RequestType}
*/
get type() {
const ret = wasm.signatureuploadrequest_type(this.__wbg_ptr);
return ret;
}
}
module.exports.SignatureUploadRequest = SignatureUploadRequest;
const SignatureVerificationFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_signatureverification_free(ptr >>> 0, 1));
/**
* The result of a signature verification of a signed JSON object.
*/
class SignatureVerification {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(SignatureVerification.prototype);
obj.__wbg_ptr = ptr;
SignatureVerificationFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
SignatureVerificationFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_signatureverification_free(ptr, 0);
}
/**
* Give the backup signature state from the current device.
* See SignatureState for values
* @returns {SignatureState}
*/
get deviceState() {
const ret = wasm.signatureverification_deviceState(this.__wbg_ptr);
return ret;
}
/**
* Give the backup signature state from the current user identity.
* See SignatureState for values
* @returns {SignatureState}
*/
get userState() {
const ret = wasm.signatureverification_userState(this.__wbg_ptr);
return ret;
}
/**
* Is the result considered to be trusted?
*
* This tells us if the result has a valid signature from any of the
* following:
*
* * Our own device
* * Our own user identity, provided the identity is trusted as well
* * Any of our own devices, provided the device is trusted as well
* @returns {boolean}
*/
trusted() {
const ret = wasm.signatureverification_trusted(this.__wbg_ptr);
return ret !== 0;
}
}
module.exports.SignatureVerification = SignatureVerification;
const SignaturesFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_signatures_free(ptr >>> 0, 1));
/**
* A collection of `Signature`.
*/
class Signatures {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(Signatures.prototype);
obj.__wbg_ptr = ptr;
SignaturesFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
SignaturesFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_signatures_free(ptr, 0);
}
/**
* Creates a new, empty, signatures collection.
*/
constructor() {
const ret = wasm.signatures_new();
this.__wbg_ptr = ret >>> 0;
SignaturesFinalization.register(this, this.__wbg_ptr, this);
return this;
}
/**
* Add the given signature from the given signer and the given key ID to
* the collection.
* @param {UserId} signer
* @param {DeviceKeyId} key_id
* @param {Ed25519Signature} signature
* @returns {MaybeSignature | undefined}
*/
addSignature(signer, key_id, signature) {
_assertClass(signer, UserId);
_assertClass(key_id, DeviceKeyId);
_assertClass(signature, Ed25519Signature);
const ret = wasm.signatures_addSignature(this.__wbg_ptr, signer.__wbg_ptr, key_id.__wbg_ptr, signature.__wbg_ptr);
return ret === 0 ? undefined : MaybeSignature.__wrap(ret);
}
/**
* Try to find an Ed25519 signature from the given signer with
* the given key ID.
* @param {UserId} signer
* @param {DeviceKeyId} key_id
* @returns {Ed25519Signature | undefined}
*/
getSignature(signer, key_id) {
_assertClass(signer, UserId);
_assertClass(key_id, DeviceKeyId);
const ret = wasm.signatures_getSignature(this.__wbg_ptr, signer.__wbg_ptr, key_id.__wbg_ptr);
return ret === 0 ? undefined : Ed25519Signature.__wrap(ret);
}
/**
* Get the map of signatures that belong to the given user.
* @param {UserId} signer
* @returns {Map<any, any> | undefined}
*/
get(signer) {
_assertClass(signer, UserId);
const ret = wasm.signatures_get(this.__wbg_ptr, signer.__wbg_ptr);
return takeObject(ret);
}
/**
* Remove all the signatures we currently hold.
*/
clear() {
wasm.signatures_clear(this.__wbg_ptr);
}
/**
* Do we hold any signatures or is our collection completely
* empty.
* @returns {boolean}
*/
isEmpty() {
const ret = wasm.signatures_isEmpty(this.__wbg_ptr);
return ret !== 0;
}
/**
* How many signatures do we currently hold.
* @returns {number}
*/
get count() {
const ret = wasm.signatures_count(this.__wbg_ptr);
return ret >>> 0;
}
/**
* Get the json with all signatures
* @returns {string}
*/
asJSON() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.signatures_asJSON(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
}
module.exports.Signatures = Signatures;
const StoreHandleFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_storehandle_free(ptr >>> 0, 1));
/**
* A struct containing an open connection to a CryptoStore.
*
* Opening the CryptoStore can take some time, due to the PBKDF calculation
* involved, so if multiple operations are being done on the same store, it is
* more efficient to open it once.
*/
class StoreHandle {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(StoreHandle.prototype);
obj.__wbg_ptr = ptr;
StoreHandleFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
StoreHandleFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_storehandle_free(ptr, 0);
}
/**
* Open a crypto store.
*
* The created store will be based on IndexedDB if a `store_name` is
* provided; otherwise it will be based on a memory store and once the
* objects is dropped, the keys will be lost.
*
* # Arguments
*
* * `store_name` - The name that should be used to open the IndexedDB
* based database. If this isn't provided, a memory-only store will be
* used. *Note* the memory-only store will lose your E2EE keys when the
* `StoreHandle` gets dropped.
*
* * `store_passphrase` - The passphrase that should be used to encrypt the
* store, for IndexedDB-based stores
* @param {string | undefined} [store_name]
* @param {string | undefined} [store_passphrase]
* @returns {Promise<StoreHandle>}
*/
static open(store_name, store_passphrase) {
var ptr0 = isLikeNone(store_name) ? 0 : passStringToWasm0(store_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
var len0 = WASM_VECTOR_LEN;
var ptr1 = isLikeNone(store_passphrase) ? 0 : passStringToWasm0(store_passphrase, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
var len1 = WASM_VECTOR_LEN;
const ret = wasm.storehandle_open(ptr0, len0, ptr1, len1);
return takeObject(ret);
}
/**
* Open a crypto store based on IndexedDB, using the given key for
* encryption.
*
* # Arguments
*
* * `store_name` - The name that should be used to open the IndexedDB
* based database.
*
* * `store_key` - The key that should be used to encrypt the store, for
* IndexedDB-based stores. Must be a 32-byte array.
* @param {string} store_name
* @param {Uint8Array} store_key
* @returns {Promise<StoreHandle>}
*/
static openWithKey(store_name, store_key) {
const ptr0 = passStringToWasm0(store_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ptr1 = passArray8ToWasm0(store_key, wasm.__wbindgen_malloc);
const len1 = WASM_VECTOR_LEN;
const ret = wasm.storehandle_openWithKey(ptr0, len0, ptr1, len1);
return takeObject(ret);
}
}
module.exports.StoreHandle = StoreHandle;
const ToDeviceRequestFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_todevicerequest_free(ptr >>> 0, 1));
/**
* Data for a request to the `/sendToDevice` API endpoint
* ([specification]).
*
* Send an event to a single device or to a group of devices.
*
* [specification]: https://spec.matrix.org/unstable/client-server-api/#put_matrixclientv3sendtodeviceeventtypetxnid
*/
class ToDeviceRequest {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(ToDeviceRequest.prototype);
obj.__wbg_ptr = ptr;
ToDeviceRequestFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
ToDeviceRequestFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_todevicerequest_free(ptr, 0);
}
/**
* The request ID.
* For to-device request this would be the same value as `txn_id`. It is
* exposed also as `id` so that the js bindings are consistent with the
* other request types by using this field to mark as sent.
* @returns {string}
*/
get id() {
const ret = wasm.__wbg_get_todevicerequest_id(this.__wbg_ptr);
return takeObject(ret);
}
/**
* A string representing the type of event being sent to each devices.
* @returns {string}
*/
get event_type() {
const ret = wasm.__wbg_get_todevicerequest_event_type(this.__wbg_ptr);
return takeObject(ret);
}
/**
* A string representing a request identifier unique to the access token
* used to send the request.
* @returns {string}
*/
get txn_id() {
const ret = wasm.__wbg_get_todevicerequest_txn_id(this.__wbg_ptr);
return takeObject(ret);
}
/**
* A JSON-encoded string containing the rest of the payload: `messages`.
*
* It represents the body of the HTTP request.
* @returns {string}
*/
get body() {
const ret = wasm.__wbg_get_todevicerequest_body(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Create a new `ToDeviceRequest`.
* @param {string} id
* @param {string} event_type
* @param {string} txn_id
* @param {string} body
*/
constructor(id, event_type, txn_id, body) {
const ret = wasm.todevicerequest_new(addHeapObject(id), addHeapObject(event_type), addHeapObject(txn_id), addHeapObject(body));
this.__wbg_ptr = ret >>> 0;
ToDeviceRequestFinalization.register(this, this.__wbg_ptr, this);
return this;
}
/**
* Get its request type.
* @returns {RequestType}
*/
get type() {
const ret = wasm.todevicerequest_type(this.__wbg_ptr);
return ret;
}
}
module.exports.ToDeviceRequest = ToDeviceRequest;
const TracingFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_tracing_free(ptr >>> 0, 1));
/**
* Type to install and to manipulate the tracing layer.
*/
class Tracing {
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
TracingFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_tracing_free(ptr, 0);
}
/**
* Check whether the `tracing` feature has been enabled.
*
* @deprecated: `tracing` is now always enabled.
* @returns {boolean}
*/
static isAvailable() {
const ret = wasm.tracing_isAvailable();
return ret !== 0;
}
/**
* Install the tracing layer.
* @param {LoggerLevel} min_level
*/
constructor(min_level) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.tracing_new(retptr, min_level);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
this.__wbg_ptr = r0 >>> 0;
TracingFinalization.register(this, this.__wbg_ptr, this);
return this;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Re-define the minimum logger level.
* @param {LoggerLevel} min_level
*/
set minLevel(min_level) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.tracing_set_minLevel(retptr, this.__wbg_ptr, min_level);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
if (r1) {
throw takeObject(r0);
}
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Turn the logger on, i.e. it emits logs again if it was turned
* off.
*/
turnOn() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.tracing_turnOn(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
if (r1) {
throw takeObject(r0);
}
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Turn the logger off, i.e. it no longer emits logs.
*/
turnOff() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.tracing_turnOff(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
if (r1) {
throw takeObject(r0);
}
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
}
module.exports.Tracing = Tracing;
const UploadSigningKeysRequestFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_uploadsigningkeysrequest_free(ptr >>> 0, 1));
/**
* Other Requests *
* Request that will publish a cross signing identity.
*
* This uploads the public cross signing key triplet.
*/
class UploadSigningKeysRequest {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(UploadSigningKeysRequest.prototype);
obj.__wbg_ptr = ptr;
UploadSigningKeysRequestFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
UploadSigningKeysRequestFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_uploadsigningkeysrequest_free(ptr, 0);
}
/**
* A JSON-encoded string containing the rest of the payload: `master_key`,
* `self_signing_key`, `user_signing_key`.
*
* It represents the body of the HTTP request.
* @returns {string}
*/
get body() {
const ret = wasm.__wbg_get_uploadsigningkeysrequest_body(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Create a new `UploadSigningKeysRequest`.
* @param {string} body
*/
constructor(body) {
const ret = wasm.uploadsigningkeysrequest_new(addHeapObject(body));
this.__wbg_ptr = ret >>> 0;
UploadSigningKeysRequestFinalization.register(this, this.__wbg_ptr, this);
return this;
}
}
module.exports.UploadSigningKeysRequest = UploadSigningKeysRequest;
const UserDevicesFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_userdevices_free(ptr >>> 0, 1));
/**
* A read only view over all devices belonging to a user.
*/
class UserDevices {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(UserDevices.prototype);
obj.__wbg_ptr = ptr;
UserDevicesFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
UserDevicesFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_userdevices_free(ptr, 0);
}
/**
* Get the specific device with the given device ID.
* @param {DeviceId} device_id
* @returns {Device | undefined}
*/
get(device_id) {
_assertClass(device_id, DeviceId);
const ret = wasm.userdevices_get(this.__wbg_ptr, device_id.__wbg_ptr);
return ret === 0 ? undefined : Device.__wrap(ret);
}
/**
* Returns true if there is at least one devices of this user
* that is considered to be verified, false otherwise.
*
* This won't consider your own device as verified, as your own
* device is always implicitly verified.
* @returns {boolean}
*/
isAnyVerified() {
const ret = wasm.userdevices_isAnyVerified(this.__wbg_ptr);
return ret !== 0;
}
/**
* Array over all the device IDs of the user devices.
* @returns {Array<any>}
*/
keys() {
const ret = wasm.userdevices_keys(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Iterator over all the devices of the user devices.
* @returns {Array<any>}
*/
devices() {
const ret = wasm.userdevices_devices(this.__wbg_ptr);
return takeObject(ret);
}
}
module.exports.UserDevices = UserDevices;
const UserIdFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_userid_free(ptr >>> 0, 1));
/**
* A Matrix [user ID].
*
*/
class UserId {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(UserId.prototype);
obj.__wbg_ptr = ptr;
UserIdFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
static __unwrap(jsValue) {
if (!(jsValue instanceof UserId)) {
return 0;
}
return jsValue.__destroy_into_raw();
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
UserIdFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_userid_free(ptr, 0);
}
/**
* Parse/validate and create a new `UserId`.
* @param {string} id
*/
constructor(id) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.userid_new(retptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
this.__wbg_ptr = r0 >>> 0;
UserIdFinalization.register(this, this.__wbg_ptr, this);
return this;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Returns the user's localpart.
* @returns {string}
*/
get localpart() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.userid_localpart(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* Returns the server name of the user ID.
* @returns {ServerName}
*/
get serverName() {
const ret = wasm.userid_serverName(this.__wbg_ptr);
return ServerName.__wrap(ret);
}
/**
* Whether this user ID is a historical one.
*
* A historical user ID is one that doesn't conform to the latest
* specification of the user ID grammar but is still accepted
* because it was previously allowed.
* @returns {boolean}
*/
isHistorical() {
const ret = wasm.userid_isHistorical(this.__wbg_ptr);
return ret !== 0;
}
/**
* Return the user ID as a string.
* @returns {string}
*/
toString() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.userid_toString(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* Create a clone of this `UserId`.
*
* This can be useful when passing a `UserId` instance to methods such as
* {@link OlmMachine.updateTrackedUsers} which destroy the instance.
* @returns {UserId}
*/
clone() {
const ret = wasm.userid_clone(this.__wbg_ptr);
return UserId.__wrap(ret);
}
}
module.exports.UserId = UserId;
const UserIdentityFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_useridentity_free(ptr >>> 0, 1));
/**
* Struct representing a cross signing identity of a user.
*
* This is the user identity of a user that isn't our own. Other users will
* only contain a master key and a self signing key, meaning that only device
* signatures can be checked with this identity.
*
* This struct wraps a read-only version of the struct and allows verifications
* to be requested to verify our own device with the user identity.
*/
class UserIdentity {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(UserIdentity.prototype);
obj.__wbg_ptr = ptr;
UserIdentityFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
UserIdentityFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_useridentity_free(ptr, 0);
}
/**
* Is this user identity verified?
* @returns {boolean}
*/
isVerified() {
const ret = wasm.useridentity_isVerified(this.__wbg_ptr);
return ret !== 0;
}
/**
* Manually verify this user.
*
* This method will attempt to sign the user identity using our private
* cross signing key.
*
* This method fails if we don't have the private part of our user-signing
* key.
*
* Returns a request that needs to be sent out for the user to be marked as
* verified.
* @returns {Promise<any>}
*/
verify() {
const ret = wasm.useridentity_verify(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Create a `VerificationRequest` object after the verification
* request content has been sent out.
* @param {RoomId} room_id
* @param {EventId} request_event_id
* @param {any[] | undefined} [methods]
* @returns {VerificationRequest}
*/
requestVerification(room_id, request_event_id, methods) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
_assertClass(room_id, RoomId);
_assertClass(request_event_id, EventId);
var ptr0 = isLikeNone(methods) ? 0 : passArrayJsValueToWasm0(methods, wasm.__wbindgen_malloc);
var len0 = WASM_VECTOR_LEN;
wasm.useridentity_requestVerification(retptr, this.__wbg_ptr, room_id.__wbg_ptr, request_event_id.__wbg_ptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return VerificationRequest.__wrap(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Send a verification request to the given user.
*
* The returned content needs to be sent out into a DM room with the given
* user.
*
* After the content has been sent out a VerificationRequest can be started
* with the `request_verification` method.
* @param {any[] | undefined} [methods]
* @returns {string}
*/
verificationRequestContent(methods) {
let deferred3_0;
let deferred3_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
var ptr0 = isLikeNone(methods) ? 0 : passArrayJsValueToWasm0(methods, wasm.__wbindgen_malloc);
var len0 = WASM_VECTOR_LEN;
wasm.useridentity_verificationRequestContent(retptr, this.__wbg_ptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
var ptr2 = r0;
var len2 = r1;
if (r3) {
ptr2 = 0; len2 = 0;
throw takeObject(r2);
}
deferred3_0 = ptr2;
deferred3_1 = len2;
return getStringFromWasm0(ptr2, len2);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
}
}
/**
* Get the master key of the identity.
* @returns {string}
*/
get masterKey() {
let deferred2_0;
let deferred2_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.useridentity_masterKey(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
var ptr1 = r0;
var len1 = r1;
if (r3) {
ptr1 = 0; len1 = 0;
throw takeObject(r2);
}
deferred2_0 = ptr1;
deferred2_1 = len1;
return getStringFromWasm0(ptr1, len1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
}
}
/**
* Get the self-signing key of the identity.
* @returns {string}
*/
get selfSigningKey() {
let deferred2_0;
let deferred2_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.useridentity_selfSigningKey(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
var ptr1 = r0;
var len1 = r1;
if (r3) {
ptr1 = 0; len1 = 0;
throw takeObject(r2);
}
deferred2_0 = ptr1;
deferred2_1 = len1;
return getStringFromWasm0(ptr1, len1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
}
}
/**
* Pin the current identity (public part of the master signing key).
* @returns {Promise<any>}
*/
pinCurrentMasterKey() {
const ret = wasm.useridentity_pinCurrentMasterKey(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Has the identity changed in a way that requires approval from the user?
*
* A user identity needs approval if it changed after the crypto machine
* has already observed ("pinned") a different identity for that user,
* unless it is an explicitly verified identity (using for example
* interactive verification).
*
* This situation can be resolved by:
*
* - Verifying the new identity with {@link requestVerification}, or:
* - Updating the pin to the new identity with {@link pinCurrentMasterKey}.
* @returns {boolean}
*/
identityNeedsUserApproval() {
const ret = wasm.useridentity_identityNeedsUserApproval(this.__wbg_ptr);
return ret !== 0;
}
/**
* True if we verified this identity (with any own identity, at any
* point).
*
* To set this latch back to false, call {@link withdrawVerification}.
* @returns {boolean}
*/
wasPreviouslyVerified() {
const ret = wasm.useridentity_wasPreviouslyVerified(this.__wbg_ptr);
return ret !== 0;
}
/**
* Remove the requirement for this identity to be verified.
*
* If an identity was previously verified and is not anymore it will be
* reported to the user. In order to remove this notice users have to
* verify again or to withdraw the verification requirement.
* @returns {Promise<any>}
*/
withdrawVerification() {
const ret = wasm.useridentity_withdrawVerification(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Was this identity verified since initial observation and is not anymore?
*
* Such a violation should be reported to the local user by the
* application, and resolved by
*
* - Verifying the new identity with {@link requestVerification}, or:
* - Withdrawing the verification requirement with {@link
* withdrawVerification}.
* @returns {boolean}
*/
hasVerificationViolation() {
const ret = wasm.useridentity_hasVerificationViolation(this.__wbg_ptr);
return ret !== 0;
}
}
module.exports.UserIdentity = UserIdentity;
const VerificationRequestFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_verificationrequest_free(ptr >>> 0, 1));
/**
* An object controlling key verification requests.
*
* Interactive verification flows usually start with a verification
* request, this object lets you send and reply to such a
* verification request.
*
* After the initial handshake the verification flow transitions into
* one of the verification methods.
*/
class VerificationRequest {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(VerificationRequest.prototype);
obj.__wbg_ptr = ptr;
VerificationRequestFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
VerificationRequestFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_verificationrequest_free(ptr, 0);
}
/**
* Create an event content that can be sent as a room event to
* request verification from the other side. This should be used
* only for verifications of other users and it should be sent to
* a room we consider to be a DM with the other user.
* @param {UserId} own_user_id
* @param {DeviceId} own_device_id
* @param {UserId} other_user_id
* @param {any[] | undefined} [methods]
* @returns {string}
*/
static request(own_user_id, own_device_id, other_user_id, methods) {
let deferred3_0;
let deferred3_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
_assertClass(own_user_id, UserId);
_assertClass(own_device_id, DeviceId);
_assertClass(other_user_id, UserId);
var ptr0 = isLikeNone(methods) ? 0 : passArrayJsValueToWasm0(methods, wasm.__wbindgen_malloc);
var len0 = WASM_VECTOR_LEN;
wasm.verificationrequest_request(retptr, own_user_id.__wbg_ptr, own_device_id.__wbg_ptr, other_user_id.__wbg_ptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
var ptr2 = r0;
var len2 = r1;
if (r3) {
ptr2 = 0; len2 = 0;
throw takeObject(r2);
}
deferred3_0 = ptr2;
deferred3_1 = len2;
return getStringFromWasm0(ptr2, len2);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
}
}
/**
* Our own user id.
* @returns {UserId}
*/
get ownUserId() {
const ret = wasm.verificationrequest_ownUserId(this.__wbg_ptr);
return UserId.__wrap(ret);
}
/**
* The ID of the other user that is participating in this
* verification request.
* @returns {UserId}
*/
get otherUserId() {
const ret = wasm.verificationrequest_otherUserId(this.__wbg_ptr);
return UserId.__wrap(ret);
}
/**
* The ID of the other device that is participating in this
* verification.
* @returns {DeviceId | undefined}
*/
get otherDeviceId() {
const ret = wasm.verificationrequest_otherDeviceId(this.__wbg_ptr);
return ret === 0 ? undefined : DeviceId.__wrap(ret);
}
/**
* Get the room ID if the verification is happening inside a
* room.
* @returns {RoomId | undefined}
*/
get roomId() {
const ret = wasm.verificationrequest_roomId(this.__wbg_ptr);
return ret === 0 ? undefined : RoomId.__wrap(ret);
}
/**
* Get info about the cancellation if the verification request
* has been cancelled.
* @returns {CancelInfo | undefined}
*/
get cancelInfo() {
const ret = wasm.verificationrequest_cancelInfo(this.__wbg_ptr);
return ret === 0 ? undefined : CancelInfo.__wrap(ret);
}
/**
* Has the verification request been answered by another device?
* @returns {boolean}
*/
isPassive() {
const ret = wasm.verificationrequest_isPassive(this.__wbg_ptr);
return ret !== 0;
}
/**
* Is the verification request ready to start a verification flow?
* @returns {boolean}
*/
isReady() {
const ret = wasm.verificationrequest_isReady(this.__wbg_ptr);
return ret !== 0;
}
/**
* Has the verification flow timed out?
* @returns {boolean}
*/
timedOut() {
const ret = wasm.verificationrequest_timedOut(this.__wbg_ptr);
return ret !== 0;
}
/**
* The number of milliseconds remaining before this verification flow times
* out.
*
* Returns zero if the time has already passed.
* @returns {number}
*/
timeRemainingMillis() {
const ret = wasm.verificationrequest_timeRemainingMillis(this.__wbg_ptr);
return ret;
}
/**
* Get the supported verification methods of the other side.
*
* Will be present only if the other side requested the
* verification or if we’re in the ready state.
*
* # Returns
*
* `undefined` if we do not yet know the supported methods; otherwise, an
* array of `VerificationMethod`s.
* @returns {any[] | undefined}
*/
get theirSupportedMethods() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.verificationrequest_theirSupportedMethods(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
if (r3) {
throw takeObject(r2);
}
let v1;
if (r0 !== 0) {
v1 = getArrayJsValueFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 4, 4);
}
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Get our own supported verification methods that we advertised.
*
* Will be present only we requested the verification or if we’re
* in the ready state.
* @returns {any[] | undefined}
*/
get ourSupportedMethods() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.verificationrequest_ourSupportedMethods(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
if (r3) {
throw takeObject(r2);
}
let v1;
if (r0 !== 0) {
v1 = getArrayJsValueFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 4, 4);
}
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Get the unique ID of this verification request.
* @returns {string}
*/
get flowId() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.verificationrequest_flowId(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* Is this a verification that is verifying one of our own
* devices?
* @returns {boolean}
*/
isSelfVerification() {
const ret = wasm.verificationrequest_isSelfVerification(this.__wbg_ptr);
return ret !== 0;
}
/**
* Did we initiate the verification request?
* @returns {boolean}
*/
weStarted() {
const ret = wasm.verificationrequest_weStarted(this.__wbg_ptr);
return ret !== 0;
}
/**
* Has the verification flow that was started with this request
* finished?
* @returns {boolean}
*/
isDone() {
const ret = wasm.verificationrequest_isDone(this.__wbg_ptr);
return ret !== 0;
}
/**
* Get the current phase of this request.
*
* Returns a `VerificationRequestPhase`.
* @returns {VerificationRequestPhase}
*/
phase() {
const ret = wasm.verificationrequest_phase(this.__wbg_ptr);
return ret;
}
/**
* If this request has transitioned into a concrete verification
* flow (and not yet been completed or cancelled), returns a `Verification`
* object.
*
* Returns: a `Sas`, a `Qr`, or `undefined`.
* @returns {any}
*/
getVerification() {
const ret = wasm.verificationrequest_getVerification(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Register a callback which will be called whenever there is an update to
* the request.
*
* The `callback` is called with no parameters.
* @param {Function} callback
*/
registerChangesCallback(callback) {
wasm.verificationrequest_registerChangesCallback(this.__wbg_ptr, addHeapObject(callback));
}
/**
* Has the verification flow that was started with this request
* been cancelled?
* @returns {boolean}
*/
isCancelled() {
const ret = wasm.verificationrequest_isCancelled(this.__wbg_ptr);
return ret !== 0;
}
/**
* Accept the verification request signaling that our client
* supports the given verification methods.
*
* `methods` represents the methods that we should advertise as
* supported by us.
*
* It returns either a `ToDeviceRequest`, a `RoomMessageRequest`
* or `undefined`.
* @param {any[]} methods
* @returns {any}
*/
acceptWithMethods(methods) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passArrayJsValueToWasm0(methods, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
wasm.verificationrequest_acceptWithMethods(retptr, this.__wbg_ptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Accept the verification request.
*
* This method will accept the request and signal that it
* supports the `m.sas.v1`, the `m.qr_code.show.v1`, and
* `m.reciprocate.v1` method.
*
* `m.qr_code.show.v1` will only be signaled if the `qrcode`
* feature is enabled. This feature is disabled by default. If
* it's enabled and QR code scanning should be supported or QR
* code showing shouldn't be supported the `accept_with_methods`
* method should be used instead.
*
* It returns either a `ToDeviceRequest`, a `RoomMessageRequest`
* or `undefined`.
* @returns {any}
*/
accept() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.verificationrequest_accept(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Cancel the verification request.
*
* It returns either a `ToDeviceRequest`, a `RoomMessageRequest`
* or `undefined`.
* @returns {any}
*/
cancel() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.verificationrequest_cancel(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
if (r2) {
throw takeObject(r1);
}
return takeObject(r0);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* Transition from this verification request into a SAS verification flow.
*
* Returns `Promise<[Sas, RoomMessageRequest|ToDeviceRequest] | undefined>`
* @returns {Promise<any>}
*/
startSas() {
const ret = wasm.verificationrequest_startSas(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Generate a QR code that can be used by another client to start
* a QR code based verification.
*
* Returns a `Qr` or `undefined`.
* @returns {Promise<any>}
*/
generateQrCode() {
const ret = wasm.verificationrequest_generateQrCode(this.__wbg_ptr);
return takeObject(ret);
}
/**
* Start a QR code verification by providing a scanned QR code
* for this verification flow.
* @param {QrCodeScan} data
* @returns {Promise<any>}
*/
scanQrCode(data) {
_assertClass(data, QrCodeScan);
const ret = wasm.verificationrequest_scanQrCode(this.__wbg_ptr, data.__wbg_ptr);
return takeObject(ret);
}
}
module.exports.VerificationRequest = VerificationRequest;
const VersionsFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_versions_free(ptr >>> 0, 1));
/**
* Object containing the versions of the Rust libraries we are using.
*/
class Versions {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(Versions.prototype);
obj.__wbg_ptr = ptr;
VersionsFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
VersionsFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_versions_free(ptr, 0);
}
/**
* The version of the vodozemac crate.
* @returns {string}
*/
get vodozemac() {
const ret = wasm.__wbg_get_versions_vodozemac(this.__wbg_ptr);
return takeObject(ret);
}
/**
* The version of the matrix-sdk-crypto crate.
* @returns {string}
*/
get matrix_sdk_crypto() {
const ret = wasm.__wbg_get_versions_matrix_sdk_crypto(this.__wbg_ptr);
return takeObject(ret);
}
/**
* The Git commit hash of the crate's source tree at build time.
* @returns {string}
*/
get git_sha() {
const ret = wasm.__wbg_get_versions_git_sha(this.__wbg_ptr);
return takeObject(ret);
}
/**
* The build-time output of the `git describe` command of the source tree
* of crate.
* @returns {string}
*/
get git_description() {
const ret = wasm.__wbg_get_versions_git_description(this.__wbg_ptr);
return takeObject(ret);
}
}
module.exports.Versions = Versions;
module.exports.__wbindgen_string_new = function(arg0, arg1) {
const ret = getStringFromWasm0(arg0, arg1);
return addHeapObject(ret);
};
module.exports.__wbindgen_object_drop_ref = function(arg0) {
takeObject(arg0);
};
module.exports.__wbindgen_number_new = function(arg0) {
const ret = arg0;
return addHeapObject(ret);
};
module.exports.__wbindgen_object_clone_ref = function(arg0) {
const ret = getObject(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_userid_unwrap = function(arg0) {
const ret = UserId.__unwrap(takeObject(arg0));
return ret;
};
module.exports.__wbg_roomid_unwrap = function(arg0) {
const ret = RoomId.__unwrap(takeObject(arg0));
return ret;
};
module.exports.__wbindgen_error_new = function(arg0, arg1) {
const ret = new Error(getStringFromWasm0(arg0, arg1));
return addHeapObject(ret);
};
module.exports.__wbindgen_jsval_eq = function(arg0, arg1) {
const ret = getObject(arg0) === getObject(arg1);
return ret;
};
module.exports.__wbindgen_string_get = function(arg0, arg1) {
const obj = getObject(arg1);
const ret = typeof(obj) === 'string' ? obj : undefined;
var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
var len1 = WASM_VECTOR_LEN;
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
};
module.exports.__wbg_inboundgroupsession_new = function(arg0) {
const ret = InboundGroupSession.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbindgen_boolean_get = function(arg0) {
const v = getObject(arg0);
const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
return ret;
};
module.exports.__wbindgen_number_get = function(arg0, arg1) {
const obj = getObject(arg1);
const ret = typeof(obj) === 'number' ? obj : undefined;
getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
};
module.exports.__wbindgen_is_undefined = function(arg0) {
const ret = getObject(arg0) === undefined;
return ret;
};
module.exports.__wbg_ownuseridentity_new = function(arg0) {
const ret = OwnUserIdentity.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_useridentity_new = function(arg0) {
const ret = UserIdentity.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_keysuploadrequest_new = function(arg0) {
const ret = KeysUploadRequest.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_keysqueryrequest_new = function(arg0) {
const ret = KeysQueryRequest.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_roomkeycounts_new = function(arg0) {
const ret = RoomKeyCounts.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_backupkeys_new = function(arg0) {
const ret = BackupKeys.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_rehydrateddevice_new = function(arg0) {
const ret = RehydratedDevice.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_dehydrateddevice_new = function(arg0) {
const ret = DehydratedDevice.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_device_new = function(arg0) {
const ret = Device.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_userdevices_new = function(arg0) {
const ret = UserDevices.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_megolmdecryptionerror_new = function(arg0) {
const ret = MegolmDecryptionError.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_userid_new = function(arg0) {
const ret = UserId.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_deviceid_new = function(arg0) {
const ret = DeviceId.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_devicekeyid_new = function(arg0) {
const ret = DeviceKeyId.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_olmmachine_new = function(arg0) {
const ret = OlmMachine.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_crosssigningstatus_new = function(arg0) {
const ret = CrossSigningStatus.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_keysclaimrequest_new = function(arg0) {
const ret = KeysClaimRequest.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_todevicerequest_new = function(arg0) {
const ret = ToDeviceRequest.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_signatureuploadrequest_new = function(arg0) {
const ret = SignatureUploadRequest.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_roommessagerequest_new = function(arg0) {
const ret = RoomMessageRequest.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_keysbackuprequest_new = function(arg0) {
const ret = KeysBackupRequest.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_putdehydrateddevicerequest_new = function(arg0) {
const ret = PutDehydratedDeviceRequest.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_crosssigningbootstraprequests_new = function(arg0) {
const ret = CrossSigningBootstrapRequests.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_decryptedroomevent_new = function(arg0) {
const ret = DecryptedRoomEvent.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_encryptioninfo_new = function(arg0) {
const ret = EncryptionInfo.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_storehandle_new = function(arg0) {
const ret = StoreHandle.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_crosssigningkeyexport_new = function(arg0) {
const ret = CrossSigningKeyExport.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_roomkeyinfo_new = function(arg0) {
const ret = RoomKeyInfo.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_roomkeywithheldinfo_new = function(arg0) {
const ret = RoomKeyWithheldInfo.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_secretsbundle_new = function(arg0) {
const ret = SecretsBundle.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_signatures_new = function(arg0) {
const ret = Signatures.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_maybesignature_new = function(arg0) {
const ret = MaybeSignature.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_signatureverification_new = function(arg0) {
const ret = SignatureVerification.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_roomkeyimportresult_new = function(arg0) {
const ret = RoomKeyImportResult.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_roomsettings_new = function(arg0) {
const ret = RoomSettings.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_sas_new = function(arg0) {
const ret = Sas.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_qr_new = function(arg0) {
const ret = Qr.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_emoji_new = function(arg0) {
const ret = Emoji.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_verificationrequest_new = function(arg0) {
const ret = VerificationRequest.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_devicekey_new = function(arg0) {
const ret = DeviceKey.__wrap(arg0);
return addHeapObject(ret);
};
module.exports.__wbg_pickledsession_unwrap = function(arg0) {
const ret = PickledSession.__unwrap(takeObject(arg0));
return ret;
};
module.exports.__wbg_pickledinboundgroupsession_unwrap = function(arg0) {
const ret = PickledInboundGroupSession.__unwrap(takeObject(arg0));
return ret;
};
module.exports.__wbindgen_is_array = function(arg0) {
const ret = Array.isArray(getObject(arg0));
return ret;
};
module.exports.__wbindgen_in = function(arg0, arg1) {
const ret = getObject(arg0) in getObject(arg1);
return ret;
};
module.exports.__wbindgen_is_bigint = function(arg0) {
const ret = typeof(getObject(arg0)) === 'bigint';
return ret;
};
module.exports.__wbindgen_is_object = function(arg0) {
const val = getObject(arg0);
const ret = typeof(val) === 'object' && val !== null;
return ret;
};
module.exports.__wbindgen_bigint_from_i64 = function(arg0) {
const ret = arg0;
return addHeapObject(ret);
};
module.exports.__wbindgen_bigint_from_u64 = function(arg0) {
const ret = BigInt.asUintN(64, arg0);
return addHeapObject(ret);
};
module.exports.__wbindgen_try_into_number = function(arg0) {
let result;
try { result = +getObject(arg0) } catch (e) { result = e }
const ret = result;
return addHeapObject(ret);
};
module.exports.__wbg_new_abda76e883ba8a5f = function() {
const ret = new Error();
return addHeapObject(ret);
};
module.exports.__wbg_stack_658279fe44541cf6 = function(arg0, arg1) {
const ret = getObject(arg1).stack;
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
};
module.exports.__wbg_error_f851667af71bcfc6 = function(arg0, arg1) {
let deferred0_0;
let deferred0_1;
try {
deferred0_0 = arg0;
deferred0_1 = arg1;
console.error(getStringFromWasm0(arg0, arg1));
} finally {
wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
}
};
module.exports.__wbindgen_is_null = function(arg0) {
const ret = getObject(arg0) === null;
return ret;
};
module.exports.__wbindgen_cb_drop = function(arg0) {
const obj = takeObject(arg0).original;
if (obj.cnt-- == 1) {
obj.a = 0;
return true;
}
const ret = false;
return ret;
};
module.exports.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
const ret = getObject(arg0) == getObject(arg1);
return ret;
};
module.exports.__wbindgen_as_number = function(arg0) {
const ret = +getObject(arg0);
return ret;
};
module.exports.__wbg_String_b9412f8799faab3e = function(arg0, arg1) {
const ret = String(getObject(arg1));
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
};
module.exports.__wbg_getwithrefkey_edc2c8960f0f1191 = function(arg0, arg1) {
const ret = getObject(arg0)[getObject(arg1)];
return addHeapObject(ret);
};
module.exports.__wbg_set_f975102236d3c502 = function(arg0, arg1, arg2) {
getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
};
module.exports.__wbg_Window_6a2291ac118902bc = function(arg0) {
const ret = getObject(arg0).Window;
return addHeapObject(ret);
};
module.exports.__wbg_WorkerGlobalScope_e82ddd4027f19bb8 = function(arg0) {
const ret = getObject(arg0).WorkerGlobalScope;
return addHeapObject(ret);
};
module.exports.__wbg_global_12bfcc55465b53ad = function(arg0) {
const ret = getObject(arg0).global;
return addHeapObject(ret);
};
module.exports.__wbg_indexedDB_59bf81be2abc635d = function() { return handleError(function (arg0) {
const ret = getObject(arg0).indexedDB;
return isLikeNone(ret) ? 0 : addHeapObject(ret);
}, arguments) };
module.exports.__wbg_String_88810dfeb4021902 = function(arg0, arg1) {
const ret = String(getObject(arg1));
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
};
module.exports.__wbg_getwithrefkey_5e6d9547403deab8 = function(arg0, arg1) {
const ret = getObject(arg0)[getObject(arg1)];
return addHeapObject(ret);
};
module.exports.__wbg_set_841ac57cff3d672b = function(arg0, arg1, arg2) {
getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
};
module.exports.__wbg_debug_d38cb52bf10ed549 = function(arg0, arg1) {
getObject(arg0).debug(getObject(arg1));
};
module.exports.__wbg_info_91b7c811ac298019 = function(arg0, arg1) {
getObject(arg0).info(getObject(arg1));
};
module.exports.__wbg_warn_036ee814e500dd31 = function(arg0, arg1) {
getObject(arg0).warn(getObject(arg1));
};
module.exports.__wbg_error_68c9b37cbadeb5e7 = function(arg0, arg1) {
getObject(arg0).error(getObject(arg1));
};
module.exports.__wbg_indexedDB_1f9ee79bddf7d011 = function() { return handleError(function (arg0) {
const ret = getObject(arg0).indexedDB;
return isLikeNone(ret) ? 0 : addHeapObject(ret);
}, arguments) };
module.exports.__wbg_debug_5a33c41aeac15ee6 = function(arg0) {
console.debug(getObject(arg0));
};
module.exports.__wbg_error_09480e4aadca50ad = function(arg0) {
console.error(getObject(arg0));
};
module.exports.__wbg_info_c261acb2deacd903 = function(arg0) {
console.info(getObject(arg0));
};
module.exports.__wbg_warn_2b3adb99ce26c314 = function(arg0) {
console.warn(getObject(arg0));
};
module.exports.__wbg_indexedDB_9d299adf9543d0c3 = function() { return handleError(function (arg0) {
const ret = getObject(arg0).indexedDB;
return isLikeNone(ret) ? 0 : addHeapObject(ret);
}, arguments) };
module.exports.__wbg_target_b7cb1739bee70928 = function(arg0) {
const ret = getObject(arg0).target;
return isLikeNone(ret) ? 0 : addHeapObject(ret);
};
module.exports.__wbg_open_a89af1720976a433 = function() { return handleError(function (arg0, arg1, arg2) {
const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_open_e8f45f3526088828 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_add_4d2791d6295ba9ec = function() { return handleError(function (arg0, arg1, arg2) {
const ret = getObject(arg0).add(getObject(arg1), getObject(arg2));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_clear_324ffb9a7c18a41c = function() { return handleError(function (arg0) {
const ret = getObject(arg0).clear();
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_count_7b9a7e71c616b931 = function() { return handleError(function (arg0) {
const ret = getObject(arg0).count();
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_createIndex_8420e89baab0736f = function() { return handleError(function (arg0, arg1, arg2, arg3) {
const ret = getObject(arg0).createIndex(getStringFromWasm0(arg1, arg2), getObject(arg3));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_createIndex_6d4c3e20ee0f1066 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
const ret = getObject(arg0).createIndex(getStringFromWasm0(arg1, arg2), getObject(arg3), getObject(arg4));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_delete_34764ece57bdc720 = function() { return handleError(function (arg0, arg1) {
const ret = getObject(arg0).delete(getObject(arg1));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_get_88b5e79e9daccb9f = function() { return handleError(function (arg0, arg1) {
const ret = getObject(arg0).get(getObject(arg1));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_getAll_cf97564e37784cbe = function() { return handleError(function (arg0, arg1) {
const ret = getObject(arg0).getAll(getObject(arg1));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_getAllKeys_404d5487a041555d = function() { return handleError(function (arg0) {
const ret = getObject(arg0).getAllKeys();
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_index_c90226e82bd94b45 = function() { return handleError(function (arg0, arg1, arg2) {
const ret = getObject(arg0).index(getStringFromWasm0(arg1, arg2));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_openCursor_728ede41c2e2d7ec = function() { return handleError(function (arg0) {
const ret = getObject(arg0).openCursor();
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_openCursor_8ca06744434102da = function() { return handleError(function (arg0, arg1) {
const ret = getObject(arg0).openCursor(getObject(arg1));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_put_f83d95662936dee7 = function() { return handleError(function (arg0, arg1, arg2) {
const ret = getObject(arg0).put(getObject(arg1), getObject(arg2));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_name_fe926223443dc728 = function(arg0, arg1) {
const ret = getObject(arg1).name;
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
};
module.exports.__wbg_message_b477ea215924b777 = function(arg0, arg1) {
const ret = getObject(arg1).message;
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
};
module.exports.__wbg_code_4a4b2516783729c7 = function(arg0) {
const ret = getObject(arg0).code;
return ret;
};
module.exports.__wbg_newwithmessage_7beb619ae81d7cb1 = function() { return handleError(function (arg0, arg1) {
const ret = new DOMException(getStringFromWasm0(arg0, arg1));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_value_d4be628e515b251f = function() { return handleError(function (arg0) {
const ret = getObject(arg0).value;
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_key_37c613728ba0b769 = function() { return handleError(function (arg0) {
const ret = getObject(arg0).key;
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_continue_a92b4c9f17458897 = function() { return handleError(function (arg0) {
getObject(arg0).continue();
}, arguments) };
module.exports.__wbg_delete_fbab4d55ffb8712b = function() { return handleError(function (arg0) {
const ret = getObject(arg0).delete();
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_update_375c91f2a290ec51 = function() { return handleError(function (arg0, arg1) {
const ret = getObject(arg0).update(getObject(arg1));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_bound_8b7ae17c676052c7 = function() { return handleError(function (arg0, arg1) {
const ret = IDBKeyRange.bound(getObject(arg0), getObject(arg1));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_bound_f24ae26594f11d12 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
const ret = IDBKeyRange.bound(getObject(arg0), getObject(arg1), arg2 !== 0, arg3 !== 0);
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_lowerBound_94d1c4a44fcc36a9 = function() { return handleError(function (arg0, arg1) {
const ret = IDBKeyRange.lowerBound(getObject(arg0), arg1 !== 0);
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_setonblocked_554fa1541fe66a16 = function(arg0, arg1) {
getObject(arg0).onblocked = getObject(arg1);
};
module.exports.__wbg_setonupgradeneeded_8f3f0ac5d7130a6f = function(arg0, arg1) {
getObject(arg0).onupgradeneeded = getObject(arg1);
};
module.exports.__wbg_result_fd2dae625828961d = function() { return handleError(function (arg0) {
const ret = getObject(arg0).result;
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_error_1221bc1f1d0b14d3 = function() { return handleError(function (arg0) {
const ret = getObject(arg0).error;
return isLikeNone(ret) ? 0 : addHeapObject(ret);
}, arguments) };
module.exports.__wbg_transaction_0549f2d854da77a6 = function(arg0) {
const ret = getObject(arg0).transaction;
return isLikeNone(ret) ? 0 : addHeapObject(ret);
};
module.exports.__wbg_readyState_80e6a6c7d538fa33 = function(arg0) {
const ret = getObject(arg0).readyState;
return {"pending":0,"done":1,}[ret] ?? 2;
};
module.exports.__wbg_setonsuccess_962c293b6e38a5d5 = function(arg0, arg1) {
getObject(arg0).onsuccess = getObject(arg1);
};
module.exports.__wbg_setonerror_bd61d0a61808ca40 = function(arg0, arg1) {
getObject(arg0).onerror = getObject(arg1);
};
module.exports.__wbg_setonabort_aedc77f0151af20c = function(arg0, arg1) {
getObject(arg0).onabort = getObject(arg1);
};
module.exports.__wbg_setoncomplete_a9e0ec1d6568a6d9 = function(arg0, arg1) {
getObject(arg0).oncomplete = getObject(arg1);
};
module.exports.__wbg_setonerror_00500154a07e987d = function(arg0, arg1) {
getObject(arg0).onerror = getObject(arg1);
};
module.exports.__wbg_objectStore_80724f9f6d33ab5b = function() { return handleError(function (arg0, arg1, arg2) {
const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_version_85aa50b42026873e = function(arg0) {
const ret = getObject(arg0).version;
return ret;
};
module.exports.__wbg_objectStoreNames_2fc72464aff4baed = function(arg0) {
const ret = getObject(arg0).objectStoreNames;
return addHeapObject(ret);
};
module.exports.__wbg_setonversionchange_b1a0928064e9b758 = function(arg0, arg1) {
getObject(arg0).onversionchange = getObject(arg1);
};
module.exports.__wbg_close_7bef29d1d5feecdb = function(arg0) {
getObject(arg0).close();
};
module.exports.__wbg_createObjectStore_190c19a0bae3fedb = function() { return handleError(function (arg0, arg1, arg2) {
const ret = getObject(arg0).createObjectStore(getStringFromWasm0(arg1, arg2));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_deleteObjectStore_745da9b507613eca = function() { return handleError(function (arg0, arg1, arg2) {
getObject(arg0).deleteObjectStore(getStringFromWasm0(arg1, arg2));
}, arguments) };
module.exports.__wbg_transaction_5a1543682e4ad921 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
const ret = getObject(arg0).transaction(getStringFromWasm0(arg1, arg2), ["readonly","readwrite","versionchange","readwriteflush","cleanup",][arg3]);
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_transaction_66168ca19ab39a78 = function() { return handleError(function (arg0, arg1, arg2) {
const ret = getObject(arg0).transaction(getObject(arg1), ["readonly","readwrite","versionchange","readwriteflush","cleanup",][arg2]);
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_item_5a55aebc84c52f29 = function(arg0, arg1, arg2) {
const ret = getObject(arg1).item(arg2 >>> 0);
var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
var len1 = WASM_VECTOR_LEN;
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
};
module.exports.__wbg_count_bb99b5211d93738d = function() { return handleError(function (arg0) {
const ret = getObject(arg0).count();
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_get_b51eae1c0542125a = function() { return handleError(function (arg0, arg1) {
const ret = getObject(arg0).get(getObject(arg1));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_getAll_789d8b6775c0f8de = function() { return handleError(function (arg0) {
const ret = getObject(arg0).getAll();
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_getAll_e51dc29fdf0c6915 = function() { return handleError(function (arg0, arg1, arg2) {
const ret = getObject(arg0).getAll(getObject(arg1), arg2 >>> 0);
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_openCursor_3e5f2356f0515f34 = function() { return handleError(function (arg0) {
const ret = getObject(arg0).openCursor();
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_setunique_6f46c3f803001492 = function(arg0, arg1) {
getObject(arg0).unique = arg1 !== 0;
};
module.exports.__wbg_oldVersion_74205b5e4698efc3 = function(arg0) {
const ret = getObject(arg0).oldVersion;
return ret;
};
module.exports.__wbg_queueMicrotask_12a30234db4045d3 = function(arg0) {
queueMicrotask(getObject(arg0));
};
module.exports.__wbg_queueMicrotask_48421b3cc9052b68 = function(arg0) {
const ret = getObject(arg0).queueMicrotask;
return addHeapObject(ret);
};
module.exports.__wbindgen_is_function = function(arg0) {
const ret = typeof(getObject(arg0)) === 'function';
return ret;
};
module.exports.__wbg_clearTimeout_541ac0980ffcef74 = function(arg0) {
const ret = clearTimeout(takeObject(arg0));
return addHeapObject(ret);
};
module.exports.__wbg_setTimeout_7d81d052875b0f4f = function() { return handleError(function (arg0, arg1) {
const ret = setTimeout(getObject(arg0), arg1);
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_performance_a1b8bde2ee512264 = function(arg0) {
const ret = getObject(arg0).performance;
return addHeapObject(ret);
};
module.exports.__wbg_now_abd80e969af37148 = function(arg0) {
const ret = getObject(arg0).now();
return ret;
};
module.exports.__wbg_crypto_1d1f22824a6a080c = function(arg0) {
const ret = getObject(arg0).crypto;
return addHeapObject(ret);
};
module.exports.__wbg_process_4a72847cc503995b = function(arg0) {
const ret = getObject(arg0).process;
return addHeapObject(ret);
};
module.exports.__wbg_versions_f686565e586dd935 = function(arg0) {
const ret = getObject(arg0).versions;
return addHeapObject(ret);
};
module.exports.__wbg_node_104a2ff8d6ea03a2 = function(arg0) {
const ret = getObject(arg0).node;
return addHeapObject(ret);
};
module.exports.__wbindgen_is_string = function(arg0) {
const ret = typeof(getObject(arg0)) === 'string';
return ret;
};
module.exports.__wbg_require_cca90b1a94a0255b = function() { return handleError(function () {
const ret = module.require;
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_msCrypto_eb05e62b530a1508 = function(arg0) {
const ret = getObject(arg0).msCrypto;
return addHeapObject(ret);
};
module.exports.__wbg_randomFillSync_5c9c955aa56b6049 = function() { return handleError(function (arg0, arg1) {
getObject(arg0).randomFillSync(takeObject(arg1));
}, arguments) };
module.exports.__wbg_getRandomValues_3aa56aa6edec874c = function() { return handleError(function (arg0, arg1) {
getObject(arg0).getRandomValues(getObject(arg1));
}, arguments) };
module.exports.__wbg_length_ae22078168b726f5 = function(arg0) {
const ret = getObject(arg0).length;
return ret;
};
module.exports.__wbg_new_a220cf903aa02ca2 = function() {
const ret = new Array();
return addHeapObject(ret);
};
module.exports.__wbg_newnoargs_76313bd6ff35d0f2 = function(arg0, arg1) {
const ret = new Function(getStringFromWasm0(arg0, arg1));
return addHeapObject(ret);
};
module.exports.__wbg_new_8608a2b51a5f6737 = function() {
const ret = new Map();
return addHeapObject(ret);
};
module.exports.__wbg_next_de3e9db4440638b2 = function(arg0) {
const ret = getObject(arg0).next;
return addHeapObject(ret);
};
module.exports.__wbg_value_6d39332ab4788d86 = function(arg0) {
const ret = getObject(arg0).value;
return addHeapObject(ret);
};
module.exports.__wbg_iterator_888179a48810a9fe = function() {
const ret = Symbol.iterator;
return addHeapObject(ret);
};
module.exports.__wbg_new_525245e2b9901204 = function() {
const ret = new Object();
return addHeapObject(ret);
};
module.exports.__wbg_new_0d215095f6a3600f = function(arg0) {
const ret = new Set(getObject(arg0));
return addHeapObject(ret);
};
module.exports.__wbg_self_3093d5d1f7bcb682 = function() { return handleError(function () {
const ret = self.self;
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_window_3bcfc4d31bc012f8 = function() { return handleError(function () {
const ret = window.window;
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_globalThis_86b222e13bdf32ed = function() { return handleError(function () {
const ret = globalThis.globalThis;
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_global_e5a3fe56f8be9485 = function() { return handleError(function () {
const ret = global.global;
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_at_5fa66069579ac579 = function(arg0, arg1) {
const ret = getObject(arg0).at(arg1);
return addHeapObject(ret);
};
module.exports.__wbg_get_3baa728f9d58d3f6 = function(arg0, arg1) {
const ret = getObject(arg0)[arg1 >>> 0];
return addHeapObject(ret);
};
module.exports.__wbg_set_673dda6c73d19609 = function(arg0, arg1, arg2) {
getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
};
module.exports.__wbg_from_0791d740a9d37830 = function(arg0) {
const ret = Array.from(getObject(arg0));
return addHeapObject(ret);
};
module.exports.__wbg_isArray_8364a5371e9737d8 = function(arg0) {
const ret = Array.isArray(getObject(arg0));
return ret;
};
module.exports.__wbg_push_37c89022f34c01ca = function(arg0, arg1) {
const ret = getObject(arg0).push(getObject(arg1));
return ret;
};
module.exports.__wbg_instanceof_ArrayBuffer_61dfc3198373c902 = function(arg0) {
let result;
try {
result = getObject(arg0) instanceof ArrayBuffer;
} catch (_) {
result = false;
}
const ret = result;
return ret;
};
module.exports.__wbg_call_1084a111329e68ce = function() { return handleError(function (arg0, arg1) {
const ret = getObject(arg0).call(getObject(arg1));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_call_89af060b4e1523f2 = function() { return handleError(function (arg0, arg1, arg2) {
const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_call_c6fe275aaa60da79 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_call_7de908392845a9a5 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3), getObject(arg4));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_instanceof_Map_763ce0e95960d55e = function(arg0) {
let result;
try {
result = getObject(arg0) instanceof Map;
} catch (_) {
result = false;
}
const ret = result;
return ret;
};
module.exports.__wbg_set_49185437f0ab06f8 = function(arg0, arg1, arg2) {
const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
return addHeapObject(ret);
};
module.exports.__wbg_entries_2f5ddf03b53c6730 = function(arg0) {
const ret = getObject(arg0).entries();
return addHeapObject(ret);
};
module.exports.__wbg_next_f9cb570345655b9a = function() { return handleError(function (arg0) {
const ret = getObject(arg0).next();
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_done_bfda7aa8f252b39f = function(arg0) {
const ret = getObject(arg0).done;
return ret;
};
module.exports.__wbg_isSafeInteger_7f1ed56200d90674 = function(arg0) {
const ret = Number.isSafeInteger(getObject(arg0));
return ret;
};
module.exports.__wbg_getTime_91058879093a1589 = function(arg0) {
const ret = getObject(arg0).getTime();
return ret;
};
module.exports.__wbg_new_7982fb43cfca37ae = function(arg0) {
const ret = new Date(getObject(arg0));
return addHeapObject(ret);
};
module.exports.__wbg_now_b7a162010a9e75b4 = function() {
const ret = Date.now();
return ret;
};
module.exports.__wbg_entries_7a0e06255456ebcd = function(arg0) {
const ret = Object.entries(getObject(arg0));
return addHeapObject(ret);
};
module.exports.__wbg_add_653baf3821a15934 = function(arg0, arg1) {
const ret = getObject(arg0).add(getObject(arg1));
return addHeapObject(ret);
};
module.exports.__wbg_values_fb3a48a5a8c681f6 = function(arg0) {
const ret = getObject(arg0).values();
return addHeapObject(ret);
};
module.exports.__wbg_instanceof_Promise_ae8c7ffdec83f2ae = function(arg0) {
let result;
try {
result = getObject(arg0) instanceof Promise;
} catch (_) {
result = false;
}
const ret = result;
return ret;
};
module.exports.__wbg_new_b85e72ed1bfd57f9 = function(arg0, arg1) {
try {
var state0 = {a: arg0, b: arg1};
var cb0 = (arg0, arg1) => {
const a = state0.a;
state0.a = 0;
try {
return __wbg_adapter_892(a, state0.b, arg0, arg1);
} finally {
state0.a = a;
}
};
const ret = new Promise(cb0);
return addHeapObject(ret);
} finally {
state0.a = state0.b = 0;
}
};
module.exports.__wbg_resolve_570458cb99d56a43 = function(arg0) {
const ret = Promise.resolve(getObject(arg0));
return addHeapObject(ret);
};
module.exports.__wbg_then_95e6edc0f89b73b1 = function(arg0, arg1) {
const ret = getObject(arg0).then(getObject(arg1));
return addHeapObject(ret);
};
module.exports.__wbg_then_876bb3c633745cc6 = function(arg0, arg1, arg2) {
const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
return addHeapObject(ret);
};
module.exports.__wbg_buffer_b7b08af79b0b0974 = function(arg0) {
const ret = getObject(arg0).buffer;
return addHeapObject(ret);
};
module.exports.__wbg_newwithbyteoffsetandlength_8a2cb9ca96b27ec9 = function(arg0, arg1, arg2) {
const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
return addHeapObject(ret);
};
module.exports.__wbg_new_ea1883e1e5e86686 = function(arg0) {
const ret = new Uint8Array(getObject(arg0));
return addHeapObject(ret);
};
module.exports.__wbg_newwithbyteoffsetandlength_94126d2ad22a595c = function(arg0, arg1, arg2) {
const ret = new Uint8ClampedArray(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
return addHeapObject(ret);
};
module.exports.__wbg_new_e36b5ccdd852e18d = function(arg0) {
const ret = new Uint8ClampedArray(getObject(arg0));
return addHeapObject(ret);
};
module.exports.__wbg_instanceof_Uint8Array_247a91427532499e = function(arg0) {
let result;
try {
result = getObject(arg0) instanceof Uint8Array;
} catch (_) {
result = false;
}
const ret = result;
return ret;
};
module.exports.__wbg_newwithlength_ec548f448387c968 = function(arg0) {
const ret = new Uint8Array(arg0 >>> 0);
return addHeapObject(ret);
};
module.exports.__wbg_subarray_7c2e3576afe181d1 = function(arg0, arg1, arg2) {
const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
return addHeapObject(ret);
};
module.exports.__wbg_length_8339fcf5d8ecd12e = function(arg0) {
const ret = getObject(arg0).length;
return ret;
};
module.exports.__wbg_set_d1e79e2388520f18 = function(arg0, arg1, arg2) {
getObject(arg0).set(getObject(arg1), arg2 >>> 0);
};
module.exports.__wbg_newwithlength_dfb862b757677cfc = function(arg0) {
const ret = new Uint8ClampedArray(arg0 >>> 0);
return addHeapObject(ret);
};
module.exports.__wbg_length_701cb851fad911df = function(arg0) {
const ret = getObject(arg0).length;
return ret;
};
module.exports.__wbg_set_b68cc6ecd92a1101 = function(arg0, arg1, arg2) {
getObject(arg0).set(getObject(arg1), arg2 >>> 0);
};
module.exports.__wbg_get_224d16597dbbfd96 = function() { return handleError(function (arg0, arg1) {
const ret = Reflect.get(getObject(arg0), getObject(arg1));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_parse_52202f117ec9ecfa = function() { return handleError(function (arg0, arg1) {
const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbg_stringify_bbf45426c92a6bf5 = function() { return handleError(function (arg0) {
const ret = JSON.stringify(getObject(arg0));
return addHeapObject(ret);
}, arguments) };
module.exports.__wbindgen_bigint_get_as_i64 = function(arg0, arg1) {
const v = getObject(arg1);
const ret = typeof(v) === 'bigint' ? v : undefined;
getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
};
module.exports.__wbindgen_debug_string = function(arg0, arg1) {
const ret = debugString(getObject(arg1));
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
};
module.exports.__wbindgen_throw = function(arg0, arg1) {
throw new Error(getStringFromWasm0(arg0, arg1));
};
module.exports.__wbindgen_memory = function() {
const ret = wasm.memory;
return addHeapObject(ret);
};
module.exports.__wbindgen_closure_wrapper5381 = function(arg0, arg1, arg2) {
const ret = makeMutClosure(arg0, arg1, 295, __wbg_adapter_56);
return addHeapObject(ret);
};
module.exports.__wbindgen_closure_wrapper12805 = function(arg0, arg1, arg2) {
const ret = makeClosure(arg0, arg1, 1828, __wbg_adapter_59);
return addHeapObject(ret);
};
module.exports.__wbindgen_closure_wrapper12807 = function(arg0, arg1, arg2) {
const ret = makeClosure(arg0, arg1, 1828, __wbg_adapter_62);
return addHeapObject(ret);
};
module.exports.__wbindgen_closure_wrapper20889 = function(arg0, arg1, arg2) {
const ret = makeMutClosure(arg0, arg1, 2684, __wbg_adapter_65);
return addHeapObject(ret);
};
module.exports.__wbindgen_closure_wrapper21304 = function(arg0, arg1, arg2) {
const ret = makeMutClosure(arg0, arg1, 2801, __wbg_adapter_68);
return addHeapObject(ret);
};
// Initially, 'wasm' is set to a Proxy object which will synchronously load the WebAssembly module and
// replace 'wasm' with a reference to the exports from the wasm module.
//
// Ideally this will never get used because the application will call initAsync instead.
wasm = new Proxy(
{},
{
get: (target, prop, receiver) => __initSync()[prop],
},
);
let inited = false;
const __initSync = function () {
if (inited) {
return;
}
if (initPromise) {
throw new Error("Asynchronous initialisation already in progress: cannot initialise synchronously");
}
const bytes = unbase64(require("./matrix_sdk_crypto_wasm_bg.wasm.js"));
const mod = new WebAssembly.Module(bytes);
const instance = new WebAssembly.Instance(mod, imports);
wasm = instance.exports;
wasm.__wbindgen_start();
inited = true;
return wasm;
};
let initPromise = null;
/**
* Load the WebAssembly module in the background, if it has not already been loaded.
*
* Returns a promise which will resolve once the other methods are ready.
*
* @returns {Promise<void>}
*/
module.exports.initAsync = function () {
if (inited) {
return Promise.resolve();
}
if (!initPromise) {
initPromise = Promise.resolve()
.then(() => require("./matrix_sdk_crypto_wasm_bg.wasm.js"))
.then((b64) => WebAssembly.instantiate(unbase64(b64), imports))
.then((result) => {
wasm = result.instance.exports;
wasm.__wbindgen_start();
inited = true;
});
}
return initPromise;
};
const b64lookup = new Uint8Array([
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 62, 0, 62, 0, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0, 63, 0, 26, 27, 28, 29, 30, 31, 32,
33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
]);
// base64 decoder, based on the code at https://developer.mozilla.org/en-US/docs/Glossary/Base64#solution_2_%E2%80%93_rewriting_atob_and_btoa_using_typedarrays_and_utf-8
function unbase64(sBase64) {
const sB64Enc = sBase64.replace(/[^A-Za-z0-9+/]/g, "");
const nInLen = sB64Enc.length;
const nOutLen = (nInLen * 3 + 1) >> 2;
const taBytes = new Uint8Array(nOutLen);
let nMod3;
let nMod4;
let nUint24 = 0;
let nOutIdx = 0;
for (let nInIdx = 0; nInIdx < nInLen; nInIdx++) {
nMod4 = nInIdx & 3;
nUint24 |= b64lookup[sB64Enc.charCodeAt(nInIdx)] << (6 * (3 - nMod4));
if (nMod4 === 3 || nInLen - nInIdx === 1) {
nMod3 = 0;
while (nMod3 < 3 && nOutIdx < nOutLen) {
taBytes[nOutIdx] = (nUint24 >>> ((16 >>> nMod3) & 24)) & 255;
nMod3++;
nOutIdx++;
}
nUint24 = 0;
}
}
return taBytes;
}