+  handle_issue_invite: "resource://gre/modules/lox_wasm.jsm",

+  static ErrorResponse = "ErrorResponse";

+   * Update Lox credential after Lox key rotation.

+   * Do not call directly, use #getPubKeys() instead to start the update only

+   * once.

+  async #updatePubkeys() {

+    let pubKeys = await this.#makeRequest("pubkeys", null);

+      // credentials if so.

+      //

+      // The UpdateCredOption rust struct serializes to "req" rather than

+      // "request".

+      const { updated, req: request } = JSON.parse(

+        lazy.check_lox_pubkeys_update(

+          pubKeys,

+          prevKeys,

+          this.#getCredentials(this.#activeLoxId)

+        )

+      );

+      if (updated) {

+        // Try update credentials.

+        // NOTE: This should be re-callable if any step fails.

+        // TODO: Verify this.

+        // TODO: If this call doesn't succeed due to a networking error, the Lox

+        // credential may be in an unusable state (spent but not updated)

+        // until this request can be completed successfully (and until Lox

+        // is refactored to send repeat responses:

+        // https://gitlab.torproject.org/tpo/anti-censorship/lox/-/issues/74)

+        let response = await this.#makeRequest("updatecred", request);

+        let cred = lazy.handle_update_cred(request, response, pubKeys);

+    this.#pubKeys = pubKeys;

+      this.#pubKeyPromise = this.#updatePubkeys().catch(error => {

+        lazy.logger.debug("Failed to update pubKeys", error);

+        // Try again with the next call.

+        this.#pubKeyPromise = null;

+        if (!this.#pubKeys) {

+          // Re-throw if we have no pubKeys value for the caller.

+          throw error;

+        }

+      });

+      this.#encTablePromise = this.#makeRequest("reachability", null)

+          this.#encTable = encTable;

+      this.#constantsPromise = this.#makeRequest("constants", null)

+          this.#constants = constants;

+    let levelup = false;

+      levelup = await this.#attemptUpgrade(loxId);

+    } catch (error) {

+      lazy.logger.error(error);

+    if (levelup) {

+      const level = this.#getLevel(loxId);

+      const newEvent = {

+        type: "levelup",

+        newlevel: level,

+      };

+      this.#events.push(newEvent);

+      this.#store();

+    }

+

+    let leveldown = false;

+      leveldown = await this.#blockageMigration(loxId);

+    } catch (error) {

+      lazy.logger.error(error);

+    }

+    if (leveldown) {

+      let level = this.#getLevel(loxId);

+      const newEvent = {

+        type: "blockage",

+        newlevel: level,

+      };

+      this.#events.push(newEvent);

+      this.#store();

+

+    if (levelup || leveldown) {

+    let invite = JSON.parse(await this.#makeRequest("invite", null));

+    // NOTE: We currently only handle "open invites".

+    // "trusted invites" are not yet supported. tor-browser#42974.

+    let response;

+    try {

+      response = await this.#makeRequest("openreq", request);

+    } catch (error) {

+      if (error instanceof LoxError && error.code === LoxError.ErrorResponse) {

+        throw new LoxError("Error response to openreq", LoxError.BadInvite);

+      } else {

+        throw error;

+      }

+    let cred = lazy.handle_new_lox_credential(request, response, this.#pubKeys);

+      this.#getCredentials(loxId),

+    let response = await this.#makeRequest("issueinvite", request);

+    // TODO: Do we ever expect handle_issue_invite to fail (beyond

+    // implementation bugs)?

+    // TODO: What happens if #pubkeys for `issue_invite` differs from the value

+    // when calling `handle_issue_invite`? Should we cache the value at the

+    // start of this method?

+    let cred = lazy.handle_issue_invite(request, response, this.#pubKeys);

+

+    // Store the new credentials as a priority.

+    this.#changeCredentials(loxId, cred);

+

+    const invite = lazy.prepare_invite(cred);

+    this.#invites.push(invite);

+    // cap length of stored invites

+    if (this.#invites.len > 50) {

+      this.#invites.shift();

+    this.#store();

+    Services.obs.notifyObservers(null, LoxTopics.NewInvite);

+    // Return a copy.

+    // Right now invite is just a string, but that might change in the future.

+    return structuredClone(invite);

+    // NOTE: If a later method fails, we should be ok to re-call "checkblockage"

+    // from the Lox authority. So there shouldn't be any adverse side effects to

+    // loosing migrationCred.

+    // TODO: Confirm this is safe to lose.

+      response

+      response,

+  /**

+   * Attempts to upgrade the currently saved Lox credential.

+   * If an upgrade is available, save an event in the event list.

+   * @param {string} loxId Lox ID

+   * @returns {boolean} Whether the credential was successfully migrated.

+    let response;

+    try {

+      response = await this.#makeRequest("levelup", request);

+    } catch (error) {

+      if (error instanceof LoxError && error.code === LoxError.ErrorResponse) {

+        // Not an error.

+        lazy.logger.debug("Not ready for level up", error);

+        return false;

+      }

+      throw error;

+    const cred = lazy.handle_level_up(request, response, this.#pubKeys);

+    let request;

+      // This function is called routinely during the background tasks without

+      // previous checks on whether an upgrade is possible, so it is expected to

+      // fail with a certain frequency. Therefore, do not relay the error to the

+      // caller and just log the message for debugging.

+

+    let response = await this.#makeRequest("trustpromo", request);

+    // FIXME: Store response to "trustpromo" in case handle_trust_promotion

+    // or "trustmig" fails. The Lox authority will not accept a re-request

+    // to "trustpromo" with the same credentials.

+    let promoCred = lazy.handle_trust_promotion(request, response);

+    lazy.logger.debug("Formatted promotion cred: ", promoCred);

+

+    request = lazy.trust_migration(

+      this.#getCredentials(loxId),

+      promoCred,

+      this.#pubKeys

+    );

+    response = await this.#makeRequest("trustmig", request);

+    lazy.logger.debug("Got new credential: ", response);

+

+    // FIXME: Store response to "trustmig" in case handle_trust_migration

+    // fails. The Lox authority will not accept a re-request to "trustmig" with

+    // the same credentials.

+    let cred = lazy.handle_trust_migration(request, response);

+  /**

+   * Fetch from the Lox authority.

+   *

+   * @param {string} procedure - The request endpoint.

+   * @param {string} body - The arguments to send in the body, if any.

+   *

+   * @returns {string} - The response body.

+   */

+  async #fetch(procedure, body) {

+    const url = `https://lox.torproject.org/${procedure}`;

+    const method = "POST";

+    const contentType = "application/vnd.api+json";

+          method,

+          headers: { "Content-Type": contentType },

+          body,

+        lazy.logger.debug("fetch fail", url, body, error);

+        lazy.logger.debug("fetch response", url, body, request);

+      return request.text();

+    // TODO: Only make domain fronted requests with user permission.

+    // tor-browser#42606.

+      return await builder.buildRequest(url, { method, contentType, body });

+      lazy.logger.debug("Domain front request fail", url, body, error);

+

+  /**

+   * Make a request to the lox authority, check for an error response, and

+   * convert it to a string.

+   *

+   * @param {string} procedure - The request endpoint.

+   * @param {?string} request - The request data, as a JSON string containing a

+   *   "request" field. Or `null` to send no data.

+   *

+   * @returns {string} - The stringified JSON response.

+   */

+  async #makeRequest(procedure, request) {

+    // Verify that the response is valid json, by parsing.

+    const jsonResponse = JSON.parse(

+      await this.#fetch(

+        procedure,

+        request ? JSON.stringify(JSON.parse(request).request) : ""

+      )

+    );

+    lazy.logger.debug(`${procedure} response:`, jsonResponse);

+    if (Object.hasOwn(jsonResponse, "error")) {

+      // TODO: Figure out if any of the "error" responses should be treated as

+      // an error. I.e. which of the procedures have soft failures and hard

+      // failures.

+      throw LoxError(

+        `Error response to ${procedure}: ${jsonResponse.error}`,

+        LoxError.ErrorResponse

+      );

+    }

+    return JSON.stringify(jsonResponse);

+  }

+   * Make a request.

+   * @param {string} url The URL to request.

+   * @param {object} args The arguments to send to the procedure.

+   * @param {string} args.method The request method.

+   * @param {string} args.body The request body.

+   * @param {string} args.contentType The "Content-Type" header to set.

+   * @returns {string} The response body.

+  async buildRequest(url, args) {

+    inStream.setData(args.body, args.body.length);

+    upChannel.setUploadStream(inStream, args.contentType, args.body.length);

+    ch.requestMethod = args.method;

+    return listener.response();

+    return JSON.parse(

+      await this.#requestBuilder.buildRequest(procedureURIString, {

+        method: "POST",

+        contentType: "application/vnd.api+json",

+        body: JSON.stringify(args),

+      })

+    );