@vex-chat/libvex 0.27.1 → 1.0.0-rc.2

package/dist/Client.js

@@ -1,61 +1,33 @@
-"use strict";
 // tslint:disable: no-empty-interface
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Client = void 0;
-const sleep_1 = require("@extrahash/sleep");
-const crypto_1 = require("@vex-chat/crypto");
-const types_1 = require("@vex-chat/types");
-const axios_1 = __importDefault(require("axios"));
-const browser_or_node_1 = require("browser-or-node");
-const btoa_1 = __importDefault(require("btoa"));
-const chalk_1 = __importDefault(require("chalk"));
-const events_1 = require("events");
-const msgpack_lite_1 = __importDefault(require("msgpack-lite"));
-const object_hash_1 = __importDefault(require("object-hash"));
-const os_1 = __importDefault(require("os"));
-const perf_hooks_1 = require("perf_hooks");
-const tweetnacl_1 = __importDefault(require("tweetnacl"));
-const uuid = __importStar(require("uuid"));
-const ws_1 = __importDefault(require("ws"));
-const Storage_1 = require("./Storage");
-const capitalize_1 = require("./utils/capitalize");
-const createLogger_1 = require("./utils/createLogger");
-const formatBytes_1 = require("./utils/formatBytes");
-const sqlSessionToCrypto_1 = require("./utils/sqlSessionToCrypto");
-const uint8uuid_1 = require("./utils/uint8uuid");
-axios_1.default.defaults.withCredentials = true;
-axios_1.default.defaults.responseType = "arraybuffer";
+import { sleep } from "@extrahash/sleep";
+import { xConcat, xConstants, xDH, xEncode, xHMAC, xKDF, XKeyConvert, xMakeNonce, xMnemonic, XUtils, } from "@vex-chat/crypto";
+import { MailType } from "@vex-chat/types";
+import ax, { AxiosError } from "axios";
+import { isBrowser, isNode } from "browser-or-node";
+import btoa from "btoa";
+import chalk from "chalk";
+import { EventEmitter } from "events";
+import { Packr } from "msgpackr";
+// useRecords:false emits standard msgpack (no nonstandard record extension).
+// moreTypes:false keeps the extension set to what every other decoder understands.
+// Packr.pack() returns Node Buffer, which axios sends correctly (plain Uint8Array
+// would have its pool buffer sent in full — see axios issue #4068).
+const msgpack = new Packr({ useRecords: false, moreTypes: false });
+import objectHash from "object-hash";
+import * as os from "node:os";
+import { performance } from "node:perf_hooks";
+import nacl from "tweetnacl";
+import * as uuid from "uuid";
+import winston from "winston";
+import WebSocket from "ws";
+import { Storage } from "./Storage.js";
+import { capitalize } from "./utils/capitalize.js";
+import { createLogger } from "./utils/createLogger.js";
+import { formatBytes } from "./utils/formatBytes.js";
+import { sqlSessionToCrypto } from "./utils/sqlSessionToCrypto.js";
+import { uuidToUint8 } from "./utils/uint8uuid.js";
+ax.defaults.withCredentials = true;
+ax.defaults.responseType = "arraybuffer";
 const protocolMsgRegex = /��\w+:\w+��/g;
 /**
  * Client provides an interface for you to use a vex chat server and
@@ -103,256 +75,378 @@ const protocolMsgRegex = /��\w+:\w+��/g;
  *
  * main();
  * ```
- *
- * @noInheritDoc
  */
-class Client extends events_1.EventEmitter {
-    constructor(privateKey, options, storage) {
-        super();
+export class Client extends EventEmitter {
+    /**
+     * Loads a key file from disk.
+     *
+     * Pass-through utility from `@vex-chat/crypto`.
+     */
+    static loadKeyFile = XUtils.loadKeyFile;
+    /**
+     * Saves a key file to disk.
+     *
+     * Pass-through utility from `@vex-chat/crypto`.
+     */
+    static saveKeyFile = XUtils.saveKeyFile;
+    /**
+     * Creates and initializes a client in one step.
+     *
+     * @param privateKey Optional hex secret key. When omitted, a fresh key is generated.
+     * @param options Runtime options.
+     * @param storage Optional custom storage backend implementing `IStorage`.
+     *
+     * @example
+     * ```ts
+     * const client = await Client.create(privateKey, { host: "api.vex.wtf" });
+     * ```
+     */
+    static create = async (privateKey, options, storage) => {
+        const client = new Client(privateKey, options, storage);
+        await client.init();
+        return client;
+    };
+    /**
+     * Generates an ed25519 secret key as a hex string.
+     *
+     * @returns - A secret key to use for the client. Save it permanently somewhere safe.
+     */
+    static generateSecretKey() {
+        return XUtils.encodeHex(nacl.sign.keyPair().secretKey);
+    }
+    /**
+     * Generates a random username using bip39.
+     *
+     * @returns - The username.
+     */
+    static randomUsername() {
+        const IKM = XUtils.decodeHex(XUtils.encodeHex(nacl.randomBytes(16)));
+        const mnemonic = xMnemonic(IKM).split(" ");
+        const addendum = XUtils.uint8ArrToNumber(nacl.randomBytes(1));
+        return (capitalize(mnemonic[0]) +
+            capitalize(mnemonic[1]) +
+            addendum.toString());
+    }
+    static getMnemonic(session) {
+        return xMnemonic(xKDF(XUtils.decodeHex(session.fingerprint)));
+    }
+    static deserializeExtra(type, extra) {
+        switch (type) {
+            case MailType.initial:
+                /* 32 bytes for signkey, 32 bytes for ephemeral key,
+                 68 bytes for AD, 6 bytes for otk index (empty for no otk) */
+                const signKey = extra.slice(0, 32);
+                const ephKey = extra.slice(32, 64);
+                const ad = extra.slice(96, 164);
+                const index = extra.slice(164, 170);
+                return [signKey, ephKey, ad, index];
+            case MailType.subsequent:
+                const publicKey = extra;
+                return [publicKey];
+            default:
+                return [];
+        }
+    }
+    /**
+     * User operations.
+     *
+     * @example
+     * ```ts
+     * const [user] = await client.users.retrieve("alice");
+     * const familiarUsers = await client.users.familiars();
+     * ```
+     */
+    users = {
         /**
-         * The IUsers interface contains methods for dealing with users.
+         * Retrieves a user's information by a string identifier.
+         * @param identifier: A userID, hex string public key, or a username.
+         *
+         * @returns - The user's IUser object, or null if the user does not exist.
          */
-        this.users = {
-            /**
-             * Retrieves a user's information by a string identifier.
-             * @param identifier: A userID, hex string public key, or a username.
-             *
-             * @returns - The user's IUser object, or null if the user does not exist.
-             */
-            retrieve: this.retrieveUserDBEntry.bind(this),
-            /**
-             * Retrieves the list of users you can currently access, or are already familiar with.
-             *
-             * @returns - The list of IUser objects.
-             */
-            familiars: this.getFamiliars.bind(this),
-        };
-        this.emoji = {
-            create: this.uploadEmoji.bind(this),
-            retrieveList: this.retrieveEmojiList.bind(this),
-            retrieve: this.retrieveEmojiByID.bind(this),
-        };
-        this.me = {
-            /**
-             * Retrieves your user information
-             *
-             * @returns - The logged in user's IUser object.
-             */
-            user: this.getUser.bind(this),
-            /**
-             * Retrieves current device details
-             *
-             * @returns - The logged in device's IDevice object.
-             */
-            device: this.getDevice.bind(this),
-            /**
-             * Changes your avatar.
-             */
-            setAvatar: this.uploadAvatar.bind(this),
-        };
-        this.devices = {
-            retrieve: this.getDeviceByID.bind(this),
-            register: this.registerDevice.bind(this),
-            delete: this.deleteDevice.bind(this),
-        };
+        retrieve: this.retrieveUserDBEntry.bind(this),
         /**
-         * The IMessages interface contains methods for dealing with messages.
+         * Retrieves the list of users you can currently access, or are already familiar with.
+         *
+         * @returns - The list of IUser objects.
          */
-        this.files = {
-            /**
-             * Uploads an encrypted file and returns the details and the secret key.
-             * @param file: The file as a Buffer.
-             *
-             * @returns Details of the file uploaded and the key to encrypt in the form [details, key].
-             */
-            create: this.createFile.bind(this),
-            retrieve: this.retrieveFile.bind(this),
-        };
+        familiars: this.getFamiliars.bind(this),
+    };
+    /**
+     * Emoji operations.
+     *
+     * @example
+     * ```ts
+     * const emoji = await client.emoji.create(imageBuffer, "party", serverID);
+     * const list = await client.emoji.retrieveList(serverID);
+     * ```
+     */
+    emoji = {
+        create: this.uploadEmoji.bind(this),
+        retrieveList: this.retrieveEmojiList.bind(this),
+        retrieve: this.retrieveEmojiByID.bind(this),
+    };
+    /**
+     * Helpers for information/actions related to the currently authenticated account.
+     */
+    me = {
         /**
-         * The IPermissions object contains all methods for dealing with permissions.
+         * Retrieves your user information
+         *
+         * @returns - The logged in user's IUser object.
          */
-        this.permissions = {
-            retrieve: this.getPermissions.bind(this),
-            delete: this.deletePermission.bind(this),
-        };
+        user: this.getUser.bind(this),
         /**
-         * The IModeration object contains all methods for dealing with permissions.
+         * Retrieves current device details
+         *
+         * @returns - The logged in device's IDevice object.
          */
-        this.moderation = {
-            kick: this.kickUser.bind(this),
-            fetchPermissionList: this.fetchPermissionList.bind(this),
-        };
+        device: this.getDevice.bind(this),
         /**
-         * The IInvites interface contains methods for dealing with invites.
+         * Changes your avatar.
          */
-        this.invites = {
-            create: this.createInvite.bind(this),
-            redeem: this.redeemInvite.bind(this),
-            retrieve: this.retrieveInvites.bind(this),
-        };
+        setAvatar: this.uploadAvatar.bind(this),
+    };
+    /**
+     * Device management methods.
+     */
+    devices = {
+        retrieve: this.getDeviceByID.bind(this),
+        register: this.registerDevice.bind(this),
+        delete: this.deleteDevice.bind(this),
+    };
+    /** File upload/download methods. */
+    files = {
         /**
-         * The IMessages interface contains methods for dealing with messages.
+         * Uploads an encrypted file and returns the details and the secret key.
+         * @param file: The file as a Buffer.
+         *
+         * @returns Details of the file uploaded and the key to encrypt in the form [details, key].
          */
-        this.messages = {
-            /**
-             * Send a direct message.
-             * @param userID: The userID of the user to send a message to.
-             * @param message: The message to send.
-             */
-            send: this.sendMessage.bind(this),
-            /**
-             * Send a group message to a channel.
-             * @param channelID: The channelID of the channel to send a message to.
-             * @param message: The message to send.
-             */
-            group: this.sendGroupMessage.bind(this),
-            /**
-             * Gets the message history with a specific userID.
-             * @param userID: The userID of the user to retrieve message history for.
-             *
-             * @returns - The list of IMessage objects.
-             */
-            retrieve: this.getMessageHistory.bind(this),
-            /**
-             * Gets the group message history with a specific channelID.
-             * @param chqnnelID: The channelID of the channel to retrieve message history for.
-             *
-             * @returns - The list of IMessage objects.
-             */
-            retrieveGroup: this.getGroupHistory.bind(this),
-            delete: this.deleteHistory.bind(this),
-            purge: this.purgeHistory.bind(this),
-        };
+        create: this.createFile.bind(this),
+        retrieve: this.retrieveFile.bind(this),
+    };
+    /**
+     * Permission-management methods for the current user.
+     */
+    permissions = {
+        retrieve: this.getPermissions.bind(this),
+        delete: this.deletePermission.bind(this),
+    };
+    /**
+     * Server moderation helper methods.
+     */
+    moderation = {
+        kick: this.kickUser.bind(this),
+        fetchPermissionList: this.fetchPermissionList.bind(this),
+    };
+    /**
+     * Invite-management methods.
+     */
+    invites = {
+        create: this.createInvite.bind(this),
+        redeem: this.redeemInvite.bind(this),
+        retrieve: this.retrieveInvites.bind(this),
+    };
+    /**
+     * Message operations (direct and group).
+     *
+     * @example
+     * ```ts
+     * await client.messages.send(userID, "Hello!");
+     * await client.messages.group(channelID, "Hello channel!");
+     * const dmHistory = await client.messages.retrieve(userID);
+     * ```
+     */
+    messages = {
         /**
-         * The ISessions interface contains methods for dealing with encryption sessions.
+         * Send a direct message.
+         * @param userID: The userID of the user to send a message to.
+         * @param message: The message to send.
          */
-        this.sessions = {
-            /**
-             * Gets all encryption sessions.
-             *
-             * @returns - The list of ISession encryption sessions.
-             */
-            retrieve: this.getSessionList.bind(this),
-            /**
-             * Returns a mnemonic for the session, to verify with the other user.
-             * @param session the ISession object to get the mnemonic for.
-             *
-             * @returns - The mnemonic representation of the session.
-             */
-            verify: Client.getMnemonic,
-            /**
-             * Marks a mnemonic verified, implying that the the user has confirmed
-             * that the session mnemonic matches with the other user.
-             * @param sessionID the sessionID of the session to mark.
-             * @param status Optionally, what to mark it as. Defaults to true.
-             */
-            markVerified: this.markSessionVerified.bind(this),
-        };
-        this.servers = {
-            /**
-             * Retrieves all servers the logged in user has access to.
-             *
-             * @returns - The list of IServer objects.
-             */
-            retrieve: this.getServerList.bind(this),
-            /**
-             * Retrieves server details by its unique serverID.
-             *
-             * @returns - The requested IServer object, or null if the id does not exist.
-             */
-            retrieveByID: this.getServerByID.bind(this),
-            /**
-             * Creates a new server.
-             * @param name: The server name.
-             *
-             * @returns - The created IServer object.
-             */
-            create: this.createServer.bind(this),
-            /**
-             * Deletes a server.
-             * @param serverID: The unique serverID to delete.
-             */
-            delete: this.deleteServer.bind(this),
-            leave: this.leaveServer.bind(this),
-        };
-        this.channels = {
-            /**
-             * Retrieves all channels in a server.
-             *
-             * @returns - The list of IChannel objects.
-             */
-            retrieve: this.getChannelList.bind(this),
-            /**
-             * Retrieves channel details by its unique channelID.
-             *
-             * @returns - The list of IChannel objects.
-             */
-            retrieveByID: this.getChannelByID.bind(this),
-            /**
-             * Creates a new channel in a server.
-             * @param name: The channel name.
-             * @param serverID: The unique serverID to create the channel in.
-             *
-             * @returns - The created IChannel object.
-             */
-            create: this.createChannel.bind(this),
-            /**
-             * Deletes a channel.
-             * @param channelID: The unique channelID to delete.
-             */
-            delete: this.deleteChannel.bind(this),
-            /**
-             * Retrieves a channel's userlist.
-             * @param channelID: The channelID to retrieve userlist for.
-             */
-            userList: this.getUserList.bind(this),
-        };
+        send: this.sendMessage.bind(this),
         /**
-         * This is true if the client has ever been initialized. You can only initialize
-         * a client once.
+         * Send a group message to a channel.
+         * @param channelID: The channelID of the channel to send a message to.
+         * @param message: The message to send.
          */
-        this.hasInit = false;
+        group: this.sendGroupMessage.bind(this),
         /**
-         * This is true if the client has ever logged in before. You can only login a client once.
+         * Gets the message history with a specific userID.
+         * @param userID: The userID of the user to retrieve message history for.
+         *
+         * @returns - The list of IMessage objects.
          */
-        this.hasLoggedIn = false;
-        this.sending = {};
-        this.firstMailFetch = true;
-        this.userRecords = {};
-        this.deviceRecords = {};
-        this.sessionRecords = {};
-        this.isAlive = true;
-        this.reading = false;
-        this.fetchingMail = false;
-        this.cookies = [];
-        this.pingInterval = null;
-        this.manuallyClosing = false;
-        this.token = null;
-        this.forwarded = [];
-        this.log = createLogger_1.createLogger("client", options === null || options === void 0 ? void 0 : options.logLevel);
-        this.prefixes = (options === null || options === void 0 ? void 0 : options.unsafeHttp) ? { HTTP: "http://", WS: "ws://" }
+        retrieve: this.getMessageHistory.bind(this),
+        /**
+         * Gets the group message history with a specific channelID.
+         * @param chqnnelID: The channelID of the channel to retrieve message history for.
+         *
+         * @returns - The list of IMessage objects.
+         */
+        retrieveGroup: this.getGroupHistory.bind(this),
+        delete: this.deleteHistory.bind(this),
+        purge: this.purgeHistory.bind(this),
+    };
+    /**
+     * Encryption-session helpers.
+     */
+    sessions = {
+        /**
+         * Gets all encryption sessions.
+         *
+         * @returns - The list of ISession encryption sessions.
+         */
+        retrieve: this.getSessionList.bind(this),
+        /**
+         * Returns a mnemonic for the session, to verify with the other user.
+         * @param session the ISession object to get the mnemonic for.
+         *
+         * @returns - The mnemonic representation of the session.
+         */
+        verify: Client.getMnemonic,
+        /**
+         * Marks a mnemonic verified, implying that the the user has confirmed
+         * that the session mnemonic matches with the other user.
+         * @param sessionID the sessionID of the session to mark.
+         * @param status Optionally, what to mark it as. Defaults to true.
+         */
+        markVerified: this.markSessionVerified.bind(this),
+    };
+    /**
+     * Server operations.
+     *
+     * @example
+     * ```ts
+     * const servers = await client.servers.retrieve();
+     * const created = await client.servers.create("Team Space");
+     * ```
+     */
+    servers = {
+        /**
+         * Retrieves all servers the logged in user has access to.
+         *
+         * @returns - The list of IServer objects.
+         */
+        retrieve: this.getServerList.bind(this),
+        /**
+         * Retrieves server details by its unique serverID.
+         *
+         * @returns - The requested IServer object, or null if the id does not exist.
+         */
+        retrieveByID: this.getServerByID.bind(this),
+        /**
+         * Creates a new server.
+         * @param name: The server name.
+         *
+         * @returns - The created IServer object.
+         */
+        create: this.createServer.bind(this),
+        /**
+         * Deletes a server.
+         * @param serverID: The unique serverID to delete.
+         */
+        delete: this.deleteServer.bind(this),
+        leave: this.leaveServer.bind(this),
+    };
+    /**
+     * Channel operations.
+     */
+    channels = {
+        /**
+         * Retrieves all channels in a server.
+         *
+         * @returns - The list of IChannel objects.
+         */
+        retrieve: this.getChannelList.bind(this),
+        /**
+         * Retrieves channel details by its unique channelID.
+         *
+         * @returns - The list of IChannel objects.
+         */
+        retrieveByID: this.getChannelByID.bind(this),
+        /**
+         * Creates a new channel in a server.
+         * @param name: The channel name.
+         * @param serverID: The unique serverID to create the channel in.
+         *
+         * @returns - The created IChannel object.
+         */
+        create: this.createChannel.bind(this),
+        /**
+         * Deletes a channel.
+         * @param channelID: The unique channelID to delete.
+         */
+        delete: this.deleteChannel.bind(this),
+        /**
+         * Retrieves a channel's userlist.
+         * @param channelID: The channelID to retrieve userlist for.
+         */
+        userList: this.getUserList.bind(this),
+    };
+    /**
+     * This is true if the client has ever been initialized. You can only initialize
+     * a client once.
+     */
+    hasInit = false;
+    /**
+     * This is true if the client has ever logged in before. You can only login a client once.
+     */
+    hasLoggedIn = false;
+    sending = {};
+    database;
+    dbPath;
+    conn;
+    host;
+    firstMailFetch = true;
+    // these are created from one set of sign keys
+    signKeys;
+    idKeys;
+    xKeyRing;
+    user;
+    device;
+    userRecords = {};
+    deviceRecords = {};
+    sessionRecords = {};
+    isAlive = true;
+    reading = false;
+    fetchingMail = false;
+    cookies = [];
+    log;
+    pingInterval = null;
+    mailInterval;
+    manuallyClosing = false;
+    token = null;
+    forwarded = [];
+    prefixes;
+    constructor(privateKey, options, storage) {
+        super();
+        this.log = createLogger("client", options?.logLevel);
+        this.prefixes = options?.unsafeHttp
+            ? { HTTP: "http://", WS: "ws://" }
             : { HTTP: "https://", WS: "wss://" };
         this.signKeys = privateKey
-            ? tweetnacl_1.default.sign.keyPair.fromSecretKey(crypto_1.XUtils.decodeHex(privateKey))
-            : tweetnacl_1.default.sign.keyPair();
-        this.idKeys = crypto_1.XKeyConvert.convertKeyPair(this.signKeys);
+            ? nacl.sign.keyPair.fromSecretKey(XUtils.decodeHex(privateKey))
+            : nacl.sign.keyPair();
+        this.idKeys = XKeyConvert.convertKeyPair(this.signKeys);
         if (!this.idKeys) {
             throw new Error("Could not convert key to X25519!");
         }
-        this.host = (options === null || options === void 0 ? void 0 : options.host) || "api.vex.wtf";
-        const dbFileName = (options === null || options === void 0 ? void 0 : options.inMemoryDb) ? ":memory:"
-            : crypto_1.XUtils.encodeHex(this.signKeys.publicKey) + ".sqlite";
-        this.dbPath = (options === null || options === void 0 ? void 0 : options.dbFolder) ? (options === null || options === void 0 ? void 0 : options.dbFolder) + "/" + dbFileName
+        this.host = options?.host || "api.vex.wtf";
+        const dbFileName = options?.inMemoryDb
+            ? ":memory:"
+            : XUtils.encodeHex(this.signKeys.publicKey) + ".sqlite";
+        this.dbPath = options?.dbFolder
+            ? options?.dbFolder + "/" + dbFileName
             : dbFileName;
         this.database = storage
             ? storage
-            : new Storage_1.Storage(this.dbPath, crypto_1.XUtils.encodeHex(this.signKeys.secretKey), options);
+            : new Storage(this.dbPath, XUtils.encodeHex(this.signKeys.secretKey), options);
         this.database.on("error", (error) => {
             this.log.error(error.toString());
             this.close(true);
         });
         // we want to initialize this later with login()
-        this.conn = new ws_1.default("ws://localhost:1234");
+        this.conn = new WebSocket("ws://localhost:1234");
         // silence the error for connecting to junk ws
         // tslint:disable-next-line: no-empty
         this.conn.onerror = () => { };
@@ -362,165 +456,149 @@ class Client extends events_1.EventEmitter {
                 host: this.getHost(),
                 dbPath: this.dbPath,
                 environment: {
-                    isBrowser: browser_or_node_1.isBrowser,
-                    isNode: browser_or_node_1.isNode,
+                    isBrowser,
+                    isNode,
                 },
                 options,
             }, null, 4));
     }
     /**
-     * Generates an ed25519 secret key as a hex string.
-     *
-     * @returns - A secret key to use for the client. Save it permanently somewhere safe.
-     */
-    static generateSecretKey() {
-        return crypto_1.XUtils.encodeHex(tweetnacl_1.default.sign.keyPair().secretKey);
-    }
-    /**
-     * Generates a random username using bip39.
+     * Returns the current HTTP API origin with protocol.
      *
-     * @returns - The username.
+     * @example
+     * ```ts
+     * console.log(client.getHost()); // "https://api.vex.wtf"
+     * ```
      */
-    static randomUsername() {
-        const IKM = crypto_1.XUtils.decodeHex(crypto_1.XUtils.encodeHex(tweetnacl_1.default.randomBytes(16)));
-        const mnemonic = crypto_1.xMnemonic(IKM).split(" ");
-        const addendum = crypto_1.XUtils.uint8ArrToNumber(tweetnacl_1.default.randomBytes(1));
-        return (capitalize_1.capitalize(mnemonic[0]) +
-            capitalize_1.capitalize(mnemonic[1]) +
-            addendum.toString());
-    }
-    static getMnemonic(session) {
-        return crypto_1.xMnemonic(crypto_1.xKDF(crypto_1.XUtils.decodeHex(session.fingerprint)));
-    }
-    static deserializeExtra(type, extra) {
-        switch (type) {
-            case types_1.XTypes.WS.MailType.initial:
-                /* 32 bytes for signkey, 32 bytes for ephemeral key,
-                 68 bytes for AD, 6 bytes for otk index (empty for no otk) */
-                const signKey = extra.slice(0, 32);
-                const ephKey = extra.slice(32, 64);
-                const ad = extra.slice(96, 164);
-                const index = extra.slice(164, 170);
-                return [signKey, ephKey, ad, index];
-            case types_1.XTypes.WS.MailType.subsequent:
-                const publicKey = extra;
-                return [publicKey];
-            default:
-                return [];
-        }
-    }
     getHost() {
         return this.prefixes.HTTP + this.host;
     }
     /**
      * Manually closes the client. Emits the closed event on successful shutdown.
      */
-    close(muteEvent = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.manuallyClosing = true;
-            this.log.info("Manually closing client.");
-            this.conn.close();
-            yield this.database.close();
-            if (this.pingInterval) {
-                clearInterval(this.pingInterval);
-            }
-            if (this.mailInterval) {
-                clearInterval(this.mailInterval);
-            }
-            delete this.xKeyRing;
-            if (!muteEvent) {
-                this.emit("closed");
-            }
-            return;
-        });
+    async close(muteEvent = false) {
+        this.manuallyClosing = true;
+        this.log.info("Manually closing client.");
+        this.conn.close();
+        await this.database.close();
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+        }
+        if (this.mailInterval) {
+            clearInterval(this.mailInterval);
+        }
+        delete this.xKeyRing;
+        if (!muteEvent) {
+            this.emit("closed");
+        }
+        return;
     }
     /**
      * Gets the hex string representations of the public and private keys.
      */
     getKeys() {
         return {
-            public: crypto_1.XUtils.encodeHex(this.signKeys.publicKey),
-            private: crypto_1.XUtils.encodeHex(this.signKeys.secretKey),
+            public: XUtils.encodeHex(this.signKeys.publicKey),
+            private: XUtils.encodeHex(this.signKeys.secretKey),
         };
     }
-    login(username, password) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const res = yield axios_1.default.post(this.getHost() + "/auth", msgpack_lite_1.default.encode({
-                    username,
-                    password,
-                }), {
-                    headers: { "Content-Type": "application/msgpack" },
-                });
-                const { user, token, } = msgpack_lite_1.default.decode(Buffer.from(res.data));
-                const cookies = res.headers["set-cookie"];
-                if (cookies) {
-                    for (const cookie of cookies) {
-                        if (cookie.includes("auth")) {
-                            this.addCookie(cookie);
-                        }
+    /**
+     * Authenticates with username/password and stores the auth token/cookie.
+     *
+     * @param username Account username.
+     * @param password Account password.
+     * @returns `null` on success, or the thrown error object on failure.
+     *
+     * @example
+     * ```ts
+     * const err = await client.login("alice", "correct horse battery staple");
+     * if (err) console.error(err);
+     * ```
+     */
+    async login(username, password) {
+        try {
+            const res = await ax.post(this.getHost() + "/auth", msgpack.encode({
+                username,
+                password,
+            }), {
+                headers: { "Content-Type": "application/msgpack" },
+            });
+            const { user, token } = msgpack.decode(Buffer.from(res.data));
+            const cookies = res.headers["set-cookie"];
+            if (cookies) {
+                for (const cookie of cookies) {
+                    if (cookie.includes("auth")) {
+                        this.addCookie(cookie);
                     }
                 }
-                this.setUser(user);
-                this.token = token;
-            }
-            catch (err) {
-                console.error(err.toString());
-                return err;
             }
-            return null;
-        });
+            this.setUser(user);
+            this.token = token;
+        }
+        catch (err) {
+            console.error(err.toString());
+            return err;
+        }
+        return null;
     }
     /**
      * Returns the authorization cookie details. Throws if you don't have a
      * valid authorization cookie.
      */
-    whoami() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield axios_1.default.post(this.getHost() + "/whoami", null, {
-                withCredentials: true,
-                responseType: "arraybuffer",
-            });
-            const whoami = msgpack_lite_1.default.decode(Buffer.from(res.data));
-            return whoami;
+    /**
+     * Returns details about the currently authenticated session.
+     *
+     * @returns The authenticated user, token expiry, and active token.
+     *
+     * @example
+     * ```ts
+     * const auth = await client.whoami();
+     * console.log(auth.user.username, new Date(auth.exp));
+     * ```
+     */
+    async whoami() {
+        const res = await ax.post(this.getHost() + "/whoami", null, {
+            withCredentials: true,
+            responseType: "arraybuffer",
         });
+        const whoami = msgpack.decode(Buffer.from(res.data));
+        return whoami;
     }
-    logout() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield axios_1.default.post(this.getHost() + "/goodbye");
-        });
+    /**
+     * Logs out the current authenticated session from the server.
+     */
+    async logout() {
+        await ax.post(this.getHost() + "/goodbye");
     }
     /**
      * Connects your device to the chat. You must have an valid authorization cookie.
      * You can check whoami() to see before calling connect().
      */
-    connect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { user, token } = yield this.whoami();
-            this.token = token;
-            if (!user || !token) {
-                throw new Error("Auth cookie missing or expired. Log in again.");
-            }
-            this.setUser(user);
-            this.device = yield this.retrieveOrCreateDevice();
-            const connectToken = yield this.getToken("connect");
-            if (!connectToken) {
-                throw new Error("Couldn't get connect token.");
-            }
-            const signed = tweetnacl_1.default.sign(Uint8Array.from(uuid.parse(connectToken.key)), this.signKeys.secretKey);
-            const res = yield axios_1.default.post(this.getHost() + "/device/" + this.device.deviceID + "/connect", msgpack_lite_1.default.encode({ signed }), { headers: { "Content-Type": "application/msgpack" } });
-            const cookies = res.headers["set-cookie"];
-            if (cookies) {
-                for (const cookie of cookies) {
-                    if (cookie.includes("device")) {
-                        this.addCookie(cookie);
-                    }
+    async connect() {
+        const { user, token } = await this.whoami();
+        this.token = token;
+        if (!user || !token) {
+            throw new Error("Auth cookie missing or expired. Log in again.");
+        }
+        this.setUser(user);
+        this.device = await this.retrieveOrCreateDevice();
+        const connectToken = await this.getToken("connect");
+        if (!connectToken) {
+            throw new Error("Couldn't get connect token.");
+        }
+        const signed = nacl.sign(Uint8Array.from(uuid.parse(connectToken.key)), this.signKeys.secretKey);
+        const res = await ax.post(this.getHost() + "/device/" + this.device.deviceID + "/connect", msgpack.encode({ signed }), { headers: { "Content-Type": "application/msgpack" } });
+        const cookies = res.headers["set-cookie"];
+        if (cookies) {
+            for (const cookie of cookies) {
+                if (cookie.includes("device")) {
+                    this.addCookie(cookie);
                 }
             }
-            this.log.info("Starting websocket.");
-            this.initSocket();
-            yield this.negotiateOTK();
-        });
+        }
+        this.log.info("Starting websocket.");
+        this.initSocket();
+        await this.negotiateOTK();
     }
     /**
      * Registers a new account on the server.
@@ -530,519 +608,432 @@ class Client extends events_1.EventEmitter {
      *
      * @example [user, err] = await client.register("MyUsername");
      */
-    register(username, password) {
-        return __awaiter(this, void 0, void 0, function* () {
-            while (!this.xKeyRing) {
-                yield sleep_1.sleep(100);
+    async register(username, password) {
+        while (!this.xKeyRing) {
+            await sleep(100);
+        }
+        const regKey = await this.getToken("register");
+        if (regKey) {
+            const signKey = XUtils.encodeHex(this.signKeys.publicKey);
+            const signed = XUtils.encodeHex(nacl.sign(Uint8Array.from(uuid.parse(regKey.key)), this.signKeys.secretKey));
+            const regMsg = {
+                username,
+                signKey,
+                signed,
+                preKey: XUtils.encodeHex(this.xKeyRing.preKeys.keyPair.publicKey),
+                preKeySignature: XUtils.encodeHex(this.xKeyRing.preKeys.signature),
+                preKeyIndex: this.xKeyRing.preKeys.index,
+                password,
+                deviceName: `${os.platform()}`,
+            };
+            try {
+                const res = await ax.post(this.getHost() + "/register", msgpack.encode(regMsg), { headers: { "Content-Type": "application/msgpack" } });
+                this.setUser(msgpack.decode(Buffer.from(res.data)));
+                return [this.getUser(), null];
             }
-            const regKey = yield this.getToken("register");
-            if (regKey) {
-                const signKey = crypto_1.XUtils.encodeHex(this.signKeys.publicKey);
-                const signed = crypto_1.XUtils.encodeHex(tweetnacl_1.default.sign(Uint8Array.from(uuid.parse(regKey.key)), this.signKeys.secretKey));
-                const regMsg = {
-                    username,
-                    signKey,
-                    signed,
-                    preKey: crypto_1.XUtils.encodeHex(this.xKeyRing.preKeys.keyPair.publicKey),
-                    preKeySignature: crypto_1.XUtils.encodeHex(this.xKeyRing.preKeys.signature),
-                    preKeyIndex: this.xKeyRing.preKeys.index,
-                    password,
-                    deviceName: `${os_1.default.platform()}`,
-                };
-                try {
-                    const res = yield axios_1.default.post(this.getHost() + "/register", msgpack_lite_1.default.encode(regMsg), { headers: { "Content-Type": "application/msgpack" } });
-                    this.setUser(msgpack_lite_1.default.decode(Buffer.from(res.data)));
-                    return [this.getUser(), null];
+            catch (err) {
+                if (err.response) {
+                    return [null, new Error(err.response.data.error)];
                 }
-                catch (err) {
-                    if (err.response) {
-                        return [null, new Error(err.response.data.error)];
-                    }
-                    else {
-                        return [null, err];
-                    }
+                else {
+                    return [null, err];
                 }
             }
-            else {
-                return [null, new Error("Couldn't get regkey from server.")];
-            }
-        });
+        }
+        else {
+            return [null, new Error("Couldn't get regkey from server.")];
+        }
     }
+    /**
+     * Returns a compact `<username><deviceID>` debug label.
+     */
     toString() {
-        var _a, _b;
-        return ((_a = this.user) === null || _a === void 0 ? void 0 : _a.username) + "<" + ((_b = this.device) === null || _b === void 0 ? void 0 : _b.deviceID) + ">";
+        return this.user?.username + "<" + this.device?.deviceID + ">";
     }
-    redeemInvite(inviteID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield axios_1.default.patch(this.getHost() + "/invite/" + inviteID);
-            return msgpack_lite_1.default.decode(Buffer.from(res.data));
-        });
+    async redeemInvite(inviteID) {
+        const res = await ax.patch(this.getHost() + "/invite/" + inviteID);
+        return msgpack.decode(Buffer.from(res.data));
     }
-    retrieveInvites(serverID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield axios_1.default.get(this.getHost() + "/server/" + serverID + "/invites");
-            return msgpack_lite_1.default.decode(Buffer.from(res.data));
-        });
+    async retrieveInvites(serverID) {
+        const res = await ax.get(this.getHost() + "/server/" + serverID + "/invites");
+        return msgpack.decode(Buffer.from(res.data));
     }
-    createInvite(serverID, duration) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const payload = {
-                serverID,
-                duration,
-            };
-            const res = yield axios_1.default.post(this.getHost() + "/server/" + serverID + "/invites", payload);
-            return msgpack_lite_1.default.decode(Buffer.from(res.data));
-        });
+    async createInvite(serverID, duration) {
+        const payload = {
+            serverID,
+            duration,
+        };
+        const res = await ax.post(this.getHost() + "/server/" + serverID + "/invites", payload);
+        return msgpack.decode(Buffer.from(res.data));
     }
-    retrieveEmojiList(serverID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield axios_1.default.get(this.getHost() + "/server/" + serverID + "/emoji");
-            return msgpack_lite_1.default.decode(Buffer.from(res.data));
-        });
+    async retrieveEmojiList(serverID) {
+        const res = await ax.get(this.getHost() + "/server/" + serverID + "/emoji");
+        return msgpack.decode(Buffer.from(res.data));
     }
-    retrieveEmojiByID(emojiID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield axios_1.default.get(this.getHost() + "/emoji/" + emojiID + "/details");
-            // this is actually empty string
-            if (!res.data) {
-                return null;
-            }
-            return msgpack_lite_1.default.decode(Buffer.from(res.data));
-        });
+    async retrieveEmojiByID(emojiID) {
+        const res = await ax.get(this.getHost() + "/emoji/" + emojiID + "/details");
+        // this is actually empty string
+        if (!res.data) {
+            return null;
+        }
+        return msgpack.decode(Buffer.from(res.data));
     }
-    leaveServer(serverID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const permissionList = yield this.permissions.retrieve();
-            for (const permission of permissionList) {
-                if (permission.resourceID === serverID) {
-                    yield this.deletePermission(permission.permissionID);
-                }
+    async leaveServer(serverID) {
+        const permissionList = await this.permissions.retrieve();
+        for (const permission of permissionList) {
+            if (permission.resourceID === serverID) {
+                await this.deletePermission(permission.permissionID);
             }
-        });
+        }
     }
-    kickUser(userID, serverID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const permissionList = yield this.fetchPermissionList(serverID);
-            for (const permission of permissionList) {
-                if (userID === permission.userID) {
-                    yield this.deletePermission(permission.permissionID);
-                    return;
-                }
+    async kickUser(userID, serverID) {
+        const permissionList = await this.fetchPermissionList(serverID);
+        for (const permission of permissionList) {
+            if (userID === permission.userID) {
+                await this.deletePermission(permission.permissionID);
+                return;
             }
-            throw new Error("Couldn't kick user.");
-        });
+        }
+        throw new Error("Couldn't kick user.");
     }
     addCookie(cookie) {
         if (!this.cookies.includes(cookie)) {
             this.cookies.push(cookie);
             this.log.info("cookies changed", this.getCookies());
-            if (browser_or_node_1.isNode) {
-                axios_1.default.defaults.headers.cookie = this.cookies.join(";");
+            if (isNode) {
+                ax.defaults.headers.cookie = this.cookies.join(";");
             }
         }
     }
     getCookies() {
         return this.cookies.join(";");
     }
-    uploadEmoji(emoji, name, serverID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (typeof FormData !== "undefined") {
-                const fpayload = new FormData();
-                fpayload.set("emoji", new Blob([emoji]));
-                fpayload.set("name", name);
-                try {
-                    const res = yield axios_1.default.post(this.getHost() + "/emoji/" + serverID, fpayload, {
-                        headers: { "Content-Type": "multipart/form-data" },
-                        onUploadProgress: (progressEvent) => {
-                            const percentCompleted = Math.round((progressEvent.loaded * 100) /
-                                progressEvent.total);
-                            const { loaded, total } = progressEvent;
-                            const progress = {
-                                direction: "upload",
-                                token: name,
-                                progress: percentCompleted,
-                                loaded,
-                                total,
-                            };
-                            this.emit("fileProgress", progress);
-                        },
-                    });
-                    return msgpack_lite_1.default.decode(Buffer.from(res.data));
-                }
-                catch (err) {
-                    return null;
-                }
-            }
-            const payload = {
-                file: crypto_1.XUtils.encodeBase64(emoji),
-                name,
-            };
+    async uploadEmoji(emoji, name, serverID) {
+        if (typeof FormData !== "undefined") {
+            const fpayload = new FormData();
+            fpayload.set("emoji", new Blob([new Uint8Array(emoji)]));
+            fpayload.set("name", name);
             try {
-                const res = yield axios_1.default.post(this.getHost() + "/emoji/" + serverID + "/json", msgpack_lite_1.default.encode(payload), { headers: { "Content-Type": "application/msgpack" } });
-                return msgpack_lite_1.default.decode(Buffer.from(res.data));
+                const res = await ax.post(this.getHost() + "/emoji/" + serverID, fpayload, {
+                    headers: { "Content-Type": "multipart/form-data" },
+                    onUploadProgress: (progressEvent) => {
+                        const percentCompleted = Math.round((progressEvent.loaded * 100) /
+                            (progressEvent.total ?? 1));
+                        const { loaded, total = 0 } = progressEvent;
+                        const progress = {
+                            direction: "upload",
+                            token: name,
+                            progress: percentCompleted,
+                            loaded,
+                            total,
+                        };
+                        this.emit("fileProgress", progress);
+                    },
+                });
+                return msgpack.decode(Buffer.from(res.data));
             }
             catch (err) {
                 return null;
             }
-        });
+        }
+        const payload = {
+            file: XUtils.encodeBase64(emoji),
+            name,
+        };
+        try {
+            const res = await ax.post(this.getHost() + "/emoji/" + serverID + "/json", msgpack.encode(payload), { headers: { "Content-Type": "application/msgpack" } });
+            return msgpack.decode(Buffer.from(res.data));
+        }
+        catch (err) {
+            return null;
+        }
     }
-    retrieveOrCreateDevice() {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            let device;
-            try {
-                const res = yield axios_1.default.get(this.prefixes.HTTP +
-                    this.host +
-                    "/device/" +
-                    crypto_1.XUtils.encodeHex(this.signKeys.publicKey));
-                device = msgpack_lite_1.default.decode(Buffer.from(res.data));
-            }
-            catch (err) {
-                this.log.error(err.toString());
-                if (((_a = err.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
-                    // just in case
-                    yield this.database.purgeKeyData();
-                    yield this.populateKeyRing();
-                    this.log.info("Attempting to register device.");
-                    const newDevice = yield this.registerDevice();
-                    if (newDevice) {
-                        device = newDevice;
-                    }
-                    else {
-                        throw new Error("Error registering device.");
-                    }
+    async retrieveOrCreateDevice() {
+        let device;
+        try {
+            const res = await ax.get(this.prefixes.HTTP +
+                this.host +
+                "/device/" +
+                XUtils.encodeHex(this.signKeys.publicKey));
+            device = msgpack.decode(Buffer.from(res.data));
+        }
+        catch (err) {
+            this.log.error(err.toString());
+            if (err.response?.status === 404) {
+                // just in case
+                await this.database.purgeKeyData();
+                await this.populateKeyRing();
+                this.log.info("Attempting to register device.");
+                const newDevice = await this.registerDevice();
+                if (newDevice) {
+                    device = newDevice;
                 }
                 else {
-                    throw err;
+                    throw new Error("Error registering device.");
                 }
             }
-            this.log.info("Got device " + JSON.stringify(device, null, 4));
-            return device;
-        });
-    }
-    registerDevice() {
-        return __awaiter(this, void 0, void 0, function* () {
-            while (!this.xKeyRing) {
-                yield sleep_1.sleep(100);
-            }
-            const token = yield this.getToken("device");
-            const [userDetails, err] = yield this.retrieveUserDBEntry(this.user.username);
-            if (!userDetails) {
-                throw new Error("Username not found " + this.user.username);
-            }
-            if (err) {
-                throw err;
-            }
-            if (!token) {
-                throw new Error("Couldn't fetch token.");
-            }
-            const signKey = this.getKeys().public;
-            const signed = crypto_1.XUtils.encodeHex(tweetnacl_1.default.sign(Uint8Array.from(uuid.parse(token.key)), this.signKeys.secretKey));
-            const devMsg = {
-                username: userDetails.username,
-                signKey,
-                signed,
-                preKey: crypto_1.XUtils.encodeHex(this.xKeyRing.preKeys.keyPair.publicKey),
-                preKeySignature: crypto_1.XUtils.encodeHex(this.xKeyRing.preKeys.signature),
-                preKeyIndex: this.xKeyRing.preKeys.index,
-                deviceName: `${os_1.default.platform()}`,
-            };
-            try {
-                const res = yield axios_1.default.post(this.prefixes.HTTP +
-                    this.host +
-                    "/user/" +
-                    userDetails.userID +
-                    "/devices", msgpack_lite_1.default.encode(devMsg), { headers: { "Content-Type": "application/msgpack" } });
-                return msgpack_lite_1.default.decode(Buffer.from(res.data));
-            }
-            catch (err) {
+            else {
                 throw err;
             }
-        });
+        }
+        this.log.info("Got device " + JSON.stringify(device, null, 4));
+        return device;
     }
-    getToken(type) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const res = yield axios_1.default.get(this.getHost() + "/token/" + type, {
-                    responseType: "arraybuffer",
-                });
-                return msgpack_lite_1.default.decode(Buffer.from(res.data));
-            }
-            catch (err) {
-                this.log.warn(err.toString());
-                return null;
-            }
-        });
+    async registerDevice() {
+        while (!this.xKeyRing) {
+            await sleep(100);
+        }
+        const token = await this.getToken("device");
+        const [userDetails, err] = await this.retrieveUserDBEntry(this.user.username);
+        if (!userDetails) {
+            throw new Error("Username not found " + this.user.username);
+        }
+        if (err) {
+            throw err;
+        }
+        if (!token) {
+            throw new Error("Couldn't fetch token.");
+        }
+        const signKey = this.getKeys().public;
+        const signed = XUtils.encodeHex(nacl.sign(Uint8Array.from(uuid.parse(token.key)), this.signKeys.secretKey));
+        const devMsg = {
+            username: userDetails.username,
+            signKey,
+            signed,
+            preKey: XUtils.encodeHex(this.xKeyRing.preKeys.keyPair.publicKey),
+            preKeySignature: XUtils.encodeHex(this.xKeyRing.preKeys.signature),
+            preKeyIndex: this.xKeyRing.preKeys.index,
+            deviceName: `${os.platform()}`,
+        };
+        try {
+            const res = await ax.post(this.prefixes.HTTP +
+                this.host +
+                "/user/" +
+                userDetails.userID +
+                "/devices", msgpack.encode(devMsg), { headers: { "Content-Type": "application/msgpack" } });
+            return msgpack.decode(Buffer.from(res.data));
+        }
+        catch (err) {
+            throw err;
+        }
     }
-    uploadAvatar(avatar) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (typeof FormData !== "undefined") {
-                const fpayload = new FormData();
-                fpayload.set("avatar", new Blob([avatar]));
-                yield axios_1.default.post(this.prefixes.HTTP +
-                    this.host +
-                    "/avatar/" +
-                    this.me.user().userID, fpayload, {
-                    headers: { "Content-Type": "multipart/form-data" },
-                    onUploadProgress: (progressEvent) => {
-                        const percentCompleted = Math.round((progressEvent.loaded * 100) / progressEvent.total);
-                        const { loaded, total } = progressEvent;
-                        const progress = {
-                            direction: "upload",
-                            token: this.getUser().userID,
-                            progress: percentCompleted,
-                            loaded,
-                            total,
-                        };
-                        this.emit("fileProgress", progress);
-                    },
-                });
-                return;
-            }
-            const payload = {
-                file: crypto_1.XUtils.encodeBase64(avatar),
-            };
-            yield axios_1.default.post(this.prefixes.HTTP +
+    async getToken(type) {
+        try {
+            const res = await ax.get(this.getHost() + "/token/" + type, {
+                responseType: "arraybuffer",
+            });
+            return msgpack.decode(Buffer.from(res.data));
+        }
+        catch (err) {
+            this.log.warn(err.toString());
+            return null;
+        }
+    }
+    async uploadAvatar(avatar) {
+        if (typeof FormData !== "undefined") {
+            const fpayload = new FormData();
+            fpayload.set("avatar", new Blob([new Uint8Array(avatar)]));
+            await ax.post(this.prefixes.HTTP +
                 this.host +
                 "/avatar/" +
-                this.me.user().userID +
-                "/json", msgpack_lite_1.default.encode(payload), { headers: { "Content-Type": "application/msgpack" } });
-        });
+                this.me.user().userID, fpayload, {
+                headers: { "Content-Type": "multipart/form-data" },
+                onUploadProgress: (progressEvent) => {
+                    const percentCompleted = Math.round((progressEvent.loaded * 100) /
+                        (progressEvent.total ?? 1));
+                    const { loaded, total = 0 } = progressEvent;
+                    const progress = {
+                        direction: "upload",
+                        token: this.getUser().userID,
+                        progress: percentCompleted,
+                        loaded,
+                        total,
+                    };
+                    this.emit("fileProgress", progress);
+                },
+            });
+            return;
+        }
+        const payload = {
+            file: XUtils.encodeBase64(avatar),
+        };
+        await ax.post(this.prefixes.HTTP +
+            this.host +
+            "/avatar/" +
+            this.me.user().userID +
+            "/json", msgpack.encode(payload), { headers: { "Content-Type": "application/msgpack" } });
     }
     /**
      * Gets a list of permissions for a server.
      *
      * @returns - The list of IPermissions objects.
      */
-    fetchPermissionList(serverID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield axios_1.default.get(this.prefixes.HTTP +
-                this.host +
-                "/server/" +
-                serverID +
-                "/permissions");
-            return msgpack_lite_1.default.decode(Buffer.from(res.data));
-        });
+    async fetchPermissionList(serverID) {
+        const res = await ax.get(this.prefixes.HTTP +
+            this.host +
+            "/server/" +
+            serverID +
+            "/permissions");
+        return msgpack.decode(Buffer.from(res.data));
     }
     /**
      * Gets all permissions for the logged in user.
      *
      * @returns - The list of IPermissions objects.
      */
-    getPermissions() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield axios_1.default.get(this.getHost() + "/user/" + this.getUser().userID + "/permissions");
-            return msgpack_lite_1.default.decode(Buffer.from(res.data));
-        });
+    async getPermissions() {
+        const res = await ax.get(this.getHost() + "/user/" + this.getUser().userID + "/permissions");
+        return msgpack.decode(Buffer.from(res.data));
     }
-    deletePermission(permissionID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield axios_1.default.delete(this.getHost() + "/permission/" + permissionID);
-        });
+    async deletePermission(permissionID) {
+        await ax.delete(this.getHost() + "/permission/" + permissionID);
     }
-    retrieveFile(fileID, key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const detailsRes = yield axios_1.default.get(this.getHost() + "/file/" + fileID + "/details");
-                const details = msgpack_lite_1.default.decode(Buffer.from(detailsRes.data));
-                const res = yield axios_1.default.get(this.getHost() + "/file/" + fileID, {
-                    onDownloadProgress: (progressEvent) => {
-                        const percentCompleted = Math.round((progressEvent.loaded * 100) / progressEvent.total);
-                        const { loaded, total } = progressEvent;
-                        const progress = {
-                            direction: "download",
-                            token: fileID,
-                            progress: percentCompleted,
-                            loaded,
-                            total,
-                        };
-                        this.emit("fileProgress", progress);
-                    },
-                });
-                const fileData = res.data;
-                const decrypted = tweetnacl_1.default.secretbox.open(Uint8Array.from(Buffer.from(fileData)), crypto_1.XUtils.decodeHex(details.nonce), crypto_1.XUtils.decodeHex(key));
-                if (decrypted) {
-                    const resp = {
-                        details,
-                        data: Buffer.from(decrypted),
+    async retrieveFile(fileID, key) {
+        try {
+            const detailsRes = await ax.get(this.getHost() + "/file/" + fileID + "/details");
+            const details = msgpack.decode(Buffer.from(detailsRes.data));
+            const res = await ax.get(this.getHost() + "/file/" + fileID, {
+                onDownloadProgress: (progressEvent) => {
+                    const percentCompleted = Math.round((progressEvent.loaded * 100) /
+                        (progressEvent.total ?? 1));
+                    const { loaded, total = 0 } = progressEvent;
+                    const progress = {
+                        direction: "download",
+                        token: fileID,
+                        progress: percentCompleted,
+                        loaded,
+                        total,
                     };
-                    return resp;
-                }
-                throw new Error("Decryption failed.");
-            }
-            catch (err) {
-                throw err;
+                    this.emit("fileProgress", progress);
+                },
+            });
+            const fileData = res.data;
+            const decrypted = nacl.secretbox.open(Uint8Array.from(Buffer.from(fileData)), XUtils.decodeHex(details.nonce), XUtils.decodeHex(key));
+            if (decrypted) {
+                const resp = {
+                    details,
+                    data: Buffer.from(decrypted),
+                };
+                return resp;
             }
-        });
+            throw new Error("Decryption failed.");
+        }
+        catch (err) {
+            throw err;
+        }
     }
-    deleteServer(serverID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield axios_1.default.delete(this.getHost() + "/server/" + serverID);
-        });
+    async deleteServer(serverID) {
+        await ax.delete(this.getHost() + "/server/" + serverID);
     }
     /**
      * Initializes the keyring. This must be called before anything else.
      */
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.hasInit) {
-                return new Error("You should only call init() once.");
+    async init() {
+        if (this.hasInit) {
+            return new Error("You should only call init() once.");
+        }
+        this.hasInit = true;
+        await this.populateKeyRing();
+        this.on("message", async (message) => {
+            if (message.direction === "outgoing" && !message.forward) {
+                this.forward(message);
+            }
+            if (message.direction === "incoming" &&
+                message.recipient === message.sender) {
+                return;
             }
-            this.hasInit = true;
-            yield this.populateKeyRing();
-            this.on("message", (message) => __awaiter(this, void 0, void 0, function* () {
-                if (message.direction === "outgoing" && !message.forward) {
-                    this.forward(message);
-                }
-                if (message.direction === "incoming" &&
-                    message.recipient === message.sender) {
-                    return;
-                }
-                yield this.database.saveMessage(message);
-            }));
-            this.emit("ready");
+            await this.database.saveMessage(message);
         });
+        this.emit("ready");
     }
-    deleteChannel(channelID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield axios_1.default.delete(this.getHost() + "/channel/" + channelID);
-        });
+    async deleteChannel(channelID) {
+        await ax.delete(this.getHost() + "/channel/" + channelID);
     }
     // returns the file details and the encryption key
-    createFile(file) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.log.info("Creating file, size: " + formatBytes_1.formatBytes(Buffer.byteLength(file)));
-            const nonce = crypto_1.xMakeNonce();
-            const key = tweetnacl_1.default.box.keyPair();
-            const box = tweetnacl_1.default.secretbox(Uint8Array.from(file), nonce, key.secretKey);
-            this.log.info("Encrypted size: " + formatBytes_1.formatBytes(Buffer.byteLength(box)));
-            if (typeof FormData !== "undefined") {
-                const fpayload = new FormData();
-                fpayload.set("owner", this.getDevice().deviceID);
-                fpayload.set("nonce", crypto_1.XUtils.encodeHex(nonce));
-                fpayload.set("file", new Blob([box]));
-                const fres = yield axios_1.default.post(this.getHost() + "/file", fpayload, {
-                    headers: { "Content-Type": "multipart/form-data" },
-                    onUploadProgress: (progressEvent) => {
-                        const percentCompleted = Math.round((progressEvent.loaded * 100) / progressEvent.total);
-                        const { loaded, total } = progressEvent;
-                        const progress = {
-                            direction: "upload",
-                            token: crypto_1.XUtils.encodeHex(nonce),
-                            progress: percentCompleted,
-                            loaded,
-                            total,
-                        };
-                        this.emit("fileProgress", progress);
-                    },
-                });
-                const fcreatedFile = msgpack_lite_1.default.decode(Buffer.from(fres.data));
-                return [fcreatedFile, crypto_1.XUtils.encodeHex(key.secretKey)];
-            }
-            const payload = {
-                owner: this.getDevice().deviceID,
-                nonce: crypto_1.XUtils.encodeHex(nonce),
-                file: crypto_1.XUtils.encodeBase64(box),
-            };
-            const res = yield axios_1.default.post(this.getHost() + "/file/json", msgpack_lite_1.default.encode(payload), { headers: { "Content-Type": "application/msgpack" } });
-            const createdFile = msgpack_lite_1.default.decode(Buffer.from(res.data));
-            return [createdFile, crypto_1.XUtils.encodeHex(key.secretKey)];
-        });
+    async createFile(file) {
+        this.log.info("Creating file, size: " + formatBytes(Buffer.byteLength(file)));
+        const nonce = xMakeNonce();
+        const key = nacl.box.keyPair();
+        const box = nacl.secretbox(Uint8Array.from(file), nonce, key.secretKey);
+        this.log.info("Encrypted size: " + formatBytes(Buffer.byteLength(box)));
+        if (typeof FormData !== "undefined") {
+            const fpayload = new FormData();
+            fpayload.set("owner", this.getDevice().deviceID);
+            fpayload.set("nonce", XUtils.encodeHex(nonce));
+            fpayload.set("file", new Blob([new Uint8Array(box)]));
+            const fres = await ax.post(this.getHost() + "/file", fpayload, {
+                headers: { "Content-Type": "multipart/form-data" },
+                onUploadProgress: (progressEvent) => {
+                    const percentCompleted = Math.round((progressEvent.loaded * 100) /
+                        (progressEvent.total ?? 1));
+                    const { loaded, total = 0 } = progressEvent;
+                    const progress = {
+                        direction: "upload",
+                        token: XUtils.encodeHex(nonce),
+                        progress: percentCompleted,
+                        loaded,
+                        total,
+                    };
+                    this.emit("fileProgress", progress);
+                },
+            });
+            const fcreatedFile = msgpack.decode(Buffer.from(fres.data));
+            return [fcreatedFile, XUtils.encodeHex(key.secretKey)];
+        }
+        const payload = {
+            owner: this.getDevice().deviceID,
+            nonce: XUtils.encodeHex(nonce),
+            file: XUtils.encodeBase64(box),
+        };
+        const res = await ax.post(this.getHost() + "/file/json", msgpack.encode(payload), { headers: { "Content-Type": "application/msgpack" } });
+        const createdFile = msgpack.decode(Buffer.from(res.data));
+        return [createdFile, XUtils.encodeHex(key.secretKey)];
     }
-    getUserList(channelID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield axios_1.default.post(this.getHost() + "/userList/" + channelID);
-            return msgpack_lite_1.default.decode(Buffer.from(res.data));
-        });
+    async getUserList(channelID) {
+        const res = await ax.post(this.getHost() + "/userList/" + channelID);
+        return msgpack.decode(Buffer.from(res.data));
     }
-    markSessionVerified(sessionID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.database.markSessionVerified(sessionID);
-        });
+    async markSessionVerified(sessionID) {
+        return this.database.markSessionVerified(sessionID);
     }
-    getGroupHistory(channelID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const messages = yield this.database.getGroupHistory(channelID);
-            return messages;
-        });
+    async getGroupHistory(channelID) {
+        const messages = await this.database.getGroupHistory(channelID);
+        return messages;
     }
-    deleteHistory(channelOrUserID, olderThan) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.database.deleteHistory(channelOrUserID, olderThan);
-        });
+    async deleteHistory(channelOrUserID, olderThan) {
+        await this.database.deleteHistory(channelOrUserID, olderThan);
     }
-    purgeHistory() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.database.purgeHistory();
-        });
+    async purgeHistory() {
+        await this.database.purgeHistory();
     }
-    getMessageHistory(userID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const messages = yield this.database.getMessageHistory(userID);
-            return messages;
-        });
+    async getMessageHistory(userID) {
+        const messages = await this.database.getMessageHistory(userID);
+        return messages;
     }
-    sendMessage(userID, message) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const [userEntry, err] = yield this.retrieveUserDBEntry(userID);
-                if (err) {
-                    throw err;
-                }
-                if (!userEntry) {
-                    throw new Error("Couldn't get user entry.");
-                }
-                let deviceList = yield this.getUserDeviceList(userID);
-                if (!deviceList) {
-                    let retries = 0;
-                    while (!deviceList) {
-                        deviceList = yield this.getUserDeviceList(userID);
-                        retries++;
-                        if (retries > 3) {
-                            throw new Error("Couldn't get device list.");
-                        }
-                    }
-                }
-                const mailID = uuid.v4();
-                const promises = [];
-                for (const device of deviceList) {
-                    promises.push(this.sendMail(device, userEntry, crypto_1.XUtils.decodeUTF8(message), null, mailID, false));
-                }
-                Promise.allSettled(promises).then((results) => {
-                    for (const result of results) {
-                        const { status } = result;
-                        if (status === "rejected") {
-                            this.log.warn("Message failed.");
-                            this.log.warn(result);
-                        }
-                    }
-                });
-            }
-            catch (err) {
-                this.log.error("Message " + (((_a = err.message) === null || _a === void 0 ? void 0 : _a.mailID) || "") + " threw exception.");
-                this.log.error(err.toString());
-                if ((_b = err.message) === null || _b === void 0 ? void 0 : _b.mailID) {
-                    yield this.database.deleteMessage(err.message.mailID);
-                }
+    async sendMessage(userID, message) {
+        try {
+            const [userEntry, err] = await this.retrieveUserDBEntry(userID);
+            if (err) {
                 throw err;
             }
-        });
-    }
-    sendGroupMessage(channelID, message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userList = yield this.getUserList(channelID);
-            for (const user of userList) {
-                this.userRecords[user.userID] = user;
+            if (!userEntry) {
+                throw new Error("Couldn't get user entry.");
+            }
+            let deviceList = await this.getUserDeviceList(userID);
+            if (!deviceList) {
+                let retries = 0;
+                while (!deviceList) {
+                    deviceList = await this.getUserDeviceList(userID);
+                    retries++;
+                    if (retries > 3) {
+                        throw new Error("Couldn't get device list.");
+                    }
+                }
             }
-            this.log.info("Sending to userlist:\n" + JSON.stringify(userList, null, 4));
             const mailID = uuid.v4();
             const promises = [];
-            const userIDs = [...new Set(userList.map((user) => user.userID))];
-            const devices = yield this.getMultiUserDeviceList(userIDs);
-            this.log.info("Retrieved devicelist:\n" + JSON.stringify(devices, null, 4));
-            for (const device of devices) {
-                promises.push(this.sendMail(device, this.userRecords[device.owner], crypto_1.XUtils.decodeUTF8(message), uint8uuid_1.uuidToUint8(channelID), mailID, false));
+            for (const device of deviceList) {
+                promises.push(this.sendMail(device, userEntry, XUtils.decodeUTF8(message), null, mailID, false));
             }
             Promise.allSettled(promises).then((results) => {
                 for (const result of results) {
@@ -1053,102 +1044,131 @@ class Client extends events_1.EventEmitter {
                     }
                 }
             });
-        });
+        }
+        catch (err) {
+            this.log.error("Message " + (err.message?.mailID || "") + " threw exception.");
+            this.log.error(err.toString());
+            if (err.message?.mailID) {
+                await this.database.deleteMessage(err.message.mailID);
+            }
+            throw err;
+        }
     }
-    createServer(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield axios_1.default.post(this.getHost() + "/server/" + btoa_1.default(name));
-            return msgpack_lite_1.default.decode(Buffer.from(res.data));
+    async sendGroupMessage(channelID, message) {
+        const userList = await this.getUserList(channelID);
+        for (const user of userList) {
+            this.userRecords[user.userID] = user;
+        }
+        this.log.info("Sending to userlist:\n" + JSON.stringify(userList, null, 4));
+        const mailID = uuid.v4();
+        const promises = [];
+        const userIDs = [...new Set(userList.map((user) => user.userID))];
+        const devices = await this.getMultiUserDeviceList(userIDs);
+        this.log.info("Retrieved devicelist:\n" + JSON.stringify(devices, null, 4));
+        for (const device of devices) {
+            promises.push(this.sendMail(device, this.userRecords[device.owner], XUtils.decodeUTF8(message), uuidToUint8(channelID), mailID, false));
+        }
+        Promise.allSettled(promises).then((results) => {
+            for (const result of results) {
+                const { status } = result;
+                if (status === "rejected") {
+                    this.log.warn("Message failed.");
+                    this.log.warn(result);
+                }
+            }
         });
     }
-    forward(message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const copy = Object.assign({}, message);
-            if (this.forwarded.includes(copy.mailID)) {
-                return;
-            }
-            this.forwarded.push(copy.mailID);
-            if (this.forwarded.length > 1000) {
-                this.forwarded.shift();
-            }
-            const msgBytes = Uint8Array.from(msgpack_lite_1.default.encode(copy));
-            const devices = yield this.getUserDeviceList(this.getUser().userID);
-            this.log.info("Forwarding to my other devices, deviceList length is " + (devices === null || devices === void 0 ? void 0 : devices.length));
-            if (!devices) {
-                throw new Error("Couldn't get own devices.");
-            }
-            const promises = [];
-            for (const device of devices) {
-                if (device.deviceID !== this.getDevice().deviceID) {
-                    promises.push(this.sendMail(device, this.getUser(), msgBytes, null, copy.mailID, true));
-                }
+    async createServer(name) {
+        const res = await ax.post(this.getHost() + "/server/" + btoa(name));
+        return msgpack.decode(Buffer.from(res.data));
+    }
+    async forward(message) {
+        const copy = { ...message };
+        if (this.forwarded.includes(copy.mailID)) {
+            return;
+        }
+        this.forwarded.push(copy.mailID);
+        if (this.forwarded.length > 1000) {
+            this.forwarded.shift();
+        }
+        const msgBytes = Uint8Array.from(msgpack.encode(copy));
+        const devices = await this.getUserDeviceList(this.getUser().userID);
+        this.log.info("Forwarding to my other devices, deviceList length is " +
+            devices?.length);
+        if (!devices) {
+            throw new Error("Couldn't get own devices.");
+        }
+        const promises = [];
+        for (const device of devices) {
+            if (device.deviceID !== this.getDevice().deviceID) {
+                promises.push(this.sendMail(device, this.getUser(), msgBytes, null, copy.mailID, true));
             }
-            Promise.allSettled(promises).then((results) => {
-                for (const result of results) {
-                    const { status } = result;
-                    if (status === "rejected") {
-                        this.log.warn("Message failed.");
-                        this.log.warn(result);
-                    }
+        }
+        Promise.allSettled(promises).then((results) => {
+            for (const result of results) {
+                const { status } = result;
+                if (status === "rejected") {
+                    this.log.warn("Message failed.");
+                    this.log.warn(result);
                 }
-            });
+            }
         });
     }
     /* Sends encrypted mail to a user. */
-    sendMail(device, user, msg, group, mailID, forward, retry = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            while (this.sending[device.deviceID] !== undefined) {
-                this.log.warn("Sending in progress to device ID " +
-                    device.deviceID +
-                    ", waiting.");
-                yield sleep_1.sleep(100);
-            }
-            this.log.info("Sending mail to user: \n" + JSON.stringify(user, null, 4));
-            this.log.info("Sending mail to device:\n " +
-                JSON.stringify(device.deviceID, null, 4));
-            this.sending[device.deviceID] = device;
-            const session = yield this.database.getSessionByDeviceID(device.deviceID);
-            if (!session || retry) {
-                this.log.info("Creating new session for " + device.deviceID);
-                yield this.createSession(device, user, msg, group, mailID, forward);
-                return;
-            }
-            else {
-                this.log.info("Found existing session for " + device.deviceID);
-            }
-            const nonce = crypto_1.xMakeNonce();
-            const cipher = tweetnacl_1.default.secretbox(msg, nonce, session.SK);
-            const extra = session.publicKey;
-            const mail = {
-                mailType: types_1.XTypes.WS.MailType.subsequent,
-                mailID: mailID || uuid.v4(),
-                recipient: device.deviceID,
-                cipher,
-                nonce,
-                extra,
-                sender: this.getDevice().deviceID,
-                group,
-                forward,
-                authorID: this.getUser().userID,
-                readerID: session.userID,
-            };
-            const msgb = {
-                transmissionID: uuid.v4(),
-                type: "resource",
-                resourceType: "mail",
-                action: "CREATE",
-                data: mail,
-            };
-            const hmac = crypto_1.xHMAC(mail, session.SK);
-            this.log.info("Mail hash: " + object_hash_1.default(mail));
-            this.log.info("Calculated hmac: " + crypto_1.XUtils.encodeHex(hmac));
-            const outMsg = forward
-                ? Object.assign(Object.assign({}, msgpack_lite_1.default.decode(msg)), { forward: true }) : {
+    async sendMail(device, user, msg, group, mailID, forward, retry = false) {
+        while (this.sending[device.deviceID] !== undefined) {
+            this.log.warn("Sending in progress to device ID " +
+                device.deviceID +
+                ", waiting.");
+            await sleep(100);
+        }
+        this.log.info("Sending mail to user: \n" + JSON.stringify(user, null, 4));
+        this.log.info("Sending mail to device:\n " +
+            JSON.stringify(device.deviceID, null, 4));
+        this.sending[device.deviceID] = device;
+        const session = await this.database.getSessionByDeviceID(device.deviceID);
+        if (!session || retry) {
+            this.log.info("Creating new session for " + device.deviceID);
+            await this.createSession(device, user, msg, group, mailID, forward);
+            return;
+        }
+        else {
+            this.log.info("Found existing session for " + device.deviceID);
+        }
+        const nonce = xMakeNonce();
+        const cipher = nacl.secretbox(msg, nonce, session.SK);
+        const extra = session.publicKey;
+        const mail = {
+            mailType: MailType.subsequent,
+            mailID: mailID || uuid.v4(),
+            recipient: device.deviceID,
+            cipher,
+            nonce,
+            extra,
+            sender: this.getDevice().deviceID,
+            group,
+            forward,
+            authorID: this.getUser().userID,
+            readerID: session.userID,
+        };
+        const msgb = {
+            transmissionID: uuid.v4(),
+            type: "resource",
+            resourceType: "mail",
+            action: "CREATE",
+            data: mail,
+        };
+        const hmac = xHMAC(mail, session.SK);
+        this.log.info("Mail hash: " + objectHash(mail));
+        this.log.info("Calculated hmac: " + XUtils.encodeHex(hmac));
+        const outMsg = forward
+            ? { ...msgpack.decode(msg), forward: true }
+            : {
                 mailID: mail.mailID,
                 sender: mail.sender,
                 recipient: mail.recipient,
-                nonce: crypto_1.XUtils.encodeHex(mail.nonce),
-                message: crypto_1.XUtils.encodeUTF8(msg),
+                nonce: XUtils.encodeHex(mail.nonce),
+                message: XUtils.encodeUTF8(msg),
                 direction: "outgoing",
                 timestamp: new Date(Date.now()),
                 decrypted: true,
@@ -1157,142 +1177,121 @@ class Client extends events_1.EventEmitter {
                 authorID: mail.authorID,
                 readerID: mail.readerID,
             };
-            this.emit("message", outMsg);
-            yield new Promise((res, rej) => {
-                const callback = (packedMsg) => __awaiter(this, void 0, void 0, function* () {
-                    const [header, receivedMsg] = crypto_1.XUtils.unpackMessage(packedMsg);
-                    if (receivedMsg.transmissionID === msgb.transmissionID) {
-                        this.conn.off("message", callback);
-                        if (receivedMsg.type === "success") {
-                            res(receivedMsg.data);
-                        }
-                        else {
-                            rej({
-                                error: receivedMsg,
-                                message: outMsg,
-                            });
-                        }
+        this.emit("message", outMsg);
+        await new Promise((res, rej) => {
+            const callback = async (packedMsg) => {
+                const [header, receivedMsg] = XUtils.unpackMessage(packedMsg);
+                if (receivedMsg.transmissionID === msgb.transmissionID) {
+                    this.conn.off("message", callback);
+                    if (receivedMsg.type === "success") {
+                        res(receivedMsg.data);
                     }
-                });
-                this.conn.on("message", callback);
-                this.send(msgb, hmac);
-            });
-            delete this.sending[device.deviceID];
-        });
-    }
-    getSessionList() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.database.getAllSessions();
+                    else {
+                        rej({
+                            error: receivedMsg,
+                            message: outMsg,
+                        });
+                    }
+                }
+            };
+            this.conn.on("message", callback);
+            this.send(msgb, hmac);
         });
+        delete this.sending[device.deviceID];
     }
-    getServerList() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield axios_1.default.get(this.getHost() + "/user/" + this.getUser().userID + "/servers");
-            return msgpack_lite_1.default.decode(Buffer.from(res.data));
-        });
+    async getSessionList() {
+        return this.database.getAllSessions();
     }
-    createChannel(name, serverID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const body = { name };
-            const res = yield axios_1.default.post(this.getHost() + "/server/" + serverID + "/channels", msgpack_lite_1.default.encode(body), { headers: { "Content-Type": "application/msgpack" } });
-            return msgpack_lite_1.default.decode(Buffer.from(res.data));
-        });
+    async getServerList() {
+        const res = await ax.get(this.getHost() + "/user/" + this.getUser().userID + "/servers");
+        return msgpack.decode(Buffer.from(res.data));
     }
-    getDeviceByID(deviceID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.deviceRecords[deviceID]) {
-                this.log.info("Found device in local cache.");
-                return this.deviceRecords[deviceID];
-            }
-            const device = yield this.database.getDevice(deviceID);
-            if (device) {
-                this.log.info("Found device in local db.");
-                this.deviceRecords[deviceID] = device;
-                return device;
-            }
-            try {
-                const res = yield axios_1.default.get(this.getHost() + "/device/" + deviceID);
-                this.log.info("Retrieved device from server.");
-                const fetchedDevice = msgpack_lite_1.default.decode(Buffer.from(res.data));
-                this.deviceRecords[deviceID] = fetchedDevice;
-                yield this.database.saveDevice(fetchedDevice);
-                return fetchedDevice;
-            }
-            catch (err) {
-                return null;
-            }
-        });
+    async createChannel(name, serverID) {
+        const body = { name };
+        const res = await ax.post(this.getHost() + "/server/" + serverID + "/channels", msgpack.encode(body), { headers: { "Content-Type": "application/msgpack" } });
+        return msgpack.decode(Buffer.from(res.data));
     }
-    deleteDevice(deviceID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (deviceID === this.getDevice().deviceID) {
-                throw new Error("You can't delete the device you're logged in to.");
-            }
-            yield axios_1.default.delete(this.prefixes.HTTP +
-                this.host +
-                "/user/" +
-                this.getUser().userID +
-                "/devices/" +
-                deviceID);
-        });
+    async getDeviceByID(deviceID) {
+        if (this.deviceRecords[deviceID]) {
+            this.log.info("Found device in local cache.");
+            return this.deviceRecords[deviceID];
+        }
+        const device = await this.database.getDevice(deviceID);
+        if (device) {
+            this.log.info("Found device in local db.");
+            this.deviceRecords[deviceID] = device;
+            return device;
+        }
+        try {
+            const res = await ax.get(this.getHost() + "/device/" + deviceID);
+            this.log.info("Retrieved device from server.");
+            const fetchedDevice = msgpack.decode(Buffer.from(res.data));
+            this.deviceRecords[deviceID] = fetchedDevice;
+            await this.database.saveDevice(fetchedDevice);
+            return fetchedDevice;
+        }
+        catch (err) {
+            return null;
+        }
     }
-    getMultiUserDeviceList(userIDs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const res = yield axios_1.default.post(this.getHost() + "/deviceList", msgpack_lite_1.default.encode(userIDs), { headers: { "Content-Type": "application/msgpack" } });
-                const devices = msgpack_lite_1.default.decode(Buffer.from(res.data));
-                for (const device of devices) {
-                    this.deviceRecords[device.deviceID] = device;
-                }
-                return devices;
-            }
-            catch (err) {
-                return [];
+    async deleteDevice(deviceID) {
+        if (deviceID === this.getDevice().deviceID) {
+            throw new Error("You can't delete the device you're logged in to.");
+        }
+        await ax.delete(this.prefixes.HTTP +
+            this.host +
+            "/user/" +
+            this.getUser().userID +
+            "/devices/" +
+            deviceID);
+    }
+    async getMultiUserDeviceList(userIDs) {
+        try {
+            const res = await ax.post(this.getHost() + "/deviceList", msgpack.encode(userIDs), { headers: { "Content-Type": "application/msgpack" } });
+            const devices = msgpack.decode(Buffer.from(res.data));
+            for (const device of devices) {
+                this.deviceRecords[device.deviceID] = device;
             }
-        });
+            return devices;
+        }
+        catch (err) {
+            return [];
+        }
     }
-    getUserDeviceList(userID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const res = yield axios_1.default.get(this.getHost() + "/user/" + userID + "/devices");
-                const devices = msgpack_lite_1.default.decode(Buffer.from(res.data));
-                for (const device of devices) {
-                    this.deviceRecords[device.deviceID] = device;
-                }
-                return devices;
-            }
-            catch (err) {
-                return null;
+    async getUserDeviceList(userID) {
+        try {
+            const res = await ax.get(this.getHost() + "/user/" + userID + "/devices");
+            const devices = msgpack.decode(Buffer.from(res.data));
+            for (const device of devices) {
+                this.deviceRecords[device.deviceID] = device;
             }
-        });
+            return devices;
+        }
+        catch (err) {
+            return null;
+        }
     }
-    getServerByID(serverID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const res = yield axios_1.default.get(this.getHost() + "/server/" + serverID);
-                return msgpack_lite_1.default.decode(Buffer.from(res.data));
-            }
-            catch (err) {
-                return null;
-            }
-        });
+    async getServerByID(serverID) {
+        try {
+            const res = await ax.get(this.getHost() + "/server/" + serverID);
+            return msgpack.decode(Buffer.from(res.data));
+        }
+        catch (err) {
+            return null;
+        }
     }
-    getChannelByID(channelID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const res = yield axios_1.default.get(this.getHost() + "/channel/" + channelID);
-                return msgpack_lite_1.default.decode(Buffer.from(res.data));
-            }
-            catch (err) {
-                return null;
-            }
-        });
+    async getChannelByID(channelID) {
+        try {
+            const res = await ax.get(this.getHost() + "/channel/" + channelID);
+            return msgpack.decode(Buffer.from(res.data));
+        }
+        catch (err) {
+            return null;
+        }
     }
-    getChannelList(serverID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield axios_1.default.get(this.getHost() + "/server/" + serverID + "/channels");
-            return msgpack_lite_1.default.decode(Buffer.from(res.data));
-        });
+    async getChannelList(serverID) {
+        const res = await ax.get(this.getHost() + "/server/" + serverID + "/channels");
+        return msgpack.decode(Buffer.from(res.data));
     }
     /* Get the currently logged in user. You cannot call this until
     after the auth event is emitted. */
@@ -1314,139 +1313,135 @@ class Client extends events_1.EventEmitter {
     /* Retrieves the userID with the user identifier.
     user identifier is checked for userID, then signkey,
     and finally falls back to username. */
-    retrieveUserDBEntry(userIdentifier) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.userRecords[userIdentifier]) {
-                return [this.userRecords[userIdentifier], null];
-            }
-            try {
-                const res = yield axios_1.default.get(this.getHost() + "/user/" + userIdentifier);
-                const userRecord = msgpack_lite_1.default.decode(Buffer.from(res.data));
-                this.userRecords[userIdentifier] = userRecord;
-                return [userRecord, null];
-            }
-            catch (err) {
-                return [null, err];
-            }
-        });
+    async retrieveUserDBEntry(userIdentifier) {
+        if (this.userRecords[userIdentifier]) {
+            return [this.userRecords[userIdentifier], null];
+        }
+        try {
+            const res = await ax.get(this.getHost() + "/user/" + userIdentifier);
+            const userRecord = msgpack.decode(Buffer.from(res.data));
+            this.userRecords[userIdentifier] = userRecord;
+            return [userRecord, null];
+        }
+        catch (err) {
+            return [null, err];
+        }
     }
     /* Retrieves the current list of users you have sessions with. */
-    getFamiliars() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sessions = yield this.database.getAllSessions();
-            const familiars = [];
-            for (const session of sessions) {
-                const [user, err] = yield this.retrieveUserDBEntry(session.userID);
-                if (user) {
-                    familiars.push(user);
-                }
+    async getFamiliars() {
+        const sessions = await this.database.getAllSessions();
+        const familiars = [];
+        for (const session of sessions) {
+            const [user, err] = await this.retrieveUserDBEntry(session.userID);
+            if (user) {
+                familiars.push(user);
             }
-            return familiars;
-        });
+        }
+        return familiars;
     }
-    createSession(device, user, message, group, 
+    async createSession(device, user, message, group, 
     /* this is passed through if the first message is
     part of a group message */
     mailID, forward) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            let keyBundle;
-            this.log.info("Requesting key bundle for device: " +
-                JSON.stringify(device, null, 4));
-            try {
-                keyBundle = yield this.retrieveKeyBundle(device.deviceID);
-            }
-            catch (err) {
-                this.log.warn("Couldn't get key bundle:", err);
-                return;
-            }
-            this.log.warn(this.toString() +
-                " retrieved keybundle #" + ((_a = keyBundle.otk) === null || _a === void 0 ? void 0 : _a.index.toString()) +
-                " for " +
-                device.deviceID);
-            // my keys
-            const IK_A = this.xKeyRing.identityKeys.secretKey;
-            const IK_AP = this.xKeyRing.identityKeys.publicKey;
-            const EK_A = this.xKeyRing.ephemeralKeys.secretKey;
-            // their keys
-            const IK_B = crypto_1.XKeyConvert.convertPublicKey(keyBundle.signKey);
-            const SPK_B = keyBundle.preKey.publicKey;
-            const OPK_B = keyBundle.otk ? keyBundle.otk.publicKey : null;
-            // diffie hellman functions
-            const DH1 = crypto_1.xDH(IK_A, SPK_B);
-            const DH2 = crypto_1.xDH(EK_A, IK_B);
-            const DH3 = crypto_1.xDH(EK_A, SPK_B);
-            const DH4 = OPK_B ? crypto_1.xDH(EK_A, OPK_B) : null;
-            // initial key material
-            const IKM = DH4 ? crypto_1.xConcat(DH1, DH2, DH3, DH4) : crypto_1.xConcat(DH1, DH2, DH3);
-            // one time key index
-            const IDX = keyBundle.otk
-                ? crypto_1.XUtils.numberToUint8Arr(keyBundle.otk.index)
-                : crypto_1.XUtils.numberToUint8Arr(0);
-            // shared secret key
-            const SK = crypto_1.xKDF(IKM);
-            this.log.info("Obtained SK, " + crypto_1.XUtils.encodeHex(SK));
-            const PK = tweetnacl_1.default.box.keyPair.fromSecretKey(SK).publicKey;
-            this.log.info(this.toString() +
-                " Obtained PK for " +
-                device.deviceID +
-                " " +
-                crypto_1.XUtils.encodeHex(PK));
-            const AD = crypto_1.xConcat(crypto_1.xEncode(crypto_1.xConstants.CURVE, IK_AP), crypto_1.xEncode(crypto_1.xConstants.CURVE, IK_B));
-            const nonce = crypto_1.xMakeNonce();
-            const cipher = tweetnacl_1.default.secretbox(message, nonce, SK);
-            this.log.info("Encrypted ciphertext.");
-            /* 32 bytes for signkey, 32 bytes for ephemeral key,
-            68 bytes for AD, 6 bytes for otk index (empty for no otk) */
-            const extra = crypto_1.xConcat(this.signKeys.publicKey, this.xKeyRing.ephemeralKeys.publicKey, PK, AD, IDX);
-            const mail = {
-                mailType: types_1.XTypes.WS.MailType.initial,
-                mailID: mailID || uuid.v4(),
-                recipient: device.deviceID,
-                cipher,
-                nonce,
-                extra,
-                sender: this.getDevice().deviceID,
-                group,
-                forward,
-                authorID: this.getUser().userID,
-                readerID: user.userID,
-            };
-            const hmac = crypto_1.xHMAC(mail, SK);
-            this.log.info("Mail hash: " + object_hash_1.default(mail));
-            this.log.info("Generated hmac: " + crypto_1.XUtils.encodeHex(hmac));
-            const msg = {
-                transmissionID: uuid.v4(),
-                type: "resource",
-                resourceType: "mail",
-                action: "CREATE",
-                data: mail,
-            };
-            // discard the ephemeral keys
-            this.newEphemeralKeys();
-            // save the encryption session
-            this.log.info("Saving new session.");
-            const sessionEntry = {
-                verified: false,
-                sessionID: uuid.v4(),
-                userID: user.userID,
-                mode: "initiator",
-                SK: crypto_1.XUtils.encodeHex(SK),
-                publicKey: crypto_1.XUtils.encodeHex(PK),
-                lastUsed: new Date(Date.now()),
-                fingerprint: crypto_1.XUtils.encodeHex(AD),
-                deviceID: device.deviceID,
-            };
-            yield this.database.saveSession(sessionEntry);
-            this.emit("session", sessionEntry, user);
-            // emit the message
-            const emitMsg = forward
-                ? Object.assign(Object.assign({}, msgpack_lite_1.default.decode(message)), { forward: true }) : {
-                nonce: crypto_1.XUtils.encodeHex(mail.nonce),
+        let keyBundle;
+        this.log.info("Requesting key bundle for device: " +
+            JSON.stringify(device, null, 4));
+        try {
+            keyBundle = await this.retrieveKeyBundle(device.deviceID);
+        }
+        catch (err) {
+            this.log.warn("Couldn't get key bundle:", err);
+            return;
+        }
+        this.log.warn(this.toString() +
+            " retrieved keybundle #" +
+            keyBundle.otk?.index.toString() +
+            " for " +
+            device.deviceID);
+        // my keys
+        const IK_A = this.xKeyRing.identityKeys.secretKey;
+        const IK_AP = this.xKeyRing.identityKeys.publicKey;
+        const EK_A = this.xKeyRing.ephemeralKeys.secretKey;
+        // their keys
+        const IK_B = XKeyConvert.convertPublicKey(keyBundle.signKey);
+        const SPK_B = keyBundle.preKey.publicKey;
+        const OPK_B = keyBundle.otk ? keyBundle.otk.publicKey : null;
+        // diffie hellman functions
+        const DH1 = xDH(IK_A, SPK_B);
+        const DH2 = xDH(EK_A, IK_B);
+        const DH3 = xDH(EK_A, SPK_B);
+        const DH4 = OPK_B ? xDH(EK_A, OPK_B) : null;
+        // initial key material
+        const IKM = DH4 ? xConcat(DH1, DH2, DH3, DH4) : xConcat(DH1, DH2, DH3);
+        // one time key index
+        const IDX = keyBundle.otk
+            ? XUtils.numberToUint8Arr(keyBundle.otk.index)
+            : XUtils.numberToUint8Arr(0);
+        // shared secret key
+        const SK = xKDF(IKM);
+        this.log.info("Obtained SK, " + XUtils.encodeHex(SK));
+        const PK = nacl.box.keyPair.fromSecretKey(SK).publicKey;
+        this.log.info(this.toString() +
+            " Obtained PK for " +
+            device.deviceID +
+            " " +
+            XUtils.encodeHex(PK));
+        const AD = xConcat(xEncode(xConstants.CURVE, IK_AP), xEncode(xConstants.CURVE, IK_B));
+        const nonce = xMakeNonce();
+        const cipher = nacl.secretbox(message, nonce, SK);
+        this.log.info("Encrypted ciphertext.");
+        /* 32 bytes for signkey, 32 bytes for ephemeral key,
+        68 bytes for AD, 6 bytes for otk index (empty for no otk) */
+        const extra = xConcat(this.signKeys.publicKey, this.xKeyRing.ephemeralKeys.publicKey, PK, AD, IDX);
+        const mail = {
+            mailType: MailType.initial,
+            mailID: mailID || uuid.v4(),
+            recipient: device.deviceID,
+            cipher,
+            nonce,
+            extra,
+            sender: this.getDevice().deviceID,
+            group,
+            forward,
+            authorID: this.getUser().userID,
+            readerID: user.userID,
+        };
+        const hmac = xHMAC(mail, SK);
+        this.log.info("Mail hash: " + objectHash(mail));
+        this.log.info("Generated hmac: " + XUtils.encodeHex(hmac));
+        const msg = {
+            transmissionID: uuid.v4(),
+            type: "resource",
+            resourceType: "mail",
+            action: "CREATE",
+            data: mail,
+        };
+        // discard the ephemeral keys
+        this.newEphemeralKeys();
+        // save the encryption session
+        this.log.info("Saving new session.");
+        const sessionEntry = {
+            verified: false,
+            sessionID: uuid.v4(),
+            userID: user.userID,
+            mode: "initiator",
+            SK: XUtils.encodeHex(SK),
+            publicKey: XUtils.encodeHex(PK),
+            lastUsed: new Date(Date.now()),
+            fingerprint: XUtils.encodeHex(AD),
+            deviceID: device.deviceID,
+        };
+        await this.database.saveSession(sessionEntry);
+        this.emit("session", sessionEntry, user);
+        // emit the message
+        const emitMsg = forward
+            ? { ...msgpack.decode(message), forward: true }
+            : {
+                nonce: XUtils.encodeHex(mail.nonce),
                 mailID: mail.mailID,
                 sender: mail.sender,
                 recipient: mail.recipient,
-                message: crypto_1.XUtils.encodeUTF8(message),
+                message: XUtils.encodeUTF8(message),
                 direction: "outgoing",
                 timestamp: new Date(Date.now()),
                 decrypted: true,
@@ -1455,30 +1450,29 @@ class Client extends events_1.EventEmitter {
                 authorID: mail.authorID,
                 readerID: mail.readerID,
             };
-            this.emit("message", emitMsg);
-            // send mail and wait for response
-            yield new Promise((res, rej) => {
-                const callback = (packedMsg) => {
-                    const [header, receivedMsg] = crypto_1.XUtils.unpackMessage(packedMsg);
-                    if (receivedMsg.transmissionID === msg.transmissionID) {
-                        this.conn.off("message", callback);
-                        if (receivedMsg.type === "success") {
-                            res(receivedMsg.data);
-                        }
-                        else {
-                            rej({
-                                error: receivedMsg,
-                                message: emitMsg,
-                            });
-                        }
+        this.emit("message", emitMsg);
+        // send mail and wait for response
+        await new Promise((res, rej) => {
+            const callback = (packedMsg) => {
+                const [header, receivedMsg] = XUtils.unpackMessage(packedMsg);
+                if (receivedMsg.transmissionID === msg.transmissionID) {
+                    this.conn.off("message", callback);
+                    if (receivedMsg.type === "success") {
+                        res(receivedMsg.data);
                     }
-                };
-                this.conn.on("message", callback);
-                this.send(msg, hmac);
-                this.log.info("Mail sent.");
-            });
-            delete this.sending[device.deviceID];
+                    else {
+                        rej({
+                            error: receivedMsg,
+                            message: emitMsg,
+                        });
+                    }
+                }
+            };
+            this.conn.on("message", callback);
+            this.send(msg, hmac);
+            this.log.info("Mail sent.");
         });
+        delete this.sending[device.deviceID];
     }
     sendReceipt(nonce) {
         const receipt = {
@@ -1488,91 +1482,93 @@ class Client extends events_1.EventEmitter {
         };
         this.send(receipt);
     }
-    getSessionByPubkey(publicKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const strPubKey = crypto_1.XUtils.encodeHex(publicKey);
-            if (this.sessionRecords[strPubKey]) {
-                return this.sessionRecords[strPubKey];
-            }
-            const session = yield this.database.getSessionByPublicKey(publicKey);
-            if (session) {
-                this.sessionRecords[strPubKey] = session;
-            }
-            return session;
-        });
-    }
-    readMail(header, mail, timestamp) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.sendReceipt(mail.nonce);
-            let timeout = 1;
-            while (this.reading) {
-                yield sleep_1.sleep(timeout);
-                timeout *= 2;
-            }
-            this.reading = true;
-            const healSession = () => __awaiter(this, void 0, void 0, function* () {
+    async getSessionByPubkey(publicKey) {
+        const strPubKey = XUtils.encodeHex(publicKey);
+        if (this.sessionRecords[strPubKey]) {
+            return this.sessionRecords[strPubKey];
+        }
+        const session = await this.database.getSessionByPublicKey(publicKey);
+        if (session) {
+            this.sessionRecords[strPubKey] = session;
+        }
+        return session;
+    }
+    async readMail(header, mail, timestamp) {
+        this.sendReceipt(mail.nonce);
+        let timeout = 1;
+        while (this.reading) {
+            await sleep(timeout);
+            timeout *= 2;
+        }
+        this.reading = true;
+        try {
+            const healSession = async () => {
                 this.log.info("Requesting retry of " + mail.mailID);
-                const deviceEntry = yield this.getDeviceByID(mail.sender);
-                const [user, err] = yield this.retrieveUserDBEntry(mail.authorID);
+                const deviceEntry = await this.getDeviceByID(mail.sender);
+                const [user, err] = await this.retrieveUserDBEntry(mail.authorID);
                 if (deviceEntry && user) {
-                    this.createSession(deviceEntry, user, crypto_1.XUtils.decodeUTF8(`��RETRY_REQUEST:${mail.mailID}��`), mail.group, uuid.v4(), false);
+                    this.createSession(deviceEntry, user, XUtils.decodeUTF8(`��RETRY_REQUEST:${mail.mailID}��`), mail.group, uuid.v4(), false);
                 }
-            });
+            };
             this.log.info("Received mail from " + mail.sender);
             switch (mail.mailType) {
-                case types_1.XTypes.WS.MailType.subsequent:
+                case MailType.subsequent:
                     const [publicKey] = Client.deserializeExtra(mail.mailType, mail.extra);
-                    let session = yield this.getSessionByPubkey(publicKey);
+                    let session = await this.getSessionByPubkey(publicKey);
                     let retries = 0;
                     while (!session) {
                         if (retries > 3) {
                             break;
                         }
-                        session = yield this.getSessionByPubkey(publicKey);
+                        session = await this.getSessionByPubkey(publicKey);
                         retries++;
                         return;
                     }
                     if (!session) {
                         this.log.warn("Couldn't find session public key " +
-                            crypto_1.XUtils.encodeHex(publicKey));
+                            XUtils.encodeHex(publicKey));
                         healSession();
                         return;
                     }
                     this.log.info("Session found for " + mail.sender);
-                    this.log.info("Mail nonce " + crypto_1.XUtils.encodeHex(mail.nonce));
-                    const HMAC = crypto_1.xHMAC(mail, session.SK);
-                    this.log.info("Mail hash: " + object_hash_1.default(mail));
-                    this.log.info("Calculated hmac: " + crypto_1.XUtils.encodeHex(HMAC));
-                    if (!crypto_1.XUtils.bytesEqual(HMAC, header)) {
+                    this.log.info("Mail nonce " + XUtils.encodeHex(mail.nonce));
+                    const HMAC = xHMAC(mail, session.SK);
+                    this.log.info("Mail hash: " + objectHash(mail));
+                    this.log.info("Calculated hmac: " + XUtils.encodeHex(HMAC));
+                    if (!XUtils.bytesEqual(HMAC, header)) {
                         this.log.warn("Message authentication failed (HMAC does not match).");
                         healSession();
                         return;
                     }
-                    const decrypted = tweetnacl_1.default.secretbox.open(mail.cipher, mail.nonce, session.SK);
+                    const decrypted = nacl.secretbox.open(mail.cipher, mail.nonce, session.SK);
                     if (decrypted) {
                         this.log.info("Decryption successful.");
                         let plaintext = "";
                         if (!mail.forward) {
-                            plaintext = crypto_1.XUtils.encodeUTF8(decrypted);
+                            plaintext = XUtils.encodeUTF8(decrypted);
                         }
                         // emit the message
                         const message = mail.forward
-                            ? Object.assign(Object.assign({}, msgpack_lite_1.default.decode(decrypted)), { forward: true }) : {
-                            nonce: crypto_1.XUtils.encodeHex(mail.nonce),
-                            mailID: mail.mailID,
-                            sender: mail.sender,
-                            recipient: mail.recipient,
-                            message: crypto_1.XUtils.encodeUTF8(decrypted),
-                            direction: "incoming",
-                            timestamp: new Date(timestamp),
-                            decrypted: true,
-                            group: mail.group
-                                ? uuid.stringify(mail.group)
-                                : null,
-                            forward: mail.forward,
-                            authorID: mail.authorID,
-                            readerID: mail.readerID,
-                        };
+                            ? {
+                                ...msgpack.decode(decrypted),
+                                forward: true,
+                            }
+                            : {
+                                nonce: XUtils.encodeHex(mail.nonce),
+                                mailID: mail.mailID,
+                                sender: mail.sender,
+                                recipient: mail.recipient,
+                                message: XUtils.encodeUTF8(decrypted),
+                                direction: "incoming",
+                                timestamp: new Date(timestamp),
+                                decrypted: true,
+                                group: mail.group
+                                    ? uuid.stringify(mail.group)
+                                    : null,
+                                forward: mail.forward,
+                                authorID: mail.authorID,
+                                readerID: mail.readerID,
+                            };
                         this.emit("message", message);
                         this.database.markSessionUsed(session.sessionID);
                     }
@@ -1581,7 +1577,7 @@ class Client extends events_1.EventEmitter {
                         healSession();
                         // emit the message
                         const message = {
-                            nonce: crypto_1.XUtils.encodeHex(mail.nonce),
+                            nonce: XUtils.encodeHex(mail.nonce),
                             mailID: mail.mailID,
                             sender: mail.sender,
                             recipient: mail.recipient,
@@ -1589,7 +1585,9 @@ class Client extends events_1.EventEmitter {
                             direction: "incoming",
                             timestamp: new Date(timestamp),
                             decrypted: false,
-                            group: mail.group ? uuid.stringify(mail.group) : null,
+                            group: mail.group
+                                ? uuid.stringify(mail.group)
+                                : null,
                             forward: mail.forward,
                             authorID: mail.authorID,
                             readerID: mail.readerID,
@@ -1597,33 +1595,33 @@ class Client extends events_1.EventEmitter {
                         this.emit("message", message);
                     }
                     break;
-                case types_1.XTypes.WS.MailType.initial:
+                case MailType.initial:
                     this.log.info("Initiating new session.");
-                    const [signKey, ephKey, assocData, indexBytes,] = Client.deserializeExtra(types_1.XTypes.WS.MailType.initial, mail.extra);
-                    const preKeyIndex = crypto_1.XUtils.uint8ArrToNumber(indexBytes);
+                    const [signKey, ephKey, assocData, indexBytes] = Client.deserializeExtra(MailType.initial, mail.extra);
+                    const preKeyIndex = XUtils.uint8ArrToNumber(indexBytes);
                     this.log.info(this.toString() + " otk #" + preKeyIndex + " indicated");
                     const otk = preKeyIndex === 0
                         ? null
-                        : yield this.database.getOneTimeKey(preKeyIndex);
+                        : await this.database.getOneTimeKey(preKeyIndex);
                     if (otk) {
                         this.log.info("otk #" +
-                            JSON.stringify(otk === null || otk === void 0 ? void 0 : otk.index) +
+                            JSON.stringify(otk?.index) +
                             " retrieved from database.");
                     }
-                    this.log.info("signKey: " + crypto_1.XUtils.encodeHex(signKey));
-                    this.log.info("preKey: " + crypto_1.XUtils.encodeHex(ephKey));
+                    this.log.info("signKey: " + XUtils.encodeHex(signKey));
+                    this.log.info("preKey: " + XUtils.encodeHex(ephKey));
                     if (otk) {
-                        this.log.info("OTK: " + crypto_1.XUtils.encodeHex(otk.keyPair.publicKey));
+                        this.log.info("OTK: " + XUtils.encodeHex(otk.keyPair.publicKey));
                     }
-                    if ((otk === null || otk === void 0 ? void 0 : otk.index) !== preKeyIndex && preKeyIndex !== 0) {
+                    if (otk?.index !== preKeyIndex && preKeyIndex !== 0) {
                         this.log.warn("OTK index mismatch, received " +
-                            JSON.stringify(otk === null || otk === void 0 ? void 0 : otk.index) +
+                            JSON.stringify(otk?.index) +
                             ", expected " +
                             preKeyIndex.toString());
                         return;
                     }
                     // their public keys
-                    const IK_A = crypto_1.XKeyConvert.convertPublicKey(signKey);
+                    const IK_A = XKeyConvert.convertPublicKey(signKey);
                     const EK_A = ephKey;
                     // my private keys
                     const IK_B = this.xKeyRing.identityKeys.secretKey;
@@ -1631,71 +1629,72 @@ class Client extends events_1.EventEmitter {
                     const SPK_B = this.xKeyRing.preKeys.keyPair.secretKey;
                     const OPK_B = otk ? otk.keyPair.secretKey : null;
                     // diffie hellman functions
-                    const DH1 = crypto_1.xDH(SPK_B, IK_A);
-                    const DH2 = crypto_1.xDH(IK_B, EK_A);
-                    const DH3 = crypto_1.xDH(SPK_B, EK_A);
-                    const DH4 = OPK_B ? crypto_1.xDH(OPK_B, EK_A) : null;
+                    const DH1 = xDH(SPK_B, IK_A);
+                    const DH2 = xDH(IK_B, EK_A);
+                    const DH3 = xDH(SPK_B, EK_A);
+                    const DH4 = OPK_B ? xDH(OPK_B, EK_A) : null;
                     // initial key material
                     const IKM = DH4
-                        ? crypto_1.xConcat(DH1, DH2, DH3, DH4)
-                        : crypto_1.xConcat(DH1, DH2, DH3);
+                        ? xConcat(DH1, DH2, DH3, DH4)
+                        : xConcat(DH1, DH2, DH3);
                     // shared secret key
-                    const SK = crypto_1.xKDF(IKM);
+                    const SK = xKDF(IKM);
                     this.log.info("Obtained SK for " +
                         mail.sender +
                         ", " +
-                        crypto_1.XUtils.encodeHex(SK));
+                        XUtils.encodeHex(SK));
                     // shared public key
-                    const PK = tweetnacl_1.default.box.keyPair.fromSecretKey(SK).publicKey;
+                    const PK = nacl.box.keyPair.fromSecretKey(SK).publicKey;
                     this.log.info(this.toString() +
                         "Obtained PK for " +
                         mail.sender +
                         " " +
-                        crypto_1.XUtils.encodeHex(PK));
-                    const hmac = crypto_1.xHMAC(mail, SK);
-                    this.log.info("Mail hash: " + object_hash_1.default(mail));
-                    this.log.info("Calculated hmac: " + crypto_1.XUtils.encodeHex(hmac));
+                        XUtils.encodeHex(PK));
+                    const hmac = xHMAC(mail, SK);
+                    this.log.info("Mail hash: " + objectHash(mail));
+                    this.log.info("Calculated hmac: " + XUtils.encodeHex(hmac));
                     // associated data
-                    const AD = crypto_1.xConcat(crypto_1.xEncode(crypto_1.xConstants.CURVE, IK_A), crypto_1.xEncode(crypto_1.xConstants.CURVE, IK_BP));
-                    if (!crypto_1.XUtils.bytesEqual(hmac, header)) {
+                    const AD = xConcat(xEncode(xConstants.CURVE, IK_A), xEncode(xConstants.CURVE, IK_BP));
+                    if (!XUtils.bytesEqual(hmac, header)) {
                         console.warn("Mail authentication failed (HMAC did not match).");
                         console.warn(mail);
                         return;
                     }
                     this.log.info("Mail authenticated successfully.");
-                    const unsealed = tweetnacl_1.default.secretbox.open(mail.cipher, mail.nonce, SK);
+                    const unsealed = nacl.secretbox.open(mail.cipher, mail.nonce, SK);
                     if (unsealed) {
                         this.log.info("Decryption successful.");
                         let plaintext = "";
                         if (!mail.forward) {
-                            plaintext = crypto_1.XUtils.encodeUTF8(unsealed);
+                            plaintext = XUtils.encodeUTF8(unsealed);
                         }
                         // emit the message
                         const message = mail.forward
-                            ? Object.assign(Object.assign({}, msgpack_lite_1.default.decode(unsealed)), { forward: true }) : {
-                            nonce: crypto_1.XUtils.encodeHex(mail.nonce),
-                            mailID: mail.mailID,
-                            sender: mail.sender,
-                            recipient: mail.recipient,
-                            message: plaintext,
-                            direction: "incoming",
-                            timestamp: new Date(timestamp),
-                            decrypted: true,
-                            group: mail.group
-                                ? uuid.stringify(mail.group)
-                                : null,
-                            forward: mail.forward,
-                            authorID: mail.authorID,
-                            readerID: mail.readerID,
-                        };
+                            ? { ...msgpack.decode(unsealed), forward: true }
+                            : {
+                                nonce: XUtils.encodeHex(mail.nonce),
+                                mailID: mail.mailID,
+                                sender: mail.sender,
+                                recipient: mail.recipient,
+                                message: plaintext,
+                                direction: "incoming",
+                                timestamp: new Date(timestamp),
+                                decrypted: true,
+                                group: mail.group
+                                    ? uuid.stringify(mail.group)
+                                    : null,
+                                forward: mail.forward,
+                                authorID: mail.authorID,
+                                readerID: mail.readerID,
+                            };
                         this.emit("message", message);
                         // discard onetimekey
-                        yield this.database.deleteOneTimeKey(preKeyIndex);
-                        const deviceEntry = yield this.getDeviceByID(mail.sender);
+                        await this.database.deleteOneTimeKey(preKeyIndex);
+                        const deviceEntry = await this.getDeviceByID(mail.sender);
                         if (!deviceEntry) {
                             throw new Error("Couldn't get device entry.");
                         }
-                        const [userEntry, userErr] = yield this.retrieveUserDBEntry(deviceEntry.owner);
+                        const [userEntry, userErr] = await this.retrieveUserDBEntry(deviceEntry.owner);
                         if (!userEntry) {
                             throw new Error("Couldn't get user entry.");
                         }
@@ -1707,14 +1706,14 @@ class Client extends events_1.EventEmitter {
                             sessionID: uuid.v4(),
                             userID: userEntry.userID,
                             mode: "receiver",
-                            SK: crypto_1.XUtils.encodeHex(SK),
-                            publicKey: crypto_1.XUtils.encodeHex(PK),
+                            SK: XUtils.encodeHex(SK),
+                            publicKey: XUtils.encodeHex(PK),
                             lastUsed: new Date(Date.now()),
-                            fingerprint: crypto_1.XUtils.encodeHex(AD),
+                            fingerprint: XUtils.encodeHex(AD),
                             deviceID: mail.sender,
                         };
-                        yield this.database.saveSession(newSession);
-                        let [user, err] = yield this.retrieveUserDBEntry(newSession.userID);
+                        await this.database.saveSession(newSession);
+                        let [user, err] = await this.retrieveUserDBEntry(newSession.userID);
                         if (user) {
                             this.emit("session", newSession, user);
                         }
@@ -1722,7 +1721,7 @@ class Client extends events_1.EventEmitter {
                             let failed = 1;
                             // retry a couple times
                             while (!user) {
-                                [user, err] = yield this.retrieveUserDBEntry(newSession.userID);
+                                [user, err] = await this.retrieveUserDBEntry(newSession.userID);
                                 failed++;
                                 if (failed > 3) {
                                     this.log.warn("Couldn't retrieve user entry.");
@@ -1739,74 +1738,73 @@ class Client extends events_1.EventEmitter {
                     this.log.warn("Unsupported MailType:", mail.mailType);
                     break;
             }
+        }
+        finally {
             this.reading = false;
-        });
+        }
     }
     newEphemeralKeys() {
-        this.xKeyRing.ephemeralKeys = tweetnacl_1.default.box.keyPair();
+        this.xKeyRing.ephemeralKeys = nacl.box.keyPair();
     }
     createPreKey() {
-        const preKeyPair = tweetnacl_1.default.box.keyPair();
+        const preKeyPair = nacl.box.keyPair();
         const preKeys = {
             keyPair: preKeyPair,
-            signature: tweetnacl_1.default.sign(crypto_1.xEncode(crypto_1.xConstants.CURVE, preKeyPair.publicKey), this.signKeys.secretKey),
+            signature: nacl.sign(xEncode(xConstants.CURVE, preKeyPair.publicKey), this.signKeys.secretKey),
         };
         return preKeys;
     }
-    handleNotify(msg) {
-        return __awaiter(this, void 0, void 0, function* () {
-            switch (msg.event) {
-                case "mail":
-                    this.log.info("Server has informed us of new mail.");
-                    yield this.getMail();
-                    this.fetchingMail = false;
-                    break;
-                case "permission":
-                    this.emit("permission", msg.data);
-                    break;
-                case "retryRequest":
-                    const messageID = msg.data;
-                    break;
-                default:
-                    this.log.info("Unsupported notification event " + msg.event);
-                    break;
-            }
-        });
+    async handleNotify(msg) {
+        switch (msg.event) {
+            case "mail":
+                this.log.info("Server has informed us of new mail.");
+                await this.getMail();
+                this.fetchingMail = false;
+                break;
+            case "permission":
+                this.emit("permission", msg.data);
+                break;
+            case "retryRequest":
+                const messageID = msg.data;
+                break;
+            default:
+                this.log.info("Unsupported notification event " + msg.event);
+                break;
+        }
     }
-    populateKeyRing() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // we've checked in the constructor that these exist
-            const identityKeys = this.idKeys;
-            let preKeys = yield this.database.getPreKeys();
-            if (!preKeys) {
-                this.log.warn("No prekeys found in database, creating a new one.");
-                preKeys = this.createPreKey();
-                yield this.database.savePreKeys([preKeys], false);
-            }
-            const sessions = yield this.database.getAllSessions();
-            for (const session of sessions) {
-                this.sessionRecords[session.publicKey] = sqlSessionToCrypto_1.sqlSessionToCrypto(session);
-            }
-            const ephemeralKeys = tweetnacl_1.default.box.keyPair();
-            this.xKeyRing = {
-                identityKeys,
-                preKeys,
-                ephemeralKeys,
-            };
-            this.log.info("Keyring populated:\n" +
-                JSON.stringify({
-                    signKey: crypto_1.XUtils.encodeHex(this.signKeys.publicKey),
-                    preKey: crypto_1.XUtils.encodeHex(preKeys.keyPair.publicKey),
-                    ephemeralKey: crypto_1.XUtils.encodeHex(ephemeralKeys.publicKey),
-                }, null, 4));
-        });
+    async populateKeyRing() {
+        // we've checked in the constructor that these exist
+        const identityKeys = this.idKeys;
+        let preKeys = await this.database.getPreKeys();
+        if (!preKeys) {
+            this.log.warn("No prekeys found in database, creating a new one.");
+            preKeys = this.createPreKey();
+            await this.database.savePreKeys([preKeys], false);
+        }
+        const sessions = await this.database.getAllSessions();
+        for (const session of sessions) {
+            this.sessionRecords[session.publicKey] =
+                sqlSessionToCrypto(session);
+        }
+        const ephemeralKeys = nacl.box.keyPair();
+        this.xKeyRing = {
+            identityKeys,
+            preKeys,
+            ephemeralKeys,
+        };
+        this.log.info("Keyring populated:\n" +
+            JSON.stringify({
+                signKey: XUtils.encodeHex(this.signKeys.publicKey),
+                preKey: XUtils.encodeHex(preKeys.keyPair.publicKey),
+                ephemeralKey: XUtils.encodeHex(ephemeralKeys.publicKey),
+            }, null, 4));
     }
     initSocket() {
         try {
             if (!this.token) {
                 throw new Error("No token found, did you call login()?");
             }
-            this.conn = new ws_1.default(this.prefixes.WS + this.host + "/socket", { headers: { Cookie: "auth=" + this.token } });
+            this.conn = new WebSocket(this.prefixes.WS + this.host + "/socket", { headers: { Cookie: "auth=" + this.token } });
             this.conn.on("open", () => {
                 this.log.info("Connection opened.");
                 this.pingInterval = setInterval(this.ping.bind(this), 15000);
@@ -1820,10 +1818,10 @@ class Client extends events_1.EventEmitter {
             this.conn.on("error", (error) => {
                 throw error;
             });
-            this.conn.on("message", (message) => __awaiter(this, void 0, void 0, function* () {
-                const [header, msg] = crypto_1.XUtils.unpackMessage(message);
-                this.log.debug(chalk_1.default.red.bold("INH ") + crypto_1.XUtils.encodeHex(header));
-                this.log.debug(chalk_1.default.red.bold("IN ") + JSON.stringify(msg, null, 4));
+            this.conn.on("message", async (message) => {
+                const [header, msg] = XUtils.unpackMessage(message);
+                this.log.debug(chalk.red.bold("INH ") + XUtils.encodeHex(header));
+                this.log.debug(chalk.red.bold("IN ") + JSON.stringify(msg, null, 4));
                 switch (msg.type) {
                     case "ping":
                         this.pong(msg.transmissionID);
@@ -1854,7 +1852,7 @@ class Client extends events_1.EventEmitter {
                         this.log.info("Unsupported message " + msg.type);
                         break;
                 }
-            }));
+            });
         }
         catch (err) {
             throw new Error("Error initiating websocket connection " + err.toString());
@@ -1863,161 +1861,137 @@ class Client extends events_1.EventEmitter {
     setAlive(status) {
         this.isAlive = status;
     }
-    postAuth() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let count = 0;
-            while (true) {
-                try {
-                    yield this.getMail();
-                    count++;
-                    this.fetchingMail = false;
-                    if (count > 10) {
-                        this.negotiateOTK();
-                        count = 0;
-                    }
-                }
-                catch (err) {
-                    this.log.warn("Problem fetching mail" + err.toString());
-                }
-                yield sleep_1.sleep(1000 * 60);
-            }
-        });
-    }
-    getMail() {
-        return __awaiter(this, void 0, void 0, function* () {
-            while (this.fetchingMail) {
-                yield sleep_1.sleep(500);
-            }
-            this.fetchingMail = true;
-            let firstFetch = false;
-            if (this.firstMailFetch) {
-                firstFetch = true;
-                this.firstMailFetch = false;
-            }
-            if (firstFetch) {
-                this.emit("decryptingMail");
-            }
-            this.log.info("fetching mail for device " + this.getDevice().deviceID);
+    async postAuth() {
+        let count = 0;
+        while (true) {
             try {
-                const res = yield axios_1.default.post(this.getHost() +
-                    "/device/" +
-                    this.getDevice().deviceID +
-                    "/mail");
-                const inbox = msgpack_lite_1.default
-                    .decode(Buffer.from(res.data))
-                    .sort((a, b) => b[2].getTime() - a[2].getTime());
-                for (const mailDetails of inbox) {
-                    const [mailHeader, mailBody, timestamp] = mailDetails;
-                    try {
-                        yield this.readMail(mailHeader, mailBody, timestamp.toString());
-                    }
-                    catch (err) {
-                        console.warn(err.toString());
-                    }
+                await this.getMail();
+                count++;
+                this.fetchingMail = false;
+                if (count > 10) {
+                    this.negotiateOTK();
+                    count = 0;
                 }
             }
             catch (err) {
-                console.warn(err.toString());
+                this.log.warn("Problem fetching mail" + err.toString());
             }
-            this.fetchingMail = false;
-        });
-    }
-    /* header is 32 bytes and is either empty
-    or contains an HMAC of the message with
-    a derived SK */
-    send(msg, header) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let i = 0;
-            while (this.conn.readyState !== 1) {
-                yield sleep_1.sleep(i);
-                i *= 2;
-            }
-            this.log.debug(chalk_1.default.red.bold("OUTH ") +
-                crypto_1.XUtils.encodeHex(header || crypto_1.XUtils.emptyHeader()));
-            this.log.debug(chalk_1.default.red.bold("OUT ") + JSON.stringify(msg, null, 4));
-            this.conn.send(crypto_1.XUtils.packMessage(msg, header));
-        });
-    }
-    retrieveKeyBundle(deviceID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield axios_1.default.post(this.getHost() + "/device/" + deviceID + "/keyBundle");
-            return msgpack_lite_1.default.decode(Buffer.from(res.data));
-        });
+            await sleep(1000 * 60);
+        }
     }
-    getOTKCount() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield axios_1.default.get(this.getHost() +
+    async getMail() {
+        while (this.fetchingMail) {
+            await sleep(500);
+        }
+        this.fetchingMail = true;
+        let firstFetch = false;
+        if (this.firstMailFetch) {
+            firstFetch = true;
+            this.firstMailFetch = false;
+        }
+        if (firstFetch) {
+            this.emit("decryptingMail");
+        }
+        this.log.info("fetching mail for device " + this.getDevice().deviceID);
+        try {
+            const res = await ax.post(this.getHost() +
                 "/device/" +
                 this.getDevice().deviceID +
-                "/otk/count");
-            return msgpack_lite_1.default.decode(Buffer.from(res.data)).count;
-        });
-    }
-    submitOTK(amount) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const otks = [];
-            const t0 = perf_hooks_1.performance.now();
-            for (let i = 0; i < amount; i++) {
-                otks[i] = this.createPreKey();
+                "/mail");
+            const inbox = msgpack
+                .decode(Buffer.from(res.data))
+                .sort((a, b) => b[2].getTime() - a[2].getTime());
+            for (const mailDetails of inbox) {
+                const [mailHeader, mailBody, timestamp] = mailDetails;
+                try {
+                    await this.readMail(mailHeader, mailBody, timestamp.toString());
+                }
+                catch (err) {
+                    console.warn(err.toString());
+                }
             }
-            const t1 = perf_hooks_1.performance.now();
-            this.log.info("Generated " + amount + " one time keys in " + (t1 - t0) + " ms.");
-            const savedKeys = yield this.database.savePreKeys(otks, true);
-            yield axios_1.default.post(this.getHost() + "/device/" + this.getDevice().deviceID + "/otk", msgpack_lite_1.default.encode(savedKeys.map((key) => this.censorPreKey(key))), {
-                headers: { "Content-Type": "application/msgpack" },
-            });
-        });
+        }
+        catch (err) {
+            console.warn(err.toString());
+        }
+        this.fetchingMail = false;
     }
-    negotiateOTK() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const otkCount = yield this.getOTKCount();
-            this.log.info("Server reported OTK: " + otkCount.toString());
-            const needs = crypto_1.xConstants.MIN_OTK_SUPPLY - otkCount;
-            if (needs === 0) {
-                this.log.info("Server otk supply full.");
-                return;
-            }
-            yield this.submitOTK(needs);
+    /* header is 32 bytes and is either empty
+    or contains an HMAC of the message with
+    a derived SK */
+    async send(msg, header) {
+        let i = 0;
+        while (this.conn.readyState !== 1) {
+            await sleep(i);
+            i *= 2;
+        }
+        this.log.debug(chalk.red.bold("OUTH ") +
+            XUtils.encodeHex(header || XUtils.emptyHeader()));
+        this.log.debug(chalk.red.bold("OUT ") + JSON.stringify(msg, null, 4));
+        this.conn.send(XUtils.packMessage(msg, header));
+    }
+    async retrieveKeyBundle(deviceID) {
+        const res = await ax.post(this.getHost() + "/device/" + deviceID + "/keyBundle");
+        return msgpack.decode(Buffer.from(res.data));
+    }
+    async getOTKCount() {
+        const res = await ax.get(this.getHost() +
+            "/device/" +
+            this.getDevice().deviceID +
+            "/otk/count");
+        return msgpack.decode(Buffer.from(res.data)).count;
+    }
+    async submitOTK(amount) {
+        const otks = [];
+        const t0 = performance.now();
+        for (let i = 0; i < amount; i++) {
+            otks[i] = this.createPreKey();
+        }
+        const t1 = performance.now();
+        this.log.info("Generated " + amount + " one time keys in " + (t1 - t0) + " ms.");
+        const savedKeys = await this.database.savePreKeys(otks, true);
+        await ax.post(this.getHost() + "/device/" + this.getDevice().deviceID + "/otk", msgpack.encode(savedKeys.map((key) => this.censorPreKey(key))), {
+            headers: { "Content-Type": "application/msgpack" },
         });
     }
+    async negotiateOTK() {
+        const otkCount = await this.getOTKCount();
+        this.log.info("Server reported OTK: " + otkCount.toString());
+        const needs = xConstants.MIN_OTK_SUPPLY - otkCount;
+        if (needs === 0) {
+            this.log.info("Server otk supply full.");
+            return;
+        }
+        await this.submitOTK(needs);
+    }
     respond(msg) {
         const response = {
             transmissionID: msg.transmissionID,
             type: "response",
-            signed: tweetnacl_1.default.sign(msg.challenge, this.signKeys.secretKey),
+            signed: nacl.sign(msg.challenge, this.signKeys.secretKey),
         };
         this.send(response);
     }
     pong(transmissionID) {
         this.send({ transmissionID, type: "pong" });
     }
-    ping() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isAlive) {
-                this.log.warn("Ping failed.");
-            }
-            this.setAlive(false);
-            this.send({ transmissionID: uuid.v4(), type: "ping" });
-        });
+    async ping() {
+        if (!this.isAlive) {
+            this.log.warn("Ping failed.");
+        }
+        this.setAlive(false);
+        this.send({ transmissionID: uuid.v4(), type: "ping" });
     }
     censorPreKey(preKey) {
         if (!preKey.index) {
             throw new Error("Key index is required.");
         }
         return {
-            publicKey: crypto_1.XUtils.decodeHex(preKey.publicKey),
-            signature: crypto_1.XUtils.decodeHex(preKey.signature),
+            publicKey: XUtils.decodeHex(preKey.publicKey),
+            signature: XUtils.decodeHex(preKey.signature),
             index: preKey.index,
             deviceID: this.getDevice().deviceID,
         };
     }
 }
-exports.Client = Client;
-Client.loadKeyFile = crypto_1.XUtils.loadKeyFile;
-Client.saveKeyFile = crypto_1.XUtils.saveKeyFile;
-Client.create = (privateKey, options, storage) => __awaiter(void 0, void 0, void 0, function* () {
-    const client = new Client(privateKey, options, storage);
-    yield client.init();
-    return client;
-});
 //# sourceMappingURL=Client.js.map