- Upgraded to rust crypto but old libolm data will not migrate

- Change how matrix-js-sdk is loaded with it now being an ESM module

package.json

@@ -3,18 +3,18 @@
   "version": "0.8.0",
   "description": "Matrix chat server client for Node-RED",
   "dependencies": {
+    "@matrix-org/matrix-sdk-crypto-nodejs": "^0.2.0-beta.1",
     "abort-controller": "^3.0.0",
     "fluent-ffmpeg": "^2.1.2",
     "fs-extra": "^11.1.0",
     "got": "^12.0.2",
     "image-size": "^1.0.2",
     "isomorphic-webcrypto": "^2.3.8",
-    "matrix-js-sdk": "^28.0.0",
+    "matrix-js-sdk": "^34.5.0",
     "mime": "^3.0.0",
     "node-fetch": "^3.3.0",
     "node-localstorage": "^2.2.1",
     "olm": "https://gitlab.matrix.org/matrix-org/olm/-/package_files/2572/download",
-    "request": "^2.88.2",
     "sharp": "^0.33.4",
     "tmp": "^0.2.1",
     "utf8": "^3.0.0"

src/matrix-event-relations.js

@@ -1,5 +1,3 @@
-const {RelationType, EventType, Direction} = require("matrix-js-sdk");
-
 module.exports = function(RED) {
     function MatrixFetchRelations(n) {
         RED.nodes.createNode(this, n);
@@ -43,6 +41,8 @@ module.exports = function(RED) {
         });
 
         node.on("input", async function(msg) {
+            const {Direction} = await import("matrix-js-sdk");
+
             if (!node.server || !node.server.matrixClient) {
                 node.error("No matrix server selected", msg);
                 return;

src/matrix-mark-read.js

@@ -1,5 +1,3 @@
-const {TimelineWindow, RelationType, Filter} = require("matrix-js-sdk");
-const crypto = require('crypto');
 module.exports = function(RED) {
     function MatrixReceiveMessage(n) {
         RED.nodes.createNode(this, n);

src/matrix-paginate-room.js

@@ -1,5 +1,3 @@
-const {TimelineWindow, RelationType, Filter} = require("matrix-js-sdk");
-const crypto = require('crypto');
 module.exports = function(RED) {
     function MatrixReceiveMessage(n) {
         RED.nodes.createNode(this, n);
@@ -34,6 +32,9 @@ module.exports = function(RED) {
         });
 
         node.on("input", async function (msg) {
+            const {TimelineWindow, RelationType, Filter} = await import("matrix-js-sdk");
+            const crypto = await import('crypto');
+
             if (! node.server || ! node.server.matrixClient) {
                 node.error("No matrix server selected", msg);
                 return;

src/matrix-receive.js

@@ -1,4 +1,3 @@
-const {RelationType} = require("matrix-js-sdk");
 module.exports = function(RED) {
     function MatrixReceiveMessage(n) {
         RED.nodes.createNode(this, n);

src/matrix-send-message.js

@@ -1,5 +1,3 @@
-const {RelationType} = require("matrix-js-sdk");
-
 module.exports = function(RED) {
     function MatrixSendImage(n) {
         RED.nodes.createNode(this, n);
@@ -68,7 +66,8 @@ module.exports = function(RED) {
             node.status({ fill: "green", shape: "ring", text: "connected" });
         });
 
-        node.on("input", function (msg) {
+        node.on("input", async function (msg) {
+            const {RelationType} = await import("matrix-js-sdk");
             function getToValue(msg, type, property) {
                 let value = property;
                 if (type === "msg") {

src/matrix-server-config.js

@@ -1,14 +1,10 @@
-const {RelationType, TimelineWindow} = require("matrix-js-sdk");
-
 global.Olm = require('olm');
 const fs = require("fs-extra");
-const sdk = require("matrix-js-sdk");
 const { resolve } = require('path');
 const { LocalStorage } = require('node-localstorage');
-const { LocalStorageCryptoStore } = require('matrix-js-sdk/lib/crypto/store/localStorage-crypto-store');
+globalThis.crypto = require('crypto');
-const {RoomEvent, RoomMemberEvent, HttpApiEvent, ClientEvent, MemoryStore} = require("matrix-js-sdk");
-const request = require("request");
 require("abort-controller/polyfill"); // polyfill abort-controller if we don't have it
+
 if (!globalThis.fetch) {
     // polyfill fetch if we don't have it
     if (!globalThis.fetch) {
@@ -19,16 +15,22 @@ if (!globalThis.fetch) {
 }
 
 module.exports = function(RED) {
+    // Prepare dynamic imports
+    const sdkPromise = import("matrix-js-sdk");
+    const LocalStorageCryptoStorePromise = import('matrix-js-sdk/lib/crypto/store/localStorage-crypto-store.js');
+    const loggerPromise = import('matrix-js-sdk/lib/logger.js');
+
     // disable logging if set to "off"
-    let loggingSettings = RED.settings.get('logging');
+    // let loggingSettings = RED.settings.get('logging');
-    if(
+    // if(
-        typeof loggingSettings.console !== 'undefined' &&
+    //     typeof loggingSettings.console !== 'undefined' &&
-        typeof loggingSettings.console.level !== 'undefined' &&
+    //     typeof loggingSettings.console.level !== 'undefined' &&
-        ['info','debug','trace'].indexOf(loggingSettings.console.level.toLowerCase()) >= 0
+    //     ['info','debug','trace'].indexOf(loggingSettings.console.level.toLowerCase()) >= 0
-    ) {
+    // ) {
-        const { logger } = require('matrix-js-sdk/lib/logger');
+    //     loggerPromise.then(({ logger }) => {
-        logger.disableAll();
+    //         logger.disableAll();
-    }
+    //     });
+    // }
 
     function MatrixFolderNameFromUserId(name) {
         return name.replace(/[^a-z0-9]/gi, '_').toLowerCase();
@@ -66,7 +68,7 @@ module.exports = function(RED) {
         node.deregister = function(consumerNode) {
             delete node.users[consumerNode.id];
         };
-        
+
         if(!this.userId) {
             node.log("Matrix connection failed: missing user ID in configuration.");
             return;
@@ -83,7 +85,7 @@ module.exports = function(RED) {
         } else if(!this.url) {
             node.error("Matrix connection failed: missing server URL in configuration.", {});
         } else {
-            node.setConnected = async function(connected, cb) {
+            node.setConnected = function(connected, cb) {
                 if (node.connected !== connected) {
                     node.connected = connected;
                     if(typeof cb === 'function') {
@@ -145,313 +147,294 @@ module.exports = function(RED) {
 
             fs.ensureDirSync(storageDir); // create storage directory if it doesn't exist
             upgradeDirectoryIfNecessary(node, storageDir);
-            node.matrixClient = sdk.createClient({
-                baseUrl: this.url,
-                accessToken: this.credentials.accessToken,
-                cryptoStore: new LocalStorageCryptoStore(localStorage),
-                store: new MemoryStore({
-                    localStorage: localStorage,
-                }),
-                userId: this.userId,
-                deviceId: (this.deviceId || getStoredDeviceId(localStorage)) || undefined,
-                request
-                // verificationMethods: ["m.sas.v1"]
-            });
 
-            node.debug(`hasLazyLoadMembersEnabled=${node.matrixClient.hasLazyLoadMembersEnabled()}`);
+            // Wait for the dynamic imports to resolve
+            Promise.all([sdkPromise, LocalStorageCryptoStorePromise]).then(([sdkModule, LocalStorageCryptoStoreModule]) => {
+                const sdk = sdkModule.default || sdkModule;
+                const { LocalStorageCryptoStore } = LocalStorageCryptoStoreModule;
 
-            // set globally if configured to do so
+                node.matrixClient = sdk.createClient({
-            if(this.globalAccess) {
+                    baseUrl: this.url,
-                this.context().global.set('matrixClient["'+this.userId+'"]', node.matrixClient);
+                    accessToken: this.credentials.accessToken,
-            }
+                    cryptoStore: new LocalStorageCryptoStore(localStorage),
-
+                    store: new sdk.MemoryStore({
-            function stopClient() {
+                        localStorage: localStorage,
-                if(node.matrixClient && node.matrixClient.clientRunning) {
+                    }),
-                    node.matrixClient.stopClient();
+                    userId: this.userId,
-                    node.setConnected(false);
+                    deviceId: (this.deviceId || getStoredDeviceId(localStorage)) || undefined
-                }
+                    // verificationMethods: ["m.sas.v1"]
-
-                if(retryStartTimeout) {
-                    clearTimeout(retryStartTimeout);
-                }
-            }
-
-            node.on('close', function(done) {
-                stopClient();
-                if(node.globalAccess) {
-                    try {
-                        node.context().global.set('matrixClient["'+node.userId+'"]', undefined);
-                    } catch(e){
-                        node.error(e.message, {});
-                    }
-                }
-                done();
-            });
-
-            node.isConnected = function() {
-                return node.connected;
-            };
-
-            node.matrixClient.on(RoomEvent.Timeline, async function(event, room, toStartOfTimeline, removed, data) {
-                if (toStartOfTimeline) {
-                    node.log("Ignoring" + (event.isEncrypted() ? ' encrypted' : '') +" timeline event [" + (event.getContent()['msgtype'] || event.getType()) + "]: (" + room.name + ") " + event.getId() + " for reason: paginated result");
-                    return; // ignore paginated results
-                }
-                if (!data || !data.liveEvent) {
-                    node.log("Ignoring" + (event.isEncrypted() ? ' encrypted' : '') +" timeline event [" + (event.getContent()['msgtype'] || event.getType()) + "]: (" + room.name + ") " + event.getId() + " for reason: old message");
-                    return; // ignore old message (we only want live events)
-                }
-                if(node.initializedAt > event.getDate()) {
-                    node.log("Ignoring" + (event.isEncrypted() ? ' encrypted' : '') +" timeline event [" + (event.getContent()['msgtype'] || event.getType()) + "]: (" + room.name + ") " + event.getId() + " for reason: old message before init");
-                    return; // skip events that occurred before our client initialized
-                }
-
-                try {
-                    await node.matrixClient.decryptEventIfNeeded(event);
-                } catch (error) {
-                    node.error(error, {});
-                    return;
-                }
-
-                const isDmRoom = (room) => {
-                    // Find out if this is a direct message room.
-                    let isDM = !!room.getDMInviter();
-                    const allMembers = room.currentState.getMembers();
-                    if (!isDM && allMembers.length <= 2) {
-                        // if not a DM, but there are 2 users only
-                        // double check DM (needed because getDMInviter works only if you were invited, not if you invite)
-                        // hence why we check for each member
-                        if (allMembers.some((m) => m.getDMInviter())) {
-                            return true;
-                        }
-                    }
-                    return allMembers.length <= 2 && isDM;
-                };
-
-                let msg = {
-                    encrypted    : event.isEncrypted(),
-                    redacted     : event.isRedacted(),
-                    content      : event.getContent(),
-                    type         : (event.getContent()['msgtype'] || event.getType()) || null,
-                    payload      : (event.getContent()['body'] || event.getContent()) || null,
-                    isDM         : isDmRoom(room),
-                    isThread     : event.getContent()?.['m.relates_to']?.rel_type === RelationType.Thread,
-                    mentions     : event.getContent()["m.mentions"] || null,
-                    userId       : event.getSender(),
-                    user         : node.matrixClient.getUser(event.getSender()),
-                    topic        : event.getRoomId(),
-                    eventId      : event.getId(),
-                    event        : event,
-                };
-
-                // remove keys from user property that start with an underscore
-                Object.keys(msg.user).forEach(function (key) {
-                    if (/^_/.test(key)) {
-                        delete msg.user[key];
-                    }
                 });
 
-                node.log(`Received ${msg.encrypted ? 'encrypted ' : ''}timeline event [${msg.type}]: (${room.name}) ${event.getSender()} :: ${msg.content.body} ${toStartOfTimeline ? ' [PAGINATED]' : ''}`);
+                node.debug(`hasLazyLoadMembersEnabled=${node.matrixClient.hasLazyLoadMembersEnabled()}`);
-                node.emit("Room.timeline", event, room, toStartOfTimeline, removed, data, msg);
-            });
 
-            /**
+                // set globally if configured to do so
-             * Fires when we want to suggest to the user that they restore their megolm keys
+                if(this.globalAccess) {
-             * from backup or by cross-signing the device.
+                    this.context().global.set('matrixClient["'+this.userId+'"]', node.matrixClient);
-             *
-             * @event module:client~MatrixClient#"crypto.suggestKeyRestore"
-             */
-            // node.matrixClient.on("crypto.suggestKeyRestore", function(){
-            //
-            // });
-
-            // node.matrixClient.on("RoomMember.typing", async function(event, member) {
-            //     let isTyping = member.typing;
-            //     let roomId = member.roomId;
-            // });
-
-            // node.matrixClient.on("RoomMember.powerLevel", async function(event, member) {
-            //     let newPowerLevel = member.powerLevel;
-            //     let newNormPowerLevel = member.powerLevelNorm;
-            //     let roomId = member.roomId;
-            // });
-
-            // node.matrixClient.on("RoomMember.name", async function(event, member) {
-            //     let newName = member.name;
-            //     let roomId = member.roomId;
-            // });
-
-            // handle auto-joining rooms
-
-            node.matrixClient.on(RoomMemberEvent.Membership, async function(event, member) {
-                if(node.initializedAt > event.getDate()) {
-                    return; // skip events that occurred before our client initialized
                 }
 
-                if (member.membership === "invite" && member.userId === node.userId) {
+                function stopClient() {
-                    node.log("Got invite to join room " + member.roomId);
+                    if(node.matrixClient && node.matrixClient.clientRunning) {
-                    if(node.autoAcceptRoomInvites) {
+                        node.matrixClient.stopClient();
-                        node.matrixClient.joinRoom(member.roomId).then(function() {
+                        node.setConnected(false);
-                            node.log("Automatically accepted invitation to join room " + member.roomId);
+                    }
-                        }).catch(function(e) {
+
-                            node.warn("Cannot join room (could be from being kicked/banned) " + member.roomId + ": " + e);
+                    if(retryStartTimeout) {
+                        clearTimeout(retryStartTimeout);
+                    }
+                }
+
+                node.on('close', function(done) {
+                    stopClient();
+                    if(node.globalAccess) {
+                        try {
+                            node.context().global.set('matrixClient["'+node.userId+'"]', undefined);
+                        } catch(e){
+                            node.error(e.message, {});
+                        }
+                    }
+                    done();
+                });
+
+                node.isConnected = function() {
+                    return node.connected;
+                };
+
+                const { RelationType, RoomEvent, RoomMemberEvent, HttpApiEvent, ClientEvent } = sdk;
+
+                node.matrixClient.on(RoomEvent.Timeline, async function(event, room, toStartOfTimeline, removed, data) {
+                    if (toStartOfTimeline) {
+                        node.log("Ignoring" + (event.isEncrypted() ? ' encrypted' : '') +" timeline event [" + (event.getContent()['msgtype'] || event.getType()) + "]: (" + room.name + ") " + event.getId() + " for reason: paginated result");
+                        return; // ignore paginated results
+                    }
+                    if (!data || !data.liveEvent) {
+                        node.log("Ignoring" + (event.isEncrypted() ? ' encrypted' : '') +" timeline event [" + (event.getContent()['msgtype'] || event.getType()) + "]: (" + room.name + ") " + event.getId() + " for reason: old message");
+                        return; // ignore old message (we only want live events)
+                    }
+                    if(node.initializedAt > event.getDate()) {
+                        node.log("Ignoring" + (event.isEncrypted() ? ' encrypted' : '') +" timeline event [" + (event.getContent()['msgtype'] || event.getType()) + "]: (" + room.name + ") " + event.getId() + " for reason: old message before init");
+                        return; // skip events that occurred before our client initialized
+                    }
+
+                    try {
+                        await node.matrixClient.decryptEventIfNeeded(event);
+                    } catch (error) {
+                        node.error(error, {});
+                        return;
+                    }
+
+                    const isDmRoom = (room) => {
+                        // Find out if this is a direct message room.
+                        let isDM = !!room.getDMInviter();
+                        const allMembers = room.currentState.getMembers();
+                        if (!isDM && allMembers.length <= 2) {
+                            // if not a DM, but there are 2 users only
+                            // double check DM (needed because getDMInviter works only if you were invited, not if you invite)
+                            // hence why we check for each member
+                            if (allMembers.some((m) => m.getDMInviter())) {
+                                return true;
+                            }
+                        }
+                        return allMembers.length <= 2 && isDM;
+                    };
+
+                    let msg = {
+                        encrypted    : event.isEncrypted(),
+                        redacted     : event.isRedacted(),
+                        content      : event.getContent(),
+                        type         : (event.getContent()['msgtype'] || event.getType()) || null,
+                        payload      : (event.getContent()['body'] || event.getContent()) || null,
+                        isDM         : isDmRoom(room),
+                        isThread     : event.getContent()?.['m.relates_to']?.rel_type === RelationType.Thread,
+                        mentions     : event.getContent()["m.mentions"] || null,
+                        userId       : event.getSender(),
+                        user         : node.matrixClient.getUser(event.getSender()),
+                        topic        : event.getRoomId(),
+                        eventId      : event.getId(),
+                        event        : event,
+                    };
+
+                    // remove keys from user property that start with an underscore
+                    if (msg.user) {
+                        Object.keys(msg.user).forEach(function (key) {
+                            if (/^_/.test(key)) {
+                                delete msg.user[key];
+                            }
                         });
                     }
 
-                    let room = node.matrixClient.getRoom(event.getRoomId());
+                    node.log(`Received ${msg.encrypted ? 'encrypted ' : ''}timeline event [${msg.type}]: (${room.name}) ${event.getSender()} :: ${msg.content.body} ${toStartOfTimeline ? ' [PAGINATED]' : ''}`);
-                    node.emit("Room.invite", {
+                    node.emit("Room.timeline", event, room, toStartOfTimeline, removed, data, msg);
-                        type      : 'm.room.member',
+                });
-                        userId    : event.getSender(),
-                        topic     : event.getRoomId(),
-                        topicName : (room ? room.name : null) || null,
-                        event     : event,
-                        eventId   : event.getId(),
-                    });
-                }
-            });
 
-            node.matrixClient.on(ClientEvent.Sync, async function(state, prevState, data) {
+                // handle auto-joining rooms
-                node.debug("SYNC [STATE=" + state + "] [PREVSTATE=" + prevState + "]");
-                if(prevState === null && state === "PREPARED" ) {
-                    // Occurs when the initial sync is completed first time.
-                    // This involves setting up filters and obtaining push rules.
-                    node.setConnected(true, function(){
-                        node.log("Matrix client connected");
-                    });
-                } else if(prevState === null && state === "ERROR") {
-                    // Occurs when the initial sync failed first time.
-                    node.setConnected(false, function(){
-                        node.error("Failed to connect to Matrix server", {});
-                    });
-                } else if(prevState === "ERROR" && state === "PREPARED") {
-                    // Occurs when the initial sync succeeds
-                    // after previously failing.
-                    node.setConnected(true, function(){
-                        node.log("Matrix client connected");
-                    });
-                } else if(prevState === "PREPARED" && state === "SYNCING") {
-                    // Occurs immediately after transitioning to PREPARED.
-                    // Starts listening for live updates rather than catching up.
-                    node.setConnected(true, function(){
-                        node.log("Matrix client connected");
-                    });
-                } else if(prevState === "SYNCING" && state === "RECONNECTING") {
-                    // Occurs when the live update fails.
-                    node.setConnected(false, function(){
-                        node.error("Connection to Matrix server lost", {});
-                    });
-                } else if(prevState === "RECONNECTING" && state === "RECONNECTING") {
-                    // Can occur if the update calls continue to fail,
-                    // but the keepalive calls (to /versions) succeed.
-                    node.setConnected(false, function(){
-                        node.error("Connection to Matrix server lost", {});
-                    });
-                } else if(prevState === "RECONNECTING" && state === "ERROR") {
-                    // Occurs when the keepalive call also fails
-                    node.setConnected(false, function(){
-                        node.error("Connection to Matrix server lost", {});
-                    });
-                } else if(prevState === "ERROR" && state === "SYNCING") {
-                    // Occurs when the client has performed a
-                    // live update after having previously failed.
-                    node.setConnected(true, function(){
-                        node.log("Matrix client connected");
-                    });
-                } else if(prevState === "ERROR" && state === "ERROR") {
-                    // Occurs when the client has failed to
-                    // keepalive for a second time or more.
-                    node.setConnected(false, function(){
-                        node.error("Connection to Matrix server lost", {});
-                    });
-                } else if(prevState === "SYNCING" && state === "SYNCING") {
-                    // Occurs when the client has performed a live update.
-                    // This is called <i>after</i> processing.
-                    node.setConnected(true, function(){
-                        node.log("Matrix client connected");
-                    });
-                } else if(state === "STOPPED") {
-                    // Occurs once the client has stopped syncing or
-                    // trying to sync after stopClient has been called.
-                    node.setConnected(false, function(){
-                        node.error("Connection to Matrix server lost", {});
-                    });
-                }
-            });
 
-
+                node.matrixClient.on(RoomMemberEvent.Membership, async function(event, member) {
-            node.matrixClient.on(HttpApiEvent.SessionLoggedOut, async function(errorObj){
+                    if(node.initializedAt > event.getDate()) {
-                // Example if user auth token incorrect:
+                        return; // skip events that occurred before our client initialized
-                // {
-                //     errcode: 'M_UNKNOWN_TOKEN',
-                //     data: {
-                //         errcode: 'M_UNKNOWN_TOKEN',
-                //         error: 'Invalid macaroon passed.',
-                //         soft_logout: false
-                //     },
-                //     httpStatus: 401
-                // }
-
-                node.error("Authentication failure: " + errorObj, {});
-                stopClient();
-            });
-
-            async function run() {
-                try {
-                    if(node.e2ee){
-                        node.log("Initializing crypto...");
-                        await node.matrixClient.initCrypto();
-                        node.matrixClient.getCrypto().globalBlacklistUnverifiedDevices = false; // prevent errors from unverified devices
                     }
-                    node.log("Connecting to Matrix server...");
-                    await node.matrixClient.startClient({
-                        initialSyncLimit: node.initialSyncLimit
-                    });
-                } catch(error) {
-                    node.error(error, {});
-                }
-            }
 
-            // do an authed request and only continue if we don't get an error
+                    if (member.membership === "invite" && member.userId === node.userId) {
-            // this prevent the matrix client from crashing Node-RED on invalid auth token
+                        node.log("Got invite to join room " + member.roomId);
-            (function checkAuthTokenThenStart() {
+                        if(node.autoAcceptRoomInvites) {
-                if(node.matrixClient.clientRunning) {
+                            node.matrixClient.joinRoom(member.roomId).then(function() {
-                    return;
+                                node.log("Automatically accepted invitation to join room " + member.roomId);
-                }
+                            }).catch(function(e) {
-
+                                node.warn("Cannot join room (could be from being kicked/banned) " + member.roomId + ": " + e);
-                /**
+                            });
-                 * We do a /whoami request before starting for a few reasons:
-                 * - validate our auth token
-                 * - make sure auth token belongs to provided node.userId
-                 * - fetch device_id if possible (only available on Synapse >= v1.40.0 under MSC2033)
-                 */
-                node.matrixClient.whoami()
-                    .then(
-                        function(data) {
-                            if((typeof data['device_id'] === undefined || !data['device_id']) && !node.deviceId && !getStoredDeviceId(localStorage)) {
-                                node.error("/whoami request did not return device_id. You will need to manually set one in your configuration because this cannot be automatically fetched.", {});
-                            }
-                            if('device_id' in data && data['device_id'] && !node.deviceId) {
-                                // if we have no device_id configured lets use the one
-                                // returned by /whoami for this access_token
-                                node.matrixClient.deviceId = data['device_id'];
-                            }
-
-                            // make sure our userId matches the access token's
-                            if(data['user_id'].toLowerCase() !== node.userId.toLowerCase()) {
-                                node.error(`User ID provided is ${node.userId} but token belongs to ${data['user_id']}`, {});
-                                return;
-                            }
-                            run().catch((error) => node.error(error));
-                        },
-                        function(err) {
-                            // if the error isn't authentication related retry in a little bit
-                            if(err.code !== "M_UNKNOWN_TOKEN") {
-                                retryStartTimeout = setTimeout(checkAuthTokenThenStart, 15000);
-                                node.error("Auth check failed: " + err, {});
-                            }
                         }
-                    )
+
-            })();
+                        let room = node.matrixClient.getRoom(event.getRoomId());
+                        node.emit("Room.invite", {
+                            type      : 'm.room.member',
+                            userId    : event.getSender(),
+                            topic     : event.getRoomId(),
+                            topicName : (room ? room.name : null) || null,
+                            event     : event,
+                            eventId   : event.getId(),
+                        });
+                    }
+                });
+
+                node.matrixClient.on(ClientEvent.Sync, async function(state, prevState, data) {
+                    node.debug("SYNC [STATE=" + state + "] [PREVSTATE=" + prevState + "]");
+                    if(prevState === null && state === "PREPARED" ) {
+                        // Occurs when the initial sync is completed first time.
+                        // This involves setting up filters and obtaining push rules.
+                        node.setConnected(true, function(){
+                            node.log("Matrix client connected");
+                        });
+                    } else if(prevState === null && state === "ERROR") {
+                        // Occurs when the initial sync failed first time.
+                        node.setConnected(false, function(){
+                            node.error("Failed to connect to Matrix server", {});
+                        });
+                    } else if(prevState === "ERROR" && state === "PREPARED") {
+                        // Occurs when the initial sync succeeds
+                        // after previously failing.
+                        node.setConnected(true, function(){
+                            node.log("Matrix client connected");
+                        });
+                    } else if(prevState === "PREPARED" && state === "SYNCING") {
+                        // Occurs immediately after transitioning to PREPARED.
+                        // Starts listening for live updates rather than catching up.
+                        node.setConnected(true, function(){
+                            node.log("Matrix client connected");
+                        });
+                    } else if(prevState === "SYNCING" && state === "RECONNECTING") {
+                        // Occurs when the live update fails.
+                        node.setConnected(false, function(){
+                            node.error("Connection to Matrix server lost", {});
+                        });
+                    } else if(prevState === "RECONNECTING" && state === "RECONNECTING") {
+                        // Can occur if the update calls continue to fail,
+                        // but the keepalive calls (to /versions) succeed.
+                        node.setConnected(false, function(){
+                            node.error("Connection to Matrix server lost", {});
+                        });
+                    } else if(prevState === "RECONNECTING" && state === "ERROR") {
+                        // Occurs when the keepalive call also fails
+                        node.setConnected(false, function(){
+                            node.error("Connection to Matrix server lost", {});
+                        });
+                    } else if(prevState === "ERROR" && state === "SYNCING") {
+                        // Occurs when the client has performed a
+                        // live update after having previously failed.
+                        node.setConnected(true, function(){
+                            node.log("Matrix client connected");
+                        });
+                    } else if(prevState === "ERROR" && state === "ERROR") {
+                        // Occurs when the client has failed to
+                        // keepalive for a second time or more.
+                        node.setConnected(false, function(){
+                            node.error("Connection to Matrix server lost", {});
+                        });
+                    } else if(prevState === "SYNCING" && state === "SYNCING") {
+                        // Occurs when the client has performed a live update.
+                        // This is called <i>after</i> processing.
+                        node.setConnected(true, function(){
+                            node.log("Matrix client connected");
+                        });
+                    } else if(state === "STOPPED") {
+                        // Occurs once the client has stopped syncing or
+                        // trying to sync after stopClient has been called.
+                        node.setConnected(false, function(){
+                            node.error("Connection to Matrix server lost", {});
+                        });
+                    }
+                });
+
+
+                node.matrixClient.on(HttpApiEvent.SessionLoggedOut, async function(errorObj){
+                    node.error("Authentication failure: " + errorObj, {});
+                    stopClient();
+                });
+
+                async function run() {
+                    try {
+                        if(node.e2ee){
+                            node.matrixClient.on("crypto.legacyCryptoStoreMigrationProgress", function(progress, total){
+                                node.log(`Migrating from legacy crypto to rust crypto. ${progress}/${total}`);
+                            });
+                            await node.matrixClient.initRustCrypto({
+                                useIndexedDB: false
+                            });
+                            console.log(`CRYPTO VERSION: ${node.matrixClient.getCrypto()?.getVersion()}`);
+                            node.matrixClient.getCrypto().globalBlacklistUnverifiedDevices = false; // prevent errors from unverified devices
+                        }
+                        node.log("Connecting to Matrix server...");
+                        await node.matrixClient.startClient({
+                            initialSyncLimit: node.initialSyncLimit
+                        });
+                    } catch(error) {
+                        node.error(error);
+                        node.error(error, {});
+                    }
+                }
+
+                // do an authed request and only continue if we don't get an error
+                // this prevent the matrix client from crashing Node-RED on invalid auth token
+                (function checkAuthTokenThenStart() {
+                    if(node.matrixClient.clientRunning) {
+                        return;
+                    }
+
+                    /**
+                     * We do a /whoami request before starting for a few reasons:
+                     * - validate our auth token
+                     * - make sure auth token belongs to provided node.userId
+                     * - fetch device_id if possible (only available on Synapse >= v1.40.0 under MSC2033)
+                     */
+                    node.matrixClient.whoami()
+                        .then(
+                            function(data) {
+                                if((typeof data['device_id'] === undefined || !data['device_id']) && !node.deviceId && !getStoredDeviceId(localStorage)) {
+                                    node.error("/whoami request did not return device_id. You will need to manually set one in your configuration because this cannot be automatically fetched.", {});
+                                }
+                                if('device_id' in data && data['device_id'] && !node.deviceId) {
+                                    // if we have no device_id configured lets use the one
+                                    // returned by /whoami for this access_token
+                                    node.matrixClient.deviceId = data['device_id'];
+                                }
+
+                                // make sure our userId matches the access token's
+                                if(data['user_id'].toLowerCase() !== node.userId.toLowerCase()) {
+                                    node.error(`User ID provided is ${node.userId} but token belongs to ${data['user_id']}`, {});
+                                    return;
+                                }
+                                run().catch((error) => node.error(error));
+                            },
+                            function(err) {
+                                // if the error isn't authentication related retry in a little bit
+                                if(err.code !== "M_UNKNOWN_TOKEN") {
+                                    retryStartTimeout = setTimeout(checkAuthTokenThenStart, 15000);
+                                    node.error("Auth check failed: " + err, {});
+                                }
+                            }
+                        )
+                })();
+            }).catch((error) => {
+                node.error("Failed to load Matrix SDK modules: " + error, {});
+            });
         }
     }
 
@@ -475,43 +458,50 @@ module.exports = function(RED) {
                 deviceId = req.body.deviceId || undefined,
                 displayName = req.body.displayName || undefined;
 
-            const matrixClient = sdk.createClient({
+            sdkPromise.then((sdkModule) => {
-                baseUrl: baseUrl,
+                const sdk = sdkModule.default || sdk;
-                deviceId: deviceId,
+
-                timelineSupport: true,
+                const matrixClient = sdk.createClient({
-                localTimeoutMs: '30000',
+                    baseUrl: baseUrl,
-                request
+                    deviceId: deviceId,
+                    timelineSupport: true,
+                    localTimeoutMs: '30000',
+                    request
+                });
+
+                matrixClient.timelineSupport = true;
+
+                matrixClient.login(
+                    'm.login.password', {
+                        identifier: {
+                            type: 'm.id.user',
+                            user: userId,
+                        },
+                        password: password,
+                        initial_device_display_name: displayName
+                    })
+                    .then(
+                        function(response) {
+                            res.json({
+                                'result': 'ok',
+                                'token': response.access_token,
+                                'device_id': response.device_id,
+                                'user_id': response.user_id,
+                            });
+                        },
+                        function(err) {
+                            res.json({
+                                'result': 'error',
+                                'message': err
+                            });
+                        }
+                    );
+            }).catch((error) => {
+                res.json({
+                    'result': 'error',
+                    'message': "Failed to load Matrix SDK: " + error
+                });
             });
-
-            new TimelineWindow()
-
-            matrixClient.timelineSupport = true;
-
-            matrixClient.login(
-                'm.login.password', {
-                    identifier: {
-                        type: 'm.id.user',
-                        user: userId,
-                    },
-                    password: password,
-                    initial_device_display_name: displayName
-                })
-                .then(
-                    function(response) {
-                        res.json({
-                            'result': 'ok',
-                            'token': response.access_token,
-                            'device_id': response.device_id,
-                            'user_id': response.user_id,
-                        });
-                    },
-                    function(err) {
-                        res.json({
-                            'result': 'error',
-                            'message': err
-                        });
-                    }
-                );
         });
 
     function upgradeDirectoryIfNecessary(node, storageDir) {