@openclaw/matrix 2026.7.1-beta.1 → 2026.7.1-beta.4

package/node_modules/matrix-js-sdk/lib/rust-crypto/secret-storage.js

@@ -1,4 +1,3 @@
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 /*
 Copyright 2023 The Matrix.org Foundation C.I.C.
 
@@ -23,8 +22,8 @@ limitations under the License.
  *
  * @internal
  */
-export function secretStorageContainsCrossSigningKeys(_x) {
-  return _secretStorageContainsCrossSigningKeys.apply(this, arguments);
+export async function secretStorageContainsCrossSigningKeys(secretStorage) {
+  return secretStorageCanAccessSecrets(secretStorage, ["m.cross_signing.master", "m.cross_signing.user_signing", "m.cross_signing.self_signing"]);
 }
 
 /**
@@ -37,27 +36,15 @@ export function secretStorageContainsCrossSigningKeys(_x) {
  *
  * @internal
  */
-function _secretStorageContainsCrossSigningKeys() {
-  _secretStorageContainsCrossSigningKeys = _asyncToGenerator(function* (secretStorage) {
-    return secretStorageCanAccessSecrets(secretStorage, ["m.cross_signing.master", "m.cross_signing.user_signing", "m.cross_signing.self_signing"]);
-  });
-  return _secretStorageContainsCrossSigningKeys.apply(this, arguments);
-}
-export function secretStorageCanAccessSecrets(_x2, _x3) {
-  return _secretStorageCanAccessSecrets.apply(this, arguments);
-}
-function _secretStorageCanAccessSecrets() {
-  _secretStorageCanAccessSecrets = _asyncToGenerator(function* (secretStorage, secretNames) {
-    var defaultKeyId = yield secretStorage.getDefaultKeyId();
-    if (!defaultKeyId) return false;
-    for (var secretName of secretNames) {
-      // check which keys this particular secret is encrypted with
-      var record = (yield secretStorage.isStored(secretName)) || {};
-      // if it's not encrypted with the right key, there is no point continuing
-      if (!(defaultKeyId in record)) return false;
-    }
-    return true;
-  });
-  return _secretStorageCanAccessSecrets.apply(this, arguments);
+export async function secretStorageCanAccessSecrets(secretStorage, secretNames) {
+  const defaultKeyId = await secretStorage.getDefaultKeyId();
+  if (!defaultKeyId) return false;
+  for (const secretName of secretNames) {
+    // check which keys this particular secret is encrypted with
+    const record = (await secretStorage.isStored(secretName)) || {};
+    // if it's not encrypted with the right key, there is no point continuing
+    if (!(defaultKeyId in record)) return false;
+  }
+  return true;
 }
 //# sourceMappingURL=secret-storage.js.map

package/node_modules/matrix-js-sdk/lib/rust-crypto/secret-storage.js.map

@@ -1 +1 @@
-{"version":3,"file":"secret-storage.js","names":["secretStorageContainsCrossSigningKeys","_x","_secretStorageContainsCrossSigningKeys","apply","arguments","_asyncToGenerator","secretStorage","secretStorageCanAccessSecrets","_x2","_x3","_secretStorageCanAccessSecrets","secretNames","defaultKeyId","getDefaultKeyId","secretName","record","isStored"],"sources":["../../src/rust-crypto/secret-storage.ts"],"sourcesContent":["/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type SecretStorageKey, type ServerSideSecretStorage } from \"../secret-storage.ts\";\n\n/**\n * Check that the private cross signing keys (master, self signing, user signing) are stored in the secret storage and encrypted with the default secret storage key.\n *\n * @param secretStorage - The secret store using account data\n * @returns True if the cross-signing keys are all stored and encrypted with the same secret storage key.\n *\n * @internal\n */\nexport async function secretStorageContainsCrossSigningKeys(secretStorage: ServerSideSecretStorage): Promise<boolean> {\n    return secretStorageCanAccessSecrets(secretStorage, [\n        \"m.cross_signing.master\",\n        \"m.cross_signing.user_signing\",\n        \"m.cross_signing.self_signing\",\n    ]);\n}\n\n/**\n *\n * Check that the secret storage can access the given secrets using the default key.\n *\n * @param secretStorage - The secret store using account data\n * @param secretNames - The secret names to check\n * @returns True if all the given secrets are accessible and encrypted with the given key.\n *\n * @internal\n */\nexport async function secretStorageCanAccessSecrets(\n    secretStorage: ServerSideSecretStorage,\n    secretNames: SecretStorageKey[],\n): Promise<boolean> {\n    const defaultKeyId = await secretStorage.getDefaultKeyId();\n    if (!defaultKeyId) return false;\n\n    for (const secretName of secretNames) {\n        // check which keys this particular secret is encrypted with\n        const record = (await secretStorage.isStored(secretName)) || {};\n        // if it's not encrypted with the right key, there is no point continuing\n        if (!(defaultKeyId in record)) return false;\n    }\n\n    return true;\n}\n"],"mappings":";AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAsBA,qCAAqCA,CAAAC,EAAA;EAAA,OAAAC,sCAAA,CAAAC,KAAA,OAAAC,SAAA;AAAA;;AAQ3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AATA,SAAAF,uCAAA;EAAAA,sCAAA,GAAAG,iBAAA,CARO,WAAqDC,aAAsC,EAAoB;IAClH,OAAOC,6BAA6B,CAACD,aAAa,EAAE,CAChD,wBAAwB,EACxB,8BAA8B,EAC9B,8BAA8B,CACjC,CAAC;EACN,CAAC;EAAA,OAAAJ,sCAAA,CAAAC,KAAA,OAAAC,SAAA;AAAA;AAYD,gBAAsBG,6BAA6BA,CAAAC,GAAA,EAAAC,GAAA;EAAA,OAAAC,8BAAA,CAAAP,KAAA,OAAAC,SAAA;AAAA;AAelD,SAAAM,+BAAA;EAAAA,8BAAA,GAAAL,iBAAA,CAfM,WACHC,aAAsC,EACtCK,WAA+B,EACf;IAChB,IAAMC,YAAY,SAASN,aAAa,CAACO,eAAe,CAAC,CAAC;IAC1D,IAAI,CAACD,YAAY,EAAE,OAAO,KAAK;IAE/B,KAAK,IAAME,UAAU,IAAIH,WAAW,EAAE;MAClC;MACA,IAAMI,MAAM,GAAG,OAAOT,aAAa,CAACU,QAAQ,CAACF,UAAU,CAAC,KAAK,CAAC,CAAC;MAC/D;MACA,IAAI,EAAEF,YAAY,IAAIG,MAAM,CAAC,EAAE,OAAO,KAAK;IAC/C;IAEA,OAAO,IAAI;EACf,CAAC;EAAA,OAAAL,8BAAA,CAAAP,KAAA,OAAAC,SAAA;AAAA","ignoreList":[]}
+{"version":3,"file":"secret-storage.js","names":[],"sources":["../../src/rust-crypto/secret-storage.ts"],"sourcesContent":["/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type SecretStorageKey, type ServerSideSecretStorage } from \"../secret-storage.ts\";\n\n/**\n * Check that the private cross signing keys (master, self signing, user signing) are stored in the secret storage and encrypted with the default secret storage key.\n *\n * @param secretStorage - The secret store using account data\n * @returns True if the cross-signing keys are all stored and encrypted with the same secret storage key.\n *\n * @internal\n */\nexport async function secretStorageContainsCrossSigningKeys(secretStorage: ServerSideSecretStorage): Promise<boolean> {\n    return secretStorageCanAccessSecrets(secretStorage, [\n        \"m.cross_signing.master\",\n        \"m.cross_signing.user_signing\",\n        \"m.cross_signing.self_signing\",\n    ]);\n}\n\n/**\n *\n * Check that the secret storage can access the given secrets using the default key.\n *\n * @param secretStorage - The secret store using account data\n * @param secretNames - The secret names to check\n * @returns True if all the given secrets are accessible and encrypted with the given key.\n *\n * @internal\n */\nexport async function secretStorageCanAccessSecrets(\n    secretStorage: ServerSideSecretStorage,\n    secretNames: SecretStorageKey[],\n): Promise<boolean> {\n    const defaultKeyId = await secretStorage.getDefaultKeyId();\n    if (!defaultKeyId) return false;\n\n    for (const secretName of secretNames) {\n        // check which keys this particular secret is encrypted with\n        const record = (await secretStorage.isStored(secretName)) || {};\n        // if it's not encrypted with the right key, there is no point continuing\n        if (!(defaultKeyId in record)) return false;\n    }\n\n    return true;\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAe,qCAAqC,CAAC,aAAsC,EAAoB;EAClH,OAAO,6BAA6B,CAAC,aAAa,EAAE,CAChD,wBAAwB,EACxB,8BAA8B,EAC9B,8BAA8B,CACjC,CAAC;AACN;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAe,6BAA6B,CAC/C,aAAsC,EACtC,WAA+B,EACf;EAChB,MAAM,YAAY,GAAG,MAAM,aAAa,CAAC,eAAe,CAAC,CAAC;EAC1D,IAAI,CAAC,YAAY,EAAE,OAAO,KAAK;EAE/B,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE;IAClC;IACA,MAAM,MAAM,GAAG,CAAC,MAAM,aAAa,CAAC,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IAC/D;IACA,IAAI,EAAE,YAAY,IAAI,MAAM,CAAC,EAAE,OAAO,KAAK;EAC/C;EAEA,OAAO,IAAI;AACf","ignoreList":[]}

package/node_modules/matrix-js-sdk/lib/rust-crypto/verification.js

@@ -1,5 +1,3 @@
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 /*
 Copyright 2023 The Matrix.org Foundation C.I.C.
@@ -42,10 +40,12 @@ export class RustVerificationRequest extends TypedEventEmitter {
   constructor(logger, olmMachine, inner, outgoingRequestProcessor, supportedVerificationMethods) {
     super();
     /** a reëmitter which relays VerificationRequestEvent.Changed events emitted by the verifier */
+    _defineProperty(this, "reEmitter", void 0);
     /** Are we in the process of sending an `m.key.verification.ready` event? */
     _defineProperty(this, "_accepting", false);
     /** Are we in the process of sending an `m.key.verification.cancellation` event? */
     _defineProperty(this, "_cancelling", false);
+    _defineProperty(this, "_verifier", void 0);
     this.logger = logger;
     this.olmMachine = olmMachine;
     this.inner = inner;
@@ -59,18 +59,15 @@ export class RustVerificationRequest extends TypedEventEmitter {
     //
     // To avoid this reference cycle, use a weak reference in the callback function. If the `RustVerificationRequest`
     // gets garbage-collected, then there is nothing to update!
-    var weakThis = new WeakRef(this);
-    inner.registerChangesCallback(/*#__PURE__*/_asyncToGenerator(function* () {
-      var _weakThis$deref;
-      return (_weakThis$deref = weakThis.deref()) === null || _weakThis$deref === void 0 ? void 0 : _weakThis$deref.onChange();
-    }));
+    const weakThis = new WeakRef(this);
+    inner.registerChangesCallback(async () => weakThis.deref()?.onChange());
   }
 
   /**
    * Hook which is called when the underlying rust class notifies us that there has been a change.
    */
   onChange() {
-    var verification = this.inner.getVerification();
+    const verification = this.inner.getVerification();
 
     // Set the _verifier object (wrapping the rust `Verification` as a js-sdk Verifier) if:
     // - we now have a `Verification` where we lacked one before
@@ -112,8 +109,7 @@ export class RustVerificationRequest extends TypedEventEmitter {
    * For to-device verifications, `undefined`.
    */
   get roomId() {
-    var _this$inner$roomId;
-    return (_this$inner$roomId = this.inner.roomId) === null || _this$inner$roomId === void 0 ? void 0 : _this$inner$roomId.toString();
+    return this.inner.roomId?.toString();
   }
 
   /**
@@ -133,20 +129,16 @@ export class RustVerificationRequest extends TypedEventEmitter {
 
   /** For verifications via to-device messages: the ID of the other device. Otherwise, undefined. */
   get otherDeviceId() {
-    var _this$inner$otherDevi;
-    return (_this$inner$otherDevi = this.inner.otherDeviceId) === null || _this$inner$otherDevi === void 0 ? void 0 : _this$inner$otherDevi.toString();
+    return this.inner.otherDeviceId?.toString();
   }
 
   /** Get the other device involved in the verification, if it is known */
-  getOtherDevice() {
-    var _this = this;
-    return _asyncToGenerator(function* () {
-      var otherDeviceId = _this.inner.otherDeviceId;
-      if (!otherDeviceId) {
-        return undefined;
-      }
-      return yield _this.olmMachine.getDevice(_this.inner.otherUserId, otherDeviceId, 5);
-    })();
+  async getOtherDevice() {
+    const otherDeviceId = this.inner.otherDeviceId;
+    if (!otherDeviceId) {
+      return undefined;
+    }
+    return await this.olmMachine.getDevice(this.inner.otherUserId, otherDeviceId, 5);
   }
 
   /** True if the other party in this request is one of this user's own devices. */
@@ -156,7 +148,7 @@ export class RustVerificationRequest extends TypedEventEmitter {
 
   /** current phase of the request. */
   get phase() {
-    var phase = this.inner.phase();
+    const phase = this.inner.phase();
     switch (phase) {
       case RustSdkCryptoJs.VerificationRequestPhase.Created:
       case RustSdkCryptoJs.VerificationRequestPhase.Requested:
@@ -176,7 +168,7 @@ export class RustVerificationRequest extends TypedEventEmitter {
       case RustSdkCryptoJs.VerificationRequestPhase.Cancelled:
         return VerificationPhase.Cancelled;
     }
-    throw new Error("Unknown verification phase ".concat(phase));
+    throw new Error(`Unknown verification phase ${phase}`);
   }
 
   /** True if the request has sent its initial event and needs more events to complete
@@ -184,7 +176,7 @@ export class RustVerificationRequest extends TypedEventEmitter {
    */
   get pending() {
     if (this.inner.isPassive()) return false;
-    var phase = this.phase;
+    const phase = this.phase;
     return phase !== VerificationPhase.Done && phase !== VerificationPhase.Cancelled;
   }
 
@@ -221,7 +213,7 @@ export class RustVerificationRequest extends TypedEventEmitter {
   /** the method picked in the .start event */
   get chosenMethod() {
     if (this.phase !== VerificationPhase.Started) return null;
-    var verification = this.inner.getVerification();
+    const verification = this.inner.getVerification();
     if (verification instanceof RustSdkCryptoJs.Sas) {
       return VerificationMethod.Sas;
     } else if (verification instanceof RustSdkCryptoJs.Qr) {
@@ -241,12 +233,12 @@ export class RustVerificationRequest extends TypedEventEmitter {
    * @returns true if the other party said they supported the method
    */
   otherPartySupportsMethod(method) {
-    var theirMethods = this.inner.theirSupportedMethods;
+    const theirMethods = this.inner.theirSupportedMethods;
     if (theirMethods === undefined) {
       // no message from the other side yet
       return false;
     }
-    var requiredMethod = verificationMethodsByIdentifier[method];
+    const requiredMethod = verificationMethodsByIdentifier[method];
     return theirMethods.some(m => m === requiredMethod);
   }
 
@@ -255,25 +247,22 @@ export class RustVerificationRequest extends TypedEventEmitter {
    *
    * @returns Promise which resolves when the event has been sent.
    */
-  accept() {
-    var _this2 = this;
-    return _asyncToGenerator(function* () {
-      if (_this2.inner.phase() !== RustSdkCryptoJs.VerificationRequestPhase.Requested || _this2._accepting) {
-        throw new Error("Cannot accept a verification request in phase ".concat(_this2.phase));
-      }
-      _this2._accepting = true;
-      try {
-        var req = _this2.inner.acceptWithMethods(_this2.supportedVerificationMethods.map(verificationMethodIdentifierToMethod));
-        if (req) {
-          yield _this2.outgoingRequestProcessor.makeOutgoingRequest(req);
-        }
-      } finally {
-        _this2._accepting = false;
+  async accept() {
+    if (this.inner.phase() !== RustSdkCryptoJs.VerificationRequestPhase.Requested || this._accepting) {
+      throw new Error(`Cannot accept a verification request in phase ${this.phase}`);
+    }
+    this._accepting = true;
+    try {
+      const req = this.inner.acceptWithMethods(this.supportedVerificationMethods.map(verificationMethodIdentifierToMethod));
+      if (req) {
+        await this.outgoingRequestProcessor.makeOutgoingRequest(req);
       }
+    } finally {
+      this._accepting = false;
+    }
 
-      // phase may have changed, so emit a 'change' event
-      _this2.emit(VerificationRequestEvent.Change);
-    })();
+    // phase may have changed, so emit a 'change' event
+    this.emit(VerificationRequestEvent.Change);
   }
 
   /**
@@ -284,24 +273,21 @@ export class RustVerificationRequest extends TypedEventEmitter {
    *
    * @returns Promise which resolves when the event has been sent.
    */
-  cancel(params) {
-    var _this3 = this;
-    return _asyncToGenerator(function* () {
-      if (_this3._cancelling) {
-        // already cancelling; do nothing
-        return;
-      }
-      _this3.logger.info("Cancelling verification request with params:", params);
-      _this3._cancelling = true;
-      try {
-        var req = _this3.inner.cancel();
-        if (req) {
-          yield _this3.outgoingRequestProcessor.makeOutgoingRequest(req);
-        }
-      } finally {
-        _this3._cancelling = false;
+  async cancel(params) {
+    if (this._cancelling) {
+      // already cancelling; do nothing
+      return;
+    }
+    this.logger.info("Cancelling verification request with params:", params);
+    this._cancelling = true;
+    try {
+      const req = this.inner.cancel();
+      if (req) {
+        await this.outgoingRequestProcessor.makeOutgoingRequest(req);
       }
-    })();
+    } finally {
+      this._cancelling = false;
+    }
   }
 
   /**
@@ -330,30 +316,26 @@ export class RustVerificationRequest extends TypedEventEmitter {
    *
    * @param method - the name of the verification method to use.
    */
-  startVerification(method) {
-    var _this4 = this;
-    return _asyncToGenerator(function* () {
-      if (method !== VerificationMethod.Sas) {
-        throw new Error("Unsupported verification method ".concat(method));
-      }
+  async startVerification(method) {
+    if (method !== VerificationMethod.Sas) {
+      throw new Error(`Unsupported verification method ${method}`);
+    }
 
-      // make sure that we have a list of the other user's devices (workaround https://github.com/matrix-org/matrix-rust-sdk/issues/2896)
-      if (!(yield _this4.getOtherDevice())) {
-        throw new Error("startVerification(): other device is unknown");
-      }
-      var res = yield _this4.inner.startSas();
-      if (res) {
-        var _res = _slicedToArray(res, 2),
-          req = _res[1];
-        yield _this4.outgoingRequestProcessor.makeOutgoingRequest(req);
-      }
+    // make sure that we have a list of the other user's devices (workaround https://github.com/matrix-org/matrix-rust-sdk/issues/2896)
+    if (!(await this.getOtherDevice())) {
+      throw new Error("startVerification(): other device is unknown");
+    }
+    const res = await this.inner.startSas();
+    if (res) {
+      const [, req] = res;
+      await this.outgoingRequestProcessor.makeOutgoingRequest(req);
+    }
 
-      // this should have triggered the onChange callback, and we should now have a verifier
-      if (!_this4._verifier) {
-        throw new Error("Still no verifier after startSas() call");
-      }
-      return _this4._verifier;
-    })();
+    // this should have triggered the onChange callback, and we should now have a verifier
+    if (!this._verifier) {
+      throw new Error("Still no verifier after startSas() call");
+    }
+    return this._verifier;
   }
 
   /**
@@ -364,24 +346,21 @@ export class RustVerificationRequest extends TypedEventEmitter {
    * @param qrCodeData - the decoded QR code.
    * @returns A verifier; call `.verify()` on it to wait for the other side to complete the verification flow.
    */
-  scanQRCode(uint8Array) {
-    var _this5 = this;
-    return _asyncToGenerator(function* () {
-      var scan = RustSdkCryptoJs.QrCodeScan.fromBytes(uint8Array);
-      var verifier = yield _this5.inner.scanQrCode(scan);
+  async scanQRCode(uint8Array) {
+    const scan = RustSdkCryptoJs.QrCodeScan.fromBytes(uint8Array);
+    const verifier = await this.inner.scanQrCode(scan);
 
-      // this should have triggered the onChange callback, and we should now have a verifier
-      if (!_this5._verifier) {
-        throw new Error("Still no verifier after scanQrCode() call");
-      }
+    // this should have triggered the onChange callback, and we should now have a verifier
+    if (!this._verifier) {
+      throw new Error("Still no verifier after scanQrCode() call");
+    }
 
-      // we can immediately trigger the reciprocate request
-      var req = verifier.reciprocate();
-      if (req) {
-        yield _this5.outgoingRequestProcessor.makeOutgoingRequest(req);
-      }
-      return _this5._verifier;
-    })();
+    // we can immediately trigger the reciprocate request
+    const req = verifier.reciprocate();
+    if (req) {
+      await this.outgoingRequestProcessor.makeOutgoingRequest(req);
+    }
+    return this._verifier;
   }
 
   /**
@@ -410,18 +389,15 @@ export class RustVerificationRequest extends TypedEventEmitter {
    *
    * Implementation of {@link Crypto.VerificationRequest#generateQRCode}.
    */
-  generateQRCode() {
-    var _this6 = this;
-    return _asyncToGenerator(function* () {
-      // make sure that we have a list of the other user's devices (workaround https://github.com/matrix-org/matrix-rust-sdk/issues/2896)
-      if (!(yield _this6.getOtherDevice())) {
-        throw new Error("generateQRCode(): other device is unknown");
-      }
-      var innerVerifier = yield _this6.inner.generateQrCode();
-      // If we are unable to generate a QRCode, we return undefined
-      if (!innerVerifier) return;
-      return innerVerifier.toBytes();
-    })();
+  async generateQRCode() {
+    // make sure that we have a list of the other user's devices (workaround https://github.com/matrix-org/matrix-rust-sdk/issues/2896)
+    if (!(await this.getOtherDevice())) {
+      throw new Error("generateQRCode(): other device is unknown");
+    }
+    const innerVerifier = await this.inner.generateQrCode();
+    // If we are unable to generate a QRCode, we return undefined
+    if (!innerVerifier) return;
+    return innerVerifier.toBytes();
   }
 
   /**
@@ -429,8 +405,7 @@ export class RustVerificationRequest extends TypedEventEmitter {
    * this verification.
    */
   get cancellationCode() {
-    var _this$inner$cancelInf, _this$inner$cancelInf2;
-    return (_this$inner$cancelInf = (_this$inner$cancelInf2 = this.inner.cancelInfo) === null || _this$inner$cancelInf2 === void 0 ? void 0 : _this$inner$cancelInf2.cancelCode()) !== null && _this$inner$cancelInf !== void 0 ? _this$inner$cancelInf : null;
+    return this.inner.cancelInfo?.cancelCode() ?? null;
   }
 
   /**
@@ -439,7 +414,7 @@ export class RustVerificationRequest extends TypedEventEmitter {
    * Only defined when phase is Cancelled
    */
   get cancellingUserId() {
-    var cancelInfo = this.inner.cancelInfo;
+    const cancelInfo = this.inner.cancelInfo;
     if (!cancelInfo) {
       return undefined;
     } else if (cancelInfo.cancelledbyUs()) {
@@ -457,21 +432,18 @@ export class RustVerificationRequest extends TypedEventEmitter {
  * @internal
  */
 class BaseRustVerifer extends TypedEventEmitter {
-  /** A deferred which completes when the verification completes (or rejects when it is cancelled/fails) */
-
   constructor(inner, outgoingRequestProcessor) {
     super();
+    /** A deferred which completes when the verification completes (or rejects when it is cancelled/fails) */
+    _defineProperty(this, "completionDeferred", void 0);
     this.inner = inner;
     this.outgoingRequestProcessor = outgoingRequestProcessor;
     this.completionDeferred = Promise.withResolvers();
 
     // As with RustVerificationRequest, we need to avoid a reference cycle.
     // See the comments in RustVerificationRequest.
-    var weakThis = new WeakRef(this);
-    inner.registerChangesCallback(/*#__PURE__*/_asyncToGenerator(function* () {
-      var _weakThis$deref2;
-      return (_weakThis$deref2 = weakThis.deref()) === null || _weakThis$deref2 === void 0 ? void 0 : _weakThis$deref2.onChange();
-    }));
+    const weakThis = new WeakRef(this);
+    inner.registerChangesCallback(async () => weakThis.deref()?.onChange());
 
     // stop the runtime complaining if nobody catches a failure
     this.completionDeferred.promise.catch(() => null);
@@ -487,8 +459,8 @@ class BaseRustVerifer extends TypedEventEmitter {
     if (this.inner.isDone()) {
       this.completionDeferred.resolve(undefined);
     } else if (this.inner.isCancelled()) {
-      var cancelInfo = this.inner.cancelInfo();
-      this.completionDeferred.reject(new Error("Verification cancelled by ".concat(cancelInfo.cancelledbyUs() ? "us" : "them", " with code ").concat(cancelInfo.cancelCode(), ": ").concat(cancelInfo.reason())));
+      const cancelInfo = this.inner.cancelInfo();
+      this.completionDeferred.reject(new Error(`Verification cancelled by ${cancelInfo.cancelledbyUs() ? "us" : "them"} with code ${cancelInfo.cancelCode()}: ${cancelInfo.reason()}`));
     }
     this.emit(VerificationRequestEvent.Change);
   }
@@ -517,7 +489,7 @@ class BaseRustVerifer extends TypedEventEmitter {
    */
   cancel(e) {
     // TODO: something with `e`
-    var req = this.inner.cancel();
+    const req = this.inner.cancel();
     if (req) {
       this.outgoingRequestProcessor.makeOutgoingRequest(req);
     }
@@ -570,17 +542,14 @@ export class RustQrCodeVerifier extends BaseRustVerifer {
    * @returns Promise which resolves when the verification has completed, or rejects if the verification is cancelled
    *    or times out.
    */
-  verify() {
-    var _this7 = this;
-    return _asyncToGenerator(function* () {
-      // Some applications (hello, matrix-react-sdk) may not check if there is a `ShowQrCodeCallbacks` and instead
-      // register a `ShowReciprocateQr` listener which they expect to be called once `.verify` is called.
-      if (_this7.callbacks !== null) {
-        _this7.emit(VerifierEvent.ShowReciprocateQr, _this7.callbacks);
-      }
-      // Nothing to do here but wait.
-      yield _this7.completionDeferred.promise;
-    })();
+  async verify() {
+    // Some applications (hello, matrix-react-sdk) may not check if there is a `ShowQrCodeCallbacks` and instead
+    // register a `ShowReciprocateQr` listener which they expect to be called once `.verify` is called.
+    if (this.callbacks !== null) {
+      this.emit(VerifierEvent.ShowReciprocateQr, this.callbacks);
+    }
+    // Nothing to do here but wait.
+    await this.completionDeferred.promise;
   }
 
   /**
@@ -613,7 +582,7 @@ export class RustQrCodeVerifier extends BaseRustVerifer {
       case QrState.Cancelled:
         return VerificationPhase.Cancelled;
       default:
-        throw new Error("Unknown qr code state ".concat(this.inner.state()));
+        throw new Error(`Unknown qr code state ${this.inner.state()}`);
     }
   }
 
@@ -626,14 +595,11 @@ export class RustQrCodeVerifier extends BaseRustVerifer {
   getReciprocateQrCodeCallbacks() {
     return this.callbacks;
   }
-  confirmScanning() {
-    var _this8 = this;
-    return _asyncToGenerator(function* () {
-      var req = _this8.inner.confirmScanning();
-      if (req) {
-        yield _this8.outgoingRequestProcessor.makeOutgoingRequest(req);
-      }
-    })();
+  async confirmScanning() {
+    const req = this.inner.confirmScanning();
+    if (req) {
+      await this.outgoingRequestProcessor.makeOutgoingRequest(req);
+    }
   }
 }
 
@@ -653,38 +619,31 @@ export class RustSASVerifier extends BaseRustVerifer {
    * @returns Promise which resolves when the verification has completed, or rejects if the verification is cancelled
    *    or times out.
    */
-  verify() {
-    var _this9 = this;
-    return _asyncToGenerator(function* () {
-      yield _this9.sendAccept();
-      yield _this9.completionDeferred.promise;
-    })();
+  async verify() {
+    await this.sendAccept();
+    await this.completionDeferred.promise;
   }
 
   /**
    * Send the accept or start event, if it hasn't already been sent
    */
-  sendAccept() {
-    var _this0 = this;
-    return _asyncToGenerator(function* () {
-      var req = _this0.inner.accept();
-      if (req) {
-        yield _this0.outgoingRequestProcessor.makeOutgoingRequest(req);
-      }
-    })();
+  async sendAccept() {
+    const req = this.inner.accept();
+    if (req) {
+      await this.outgoingRequestProcessor.makeOutgoingRequest(req);
+    }
   }
 
   /** if we can now show the callbacks, do so */
   onChange() {
-    var _this1 = this;
     super.onChange();
     if (this.callbacks === null) {
-      var emoji = this.inner.emoji();
-      var decimal = this.inner.decimals();
+      const emoji = this.inner.emoji();
+      const decimal = this.inner.decimals();
       if (emoji === undefined && decimal === undefined) {
         return;
       }
-      var sas = {};
+      const sas = {};
       if (emoji) {
         sas.emoji = emoji.map(e => [e.symbol, e.description]);
       }
@@ -693,26 +652,20 @@ export class RustSASVerifier extends BaseRustVerifer {
       }
       this.callbacks = {
         sas,
-        confirm: function () {
-          var _confirm = _asyncToGenerator(function* () {
-            var requests = yield _this1.inner.confirm();
-            for (var m of requests) {
-              yield _this1.outgoingRequestProcessor.makeOutgoingRequest(m);
-            }
-          });
-          function confirm() {
-            return _confirm.apply(this, arguments);
+        confirm: async () => {
+          const requests = await this.inner.confirm();
+          for (const m of requests) {
+            await this.outgoingRequestProcessor.makeOutgoingRequest(m);
           }
-          return confirm;
-        }(),
+        },
         mismatch: () => {
-          var request = this.inner.cancelWithCode("m.mismatched_sas");
+          const request = this.inner.cancelWithCode("m.mismatched_sas");
           if (request) {
-            this.outgoingRequestProcessor.makeOutgoingRequest(request);
+            void this.outgoingRequestProcessor.makeOutgoingRequest(request);
           }
         },
         cancel: () => {
-          var request = this.inner.cancelWithCode("m.user");
+          const request = this.inner.cancelWithCode("m.user");
           if (request) {
             this.outgoingRequestProcessor.makeOutgoingRequest(request);
           }
@@ -751,11 +704,8 @@ export class RustSASVerifier extends BaseRustVerifer {
 
       // As with RustVerificationRequest, we need to avoid a reference cycle.
       // See the comments in RustVerificationRequest.
-      var weakThis = new WeakRef(this);
-      inner.registerChangesCallback(/*#__PURE__*/_asyncToGenerator(function* () {
-        var _weakThis$deref3;
-        return (_weakThis$deref3 = weakThis.deref()) === null || _weakThis$deref3 === void 0 ? void 0 : _weakThis$deref3.onChange();
-      }));
+      const weakThis = new WeakRef(this);
+      inner.registerChangesCallback(async () => weakThis.deref()?.onChange());
 
       // replaceInner will only get called if we started the verification at the same time as the other side, and we lost
       // the tie breaker.  So we need to re-accept their verification.
@@ -766,7 +716,7 @@ export class RustSASVerifier extends BaseRustVerifer {
 }
 
 /** For each specced verification method, the rust-side `VerificationMethod` corresponding to it */
-var verificationMethodsByIdentifier = {
+const verificationMethodsByIdentifier = {
   [VerificationMethod.Sas]: RustSdkCryptoJs.VerificationMethod.SasV1,
   [VerificationMethod.ScanQrCode]: RustSdkCryptoJs.VerificationMethod.QrCodeScanV1,
   [VerificationMethod.ShowQrCode]: RustSdkCryptoJs.VerificationMethod.QrCodeShowV1,
@@ -783,9 +733,9 @@ var verificationMethodsByIdentifier = {
  * @internal
  */
 export function verificationMethodIdentifierToMethod(method) {
-  var meth = verificationMethodsByIdentifier[method];
+  const meth = verificationMethodsByIdentifier[method];
   if (meth === undefined) {
-    throw new Error("Unknown verification method ".concat(method));
+    throw new Error(`Unknown verification method ${method}`);
   }
   return meth;
 }