@peers-app/peers-device 0.8.1 → 0.8.3

package/dist/connection-manager/connection-manager.d.ts

@@ -1,41 +1,35 @@
 import { ChangeTrackingTable, Connection, DataContext, Device, IDeviceMessage, IFileChunkInfo, INetworkInfo, Observable, UserContext } from "@peers-app/peers-sdk";
 import { ChunkDownloadManager } from "../chunk-download-manager";
 import { SyncGroup } from "../sync-group";
+import { DeviceMessages } from "./device-messages";
 interface IDownloadDevice {
     userId: string;
     deviceId: string;
     getFileChunkInfo(chunkHash: string): Promise<IFileChunkInfo>;
     downloadFileChunk(chunkHash: string): Promise<Uint8Array | null>;
 }
-export declare const TTL0 = "TTL0";
+export { TTL0 } from "./device-messages";
 export declare class ConnectionManager {
     readonly userContext: UserContext;
     readonly changeTrackingTableFactory: (groupId?: string) => ChangeTrackingTable;
     private readonly localDevice;
     private readonly getGroupSecretKey;
     MAX_CONNECTIONS: number;
-    MAX_CONNECTIONS_TO_FORWARD_MESSAGES_TO: number;
-    MAX_DEVICE_MESSAGE_SIZE: number;
+    get MAX_CONNECTIONS_TO_FORWARD_MESSAGES_TO(): number;
+    set MAX_CONNECTIONS_TO_FORWARD_MESSAGES_TO(value: number);
     readonly chunkDownloadManager: ChunkDownloadManager;
+    readonly deviceMessages: DeviceMessages;
     private syncGroups;
     private connectionStates;
     private deviceSyncConnections;
     private groupMemberSubscriptionCleanups;
     private allConnections;
-    private cleanOldDeviceMessagesSeenInterval;
     private pingInterval;
-    private cleanupExpiredAliasesInterval;
-    private userConnectCodeOfferSubscription;
-    private userConnectCodeAnswerSubscription;
-    private deviceMessageHandlers;
     private connectionMetrics;
     readonly onConnectionAdded: Observable<Connection | undefined>;
     readonly onConnectionRemoved: Observable<Connection | undefined>;
     readonly onUserConnectExchangeFinished: Observable<string | undefined>;
     constructor(userContext: UserContext, changeTrackingTableFactory: (groupId?: string) => ChangeTrackingTable, localDevice: Device, getGroupSecretKey: (groupId: string) => Promise<string>);
-    userConnectOffer(userConnectCode: string): Promise<void>;
-    private userConnectAnswer;
-    cleanOldDeviceMessagesSeen(): void;
     private pingAllConnections;
     /**
      * Register a handler for device messages with a specific payload type
@@ -59,13 +53,7 @@ export declare class ConnectionManager {
     getFileChunkInfo(chunkHash: string): Promise<IFileChunkInfo>;
     getDownloadDevices(): IDownloadDevice[];
     removeLeastPreferredConnection(): Promise<void>;
-    private secureDeviceMessagePayload;
-    private validateDeviceMessagePayload;
-    private readonly deviceMessagesSeen;
-    private readonly deviceAliases;
-    private readonly deviceAliasesExpires;
     sendDeviceMessage(partialMessage: Pick<IDeviceMessage, 'toDeviceId' | 'dataContextId' | 'payload'> & Partial<IDeviceMessage>): Promise<any>;
-    private forwardDeviceMessageAndReturnFirstResponse;
     /**
      * this is used for testing setup, it's not intended for normal use
      */
@@ -76,7 +64,5 @@ export declare class ConnectionManager {
         pathType: string;
         throughDeviceIds: string[];
     };
-    cleanupExpiredAliases(): void;
     dispose(): Promise<void>;
 }
-export {};

package/dist/connection-manager/connection-manager.js

@@ -7,8 +7,9 @@ const chunk_download_manager_1 = require("../chunk-download-manager");
 const machine_stats_1 = require("../machine-stats");
 const sync_group_1 = require("../sync-group");
 const connection_manager_priorities_1 = require("./connection-manager-priorities");
-exports.TTL0 = "TTL0";
-const ACK_DUP = "ACK_DUP";
+const device_messages_1 = require("./device-messages");
+var device_messages_2 = require("./device-messages");
+Object.defineProperty(exports, "TTL0", { enumerable: true, get: function () { return device_messages_2.TTL0; } });
 class ConnectionManager {
     userContext;
     changeTrackingTableFactory;
@@ -16,20 +17,20 @@ class ConnectionManager {
     getGroupSecretKey;
     // TODO set this based on device type (desktops and servers should be able to handle much more than the default of 30)
     MAX_CONNECTIONS = peers_sdk_1.PeerDeviceConsts.MAX_CONNECTIONS;
-    MAX_CONNECTIONS_TO_FORWARD_MESSAGES_TO = 6;
-    MAX_DEVICE_MESSAGE_SIZE = 64 * 1024; // 64 KB
+    get MAX_CONNECTIONS_TO_FORWARD_MESSAGES_TO() {
+        return this.deviceMessages.MAX_CONNECTIONS_TO_FORWARD_MESSAGES_TO;
+    }
+    set MAX_CONNECTIONS_TO_FORWARD_MESSAGES_TO(value) {
+        this.deviceMessages.MAX_CONNECTIONS_TO_FORWARD_MESSAGES_TO = value;
+    }
     chunkDownloadManager;
+    deviceMessages;
     syncGroups = {};
     connectionStates = new Map();
     deviceSyncConnections = new Map();
     groupMemberSubscriptionCleanups = new Map();
     allConnections = {};
-    cleanOldDeviceMessagesSeenInterval;
     pingInterval;
-    cleanupExpiredAliasesInterval;
-    userConnectCodeOfferSubscription;
-    userConnectCodeAnswerSubscription;
-    deviceMessageHandlers = new Map();
     connectionMetrics = new Map();
     onConnectionAdded = (0, peers_sdk_1.observable)();
     onConnectionRemoved = (0, peers_sdk_1.observable)();
@@ -40,128 +41,21 @@ class ConnectionManager {
         this.localDevice = localDevice;
         this.getGroupSecretKey = getGroupSecretKey;
         this.chunkDownloadManager = new chunk_download_manager_1.ChunkDownloadManager(this);
+        this.deviceMessages = new device_messages_1.DeviceMessages({
+            userContext,
+            localDevice,
+            getGroupSecretKey,
+            getAllConnections: () => this.allConnections,
+            getConnectionStates: () => this.connectionStates,
+            getSyncGroups: () => this.syncGroups,
+            getPeerGroupDevice: (dataContext) => this.getPeerGroupDevice(dataContext),
+            onUserConnectExchangeFinished: (deviceId) => this.onUserConnectExchangeFinished(deviceId),
+        });
         this.setupGroupsSubscriptions();
-        this.cleanOldDeviceMessagesSeenInterval = setInterval(() => {
-            this.cleanOldDeviceMessagesSeen();
-        }, 60 * 60 * 1000); // every hour
         // Ping all connections every 15 seconds
         this.pingInterval = setInterval(() => {
             this.pingAllConnections();
         }, 15_000);
-        // setup user connect code subscriptions
-        this.userConnectCodeOfferSubscription = peers_sdk_1.userConnectCodeOffer.subscribe(() => {
-            if ((0, peers_sdk_1.userConnectCodeOffer)()) {
-                const { alias } = (0, peers_sdk_1.parseConnectionCode)((0, peers_sdk_1.userConnectCodeOffer)());
-                this.sendDeviceMessage({
-                    toDeviceId: 'device-alias',
-                    dataContextId: '',
-                    payload: alias,
-                    ttl: 3,
-                });
-            }
-        });
-        this.userConnectCodeAnswerSubscription = peers_sdk_1.userConnectCodeAnswer.subscribe(() => {
-            if ((0, peers_sdk_1.userConnectCodeAnswer)()) {
-                this.userConnectOffer((0, peers_sdk_1.userConnectCodeAnswer)());
-            }
-        });
-        this.cleanupExpiredAliasesInterval = setInterval(() => {
-            this.cleanupExpiredAliases();
-        }, 60_0000);
-    }
-    async userConnectOffer(userConnectCode) {
-        const { alias, secret } = (0, peers_sdk_1.parseConnectionCode)(userConnectCode);
-        const me = await (0, peers_sdk_1.getMe)();
-        const myUserConnectInfo = {
-            userId: me.userId,
-            name: me.name,
-            publicKey: me.publicKey,
-            publicBoxKey: me.publicBoxKey,
-            deviceId: this.userContext.deviceId(),
-        };
-        const response = await this.sendDeviceMessage({
-            toDeviceId: alias,
-            dataContextId: 'user-connect',
-            payload: (0, peers_sdk_1.encryptWithSecret)(myUserConnectInfo, secret),
-        });
-        if (response === exports.TTL0) {
-            (0, peers_sdk_1.userConnectStatus)('Error: Could not find device, check connection code and try again');
-        }
-        else {
-            const remoteUserConnectInfo = (0, peers_sdk_1.decryptWithSecret)(response.payload, secret);
-            const usersTable = (0, peers_sdk_1.Users)(this.userContext.userDataContext);
-            await usersTable.save({
-                userId: remoteUserConnectInfo.userId,
-                name: remoteUserConnectInfo.name || remoteUserConnectInfo.userId,
-                publicKey: remoteUserConnectInfo.publicKey,
-                publicBoxKey: remoteUserConnectInfo.publicBoxKey,
-            }, { restoreIfDeleted: true, weakInsert: true });
-            const devicesTable = (0, peers_sdk_1.Devices)(this.userContext.userDataContext);
-            await devicesTable.save({
-                deviceId: remoteUserConnectInfo.deviceId,
-                userId: remoteUserConnectInfo.userId,
-                firstSeen: new Date(),
-                lastSeen: new Date(),
-                trustLevel: peers_sdk_1.TrustLevel.NewDevice,
-            }, { restoreIfDeleted: true, weakInsert: true });
-            this.onUserConnectExchangeFinished(remoteUserConnectInfo.deviceId);
-            (0, peers_sdk_1.userConnectStatus)(remoteUserConnectInfo.userId);
-        }
-    }
-    async userConnectAnswer(message) {
-        try {
-            const userConnectCode = (0, peers_sdk_1.userConnectCodeOffer)();
-            if (!userConnectCode) {
-                throw new Error('Device is not waiting for a user connection, check connection code and try again');
-            }
-            const parsedCode = (0, peers_sdk_1.parseConnectionCode)(userConnectCode);
-            const remoteUserConnectInfo = (0, peers_sdk_1.decryptWithSecret)(message.payload, parsedCode.secret);
-            const usersTable = (0, peers_sdk_1.Users)(this.userContext.userDataContext);
-            await usersTable.save({
-                userId: remoteUserConnectInfo.userId,
-                name: remoteUserConnectInfo.name || remoteUserConnectInfo.userId,
-                publicKey: remoteUserConnectInfo.publicKey,
-                publicBoxKey: remoteUserConnectInfo.publicBoxKey,
-            }, { restoreIfDeleted: true, weakInsert: true });
-            const devicesTable = (0, peers_sdk_1.Devices)(this.userContext.userDataContext);
-            await devicesTable.save({
-                deviceId: remoteUserConnectInfo.deviceId,
-                userId: remoteUserConnectInfo.userId,
-                firstSeen: new Date(),
-                lastSeen: new Date(),
-                trustLevel: peers_sdk_1.TrustLevel.NewDevice,
-            }, { restoreIfDeleted: true, weakInsert: true });
-            (0, peers_sdk_1.userConnectStatus)(remoteUserConnectInfo.userId);
-            const me = await (0, peers_sdk_1.getMe)();
-            const myUserConnectInfo = {
-                userId: me.userId,
-                name: me.name,
-                publicKey: me.publicKey,
-                publicBoxKey: me.publicBoxKey,
-                deviceId: this.userContext.deviceId(),
-            };
-            return {
-                statusCode: 200,
-                payload: (0, peers_sdk_1.encryptWithSecret)(myUserConnectInfo, parsedCode.secret),
-            };
-        }
-        catch (err) {
-            return {
-                isError: true,
-                statusCode: 400,
-                statusMessage: `Error handling user-connect device message: ${err}`
-            };
-        }
-    }
-    cleanOldDeviceMessagesSeen() {
-        // clear out deviceMessageIds older than 24 hours
-        const twentyFourHours = 24 * 60 * 60 * 1000;
-        for (const deviceMessageId of Object.keys(this.deviceMessagesSeen)) {
-            const time = (0, peers_sdk_1.idTime)(deviceMessageId);
-            if (Date.now() - time > twentyFourHours) {
-                delete this.deviceMessagesSeen[deviceMessageId];
-            }
-        }
     }
     async pingAllConnections() {
         // make sure all connections exist in `allConnections`
@@ -226,13 +120,7 @@ class ConnectionManager {
      * @returns Unsubscribe function
      */
     on(deviceMessageType, handler) {
-        if (this.deviceMessageHandlers.has(deviceMessageType)) {
-            throw new Error(`Handler already registered for device message type: ${deviceMessageType}`);
-        }
-        this.deviceMessageHandlers.set(deviceMessageType, handler);
-        return () => {
-            this.deviceMessageHandlers.delete(deviceMessageType);
-        };
+        return this.deviceMessages.on(deviceMessageType, handler);
     }
     getDeviceConnection(deviceId) {
         return this.allConnections[deviceId];
@@ -481,311 +369,8 @@ class ConnectionManager {
         }
         return Promise.resolve();
     }
-    async secureDeviceMessagePayload(message) {
-        let toPublicBoxKey = ''; //message.toPublicBoxKey;
-        // try to lookup public box key from device
-        if (!toPublicBoxKey && message.toDeviceId) {
-            const device = await (0, peers_sdk_1.Devices)(this.userContext.userDataContext).get(message.toDeviceId);
-            if (device) {
-                const user = await (0, peers_sdk_1.getUserById)(device.userId, { userContext: this.userContext });
-                if (user) {
-                    toPublicBoxKey = user.publicBoxKey;
-                }
-            }
-        }
-        // try to lookup public box key by user (it's not uncommon to send a message to user's personal data context)
-        if (!toPublicBoxKey) {
-            if (message.dataContextId === this.userContext.userId) {
-                toPublicBoxKey = this.localDevice.publicBoxKey;
-            }
-            else {
-                const user = await (0, peers_sdk_1.getUserById)(message.dataContextId, { userContext: this.userContext });
-                if (user) {
-                    toPublicBoxKey = user.publicBoxKey;
-                }
-            }
-        }
-        // try to lookup public box key by group
-        if (!toPublicBoxKey) {
-            const group = await (0, peers_sdk_1.Groups)(this.userContext.userDataContext).get(message.dataContextId);
-            if (group) {
-                toPublicBoxKey = group.publicBoxKey;
-            }
-        }
-        // sign and box (or just sign if we couldn't find a box key)
-        if (toPublicBoxKey) {
-            message.payload = this.localDevice.signAndBoxDataForKey(message.payload, toPublicBoxKey);
-        }
-        else {
-            console.warn(`WARNING! Could not establish a publicBoxKey to encrypt message with, sending as signed plain text`, message.payload);
-            message.payload = this.localDevice.signObjectWithSecretKey(message.payload);
-        }
-    }
-    async validateDeviceMessagePayload(message) {
-        if (!message.payload)
-            return;
-        const fromDevice = await (0, peers_sdk_1.Devices)(this.userContext.userDataContext).get(message.fromDeviceId);
-        const fromUser = fromDevice?.userId && await (0, peers_sdk_1.getUserById)(fromDevice.userId, { userContext: this.userContext }) || undefined;
-        if ((0, peers_sdk_1.isBoxedData)(message.payload)) {
-            try {
-                const fromBoxKey = message.payload.fromPublicKey;
-                if (fromUser && fromUser.publicBoxKey !== fromBoxKey) {
-                    throw new Error(`Box key used does not match sending device's user`);
-                }
-                message.payload = this.localDevice.openBoxedAndSignedData(message.payload);
-            }
-            catch (err) {
-                // if I couldn't open it with mine, maybe it's boxed with the group's secret key
-                try {
-                    const groupSecretKey = await this.getGroupSecretKey(message.dataContextId);
-                    message.payload = (0, peers_sdk_1.openBoxWithSecretKey)(message.payload, groupSecretKey);
-                }
-                catch (err) {
-                    throw new Error(`Could not open boxed data`, { cause: err });
-                }
-            }
-        }
-        else {
-            try {
-                const fromPublicKey = message.payload.publicKey;
-                if (fromUser && fromUser.publicKey !== fromPublicKey) {
-                    throw new Error(`public key of signature does not match sending device's user`);
-                }
-                (0, peers_sdk_1.isObjectSignatureValid)(message.payload);
-            }
-            catch (err) {
-                throw new Error(`Could not validate signature`, { cause: err });
-            }
-        }
-    }
-    deviceMessagesSeen = {};
-    deviceAliases = new Map();
-    deviceAliasesExpires = new Map();
-    async sendDeviceMessage(partialMessage) {
-        // Fill in defaults for optional fields
-        const message = {
-            deviceMessageId: partialMessage.deviceMessageId || (0, peers_sdk_1.newid)(),
-            fromDeviceId: partialMessage.fromDeviceId || this.userContext.deviceId(),
-            toDeviceId: partialMessage.toDeviceId,
-            dataContextId: partialMessage.dataContextId,
-            ttl: partialMessage.ttl ?? 5,
-            payload: partialMessage.payload,
-            hops: partialMessage.hops || [],
-        };
-        // don't process this again if I've already seen it
-        if (this.deviceMessagesSeen[message.deviceMessageId]) {
-            return ACK_DUP;
-        }
-        this.deviceMessagesSeen[message.deviceMessageId] = true;
-        // device-alias special logic
-        {
-            if (message.toDeviceId === 'device-alias' && message.payload) {
-                const alias = message.payload;
-                if (typeof alias !== 'string' || alias.length < 4 || alias.length > 12) {
-                    return {
-                        isError: true,
-                        statusCode: 400,
-                        statusMessage: 'Invalid alias',
-                    };
-                }
-                if (this.deviceAliases.has(alias) && this.deviceAliases.get(alias) !== message.fromDeviceId) {
-                    return {
-                        isError: true,
-                        statusCode: 400,
-                        statusMessage: 'Alias already in use by another device',
-                    };
-                }
-                this.deviceAliases.set(alias, message.fromDeviceId);
-                this.deviceAliasesExpires.set(alias, Date.now() + 600_000); // 10 minutes
-                message.ttl--;
-                if (message.ttl <= 0) {
-                    return exports.TTL0;
-                }
-                // propagate the alias to all devices
-                return this.forwardDeviceMessageAndReturnFirstResponse(message, Object.values(this.allConnections));
-            }
-            const knownAlias = this.deviceAliases.get(message.toDeviceId);
-            if (knownAlias) {
-                message.toDeviceId = knownAlias;
-            }
-            // user-connect special logic
-            if (message.dataContextId === 'user-connect' && message.toDeviceId === this.userContext.deviceId()) {
-                return this.userConnectAnswer(message);
-            }
-        }
-        // if this is the source device, assume we need to secure the message
-        if (message.hops.length === 0 && message.payload && message.dataContextId !== 'user-connect') {
-            try {
-                await this.secureDeviceMessagePayload(message);
-            }
-            catch (err) {
-                throw new Error(`Error while securing device message payload`, { cause: err });
-            }
-        }
-        // add this device to the list of hops
-        message.hops = [...message.hops, this.userContext.deviceId()];
-        const dataContextIds = [this.userContext.userId, ...this.userContext.groupIds()];
-        // Device Discovery - if there is no deviceId, we assume they are just looking for any device that supports the given dataContextId
-        // TODO revisit this to make sure we're not creating a bunch of unnecessary noise by using an empty toDeviceId
-        if (message.toDeviceId === '' && dataContextIds.includes(message.dataContextId) && message.fromDeviceId !== this.userContext.deviceId() && !message.payload) {
-            return {
-                statusCode: 200,
-                message: "OK",
-                hops: message.hops
-            };
-        }
-        // if it's meant for this device then process it
-        if (this.userContext.deviceId() === message.toDeviceId) {
-            try {
-                await this.validateDeviceMessagePayload(message);
-            }
-            catch (err) {
-                return {
-                    isError: true,
-                    statusCode: 400,
-                    statusMessage: `Error while validating device message payload: ${err}`
-                };
-            }
-            // Check for device-level handler first (e.g., webrtc-signal)
-            if (message.payload?.type && this.deviceMessageHandlers.has(message.payload.type)) {
-                const handler = this.deviceMessageHandlers.get(message.payload.type);
-                return handler(message);
-            }
-            // check if this user has joined this group, if not return error
-            if (!dataContextIds.includes(message.dataContextId)) {
-                return {
-                    isError: true,
-                    statusCode: 400,
-                    statusMessage: 'Device does not support specified dataContext: ' + message.dataContextId
-                };
-            }
-            const dataContext = this.userContext.getDataContext(message.dataContextId);
-            const syncDevice = this.getPeerGroupDevice(dataContext);
-            // give it to groupDevice to process it
-            return syncDevice.sendDeviceMessage(message);
-        }
-        // decrement ttl
-        message.ttl--;
-        if (message.ttl <= 0) {
-            return exports.TTL0;
-        }
-        // TODO maybe use hash chain to validate hopes are append only
-        // TODO maybe use hops to record paths for later use
-        // try to forward to the exact device
-        if (this.allConnections[message.toDeviceId]) {
-            const conn = this.allConnections[message.toDeviceId];
-            return conn.emit("sendDeviceMessage", message);
-        }
-        // if we don't have a direct connection to the device and the ttl is 1, we know it'll fail so short circuit
-        if (message.ttl <= 1) {
-            return exports.TTL0;
-        }
-        // before flooding the network make sure the message size isn't too big and TTL is reasonable
-        if (JSON.stringify(message).length > this.MAX_DEVICE_MESSAGE_SIZE) {
-            return {
-                isError: true,
-                statusCode: 413,
-                statusMessage: "Payload Too Large"
-            };
-        }
-        if (message.ttl > 4) {
-            throw new Error('Max TTL is 5 but message has TTL of ' + (message.ttl + 1));
-        }
-        // start with connections to all devices that are not in the current list of hops
-        let connectionsToTry = Array.from(this.connectionStates.keys())
-            .filter(c => !message.hops.includes(c.remoteDeviceInfo.deviceId));
-        const alreadySeenDeviceIds = (0, lodash_1.uniq)([this.userContext.deviceId(), ...Object.keys(this.allConnections), ...message.hops]);
-        // try to find an indirect connection from cached networkInfos (connection to a device that is then connected to target device)
-        for (const syncGroup of Object.values(this.syncGroups)) {
-            const pathToDevice = syncGroup.getPathToDevice(message.toDeviceId);
-            if (pathToDevice.throughDeviceIds.length) {
-                const indirectConnections = connectionsToTry.filter(c => pathToDevice.throughDeviceIds.includes(c.remoteDeviceInfo.deviceId))
-                    // before slicing, sort by connections by the ones with the most indirect connections to other devices
-                    // QUESTION? do we really want to purposely send to "busy" devices or would it be better to send to less busy devices that just happen to have the right path?
-                    .sort((a, b) => {
-                    const aRemoteDeviceIds = this.getConnectionIndirectRemoteDeviceIds(a, alreadySeenDeviceIds);
-                    const bRemoteDeviceIds = this.getConnectionIndirectRemoteDeviceIds(b, alreadySeenDeviceIds);
-                    return bRemoteDeviceIds.length - aRemoteDeviceIds.length;
-                })
-                    .slice(0, 2); // in the unlikely event we have many indirect connections, trim them down
-                const response = await this.forwardDeviceMessageAndReturnFirstResponse(message, indirectConnections);
-                if ((response !== ACK_DUP && response !== exports.TTL0)) {
-                    return response;
-                }
-                else if (indirectConnections.length > 1) {
-                    // if we had multiple indirect connections and they all returned TTL0 (which may have stemmed from ACK_DUP),
-                    // don't continue trying other connections, it's very likely the message has already been delivered
-                    return response;
-                }
-                connectionsToTry = connectionsToTry.filter(c => !indirectConnections.includes(c));
-            }
-        }
-        // if we don't have a lot of connections just forward to them all
-        if (connectionsToTry.length <= this.MAX_CONNECTIONS_TO_FORWARD_MESSAGES_TO) {
-            return this.forwardDeviceMessageAndReturnFirstResponse(message, connectionsToTry);
-        }
-        // WARNING! at this point, we don't have a known path but we have a lot of connections
-        //          we could end up choking this device or its network if we're not careful and it might time out anyway
-        //          we want to find a good subset of connections that have the best chance of being connected to the device
-        // remove connections that don't have any new paths 
-        // i.e. trim off this device's connections to leaf network devices, no point forwarding to them
-        connectionsToTry = connectionsToTry.filter(c => {
-            const remoteDeviceIds = this.getConnectionIndirectRemoteDeviceIds(c, alreadySeenDeviceIds);
-            return remoteDeviceIds.length > 0;
-        });
-        if (connectionsToTry.length <= this.MAX_CONNECTIONS_TO_FORWARD_MESSAGES_TO) {
-            return this.forwardDeviceMessageAndReturnFirstResponse(message, connectionsToTry);
-        }
-        // sort the connections by how many new paths they have (highest first) and whether they're in the target group
-        // example: if we allow 4 connections to be forwarded to, and we have 2 connections that are in the target group,
-        //          those 2 will be prioritized and then the next 2 connections will be the ones with the highest number of new paths
-        //          if we have more than 4 connections in the target group, we'll take the 4 with the highest number of new paths
-        const messageDataContextSyncGroup = this.syncGroups[message.dataContextId];
-        const groupConnectionDeviceIds = new Set((messageDataContextSyncGroup?.getConnections() || []).map(dc => dc.deviceId));
-        // TODO: change this to re-sort after each selection to account for overlap in indirect connections
-        connectionsToTry = connectionsToTry.sort((a, b) => {
-            // prioritize connections that are in the target group
-            const aIsGroupConnection = groupConnectionDeviceIds.has(a.remoteDeviceInfo.deviceId) ? 1 : 0;
-            const bIsGroupConnection = groupConnectionDeviceIds.has(b.remoteDeviceInfo.deviceId) ? 1 : 0;
-            if (aIsGroupConnection !== bIsGroupConnection) {
-                return bIsGroupConnection - aIsGroupConnection;
-            }
-            // for each connection, get the number of indirect connections it has to devices we haven't already seen
-            const aRemoteDeviceIds = this.getConnectionIndirectRemoteDeviceIds(a, alreadySeenDeviceIds);
-            const bRemoteDeviceIds = this.getConnectionIndirectRemoteDeviceIds(b, alreadySeenDeviceIds);
-            return bRemoteDeviceIds.length - aRemoteDeviceIds.length;
-        });
-        // finally, forward to the top connections
-        return this.forwardDeviceMessageAndReturnFirstResponse(message, connectionsToTry.slice(0, this.MAX_CONNECTIONS_TO_FORWARD_MESSAGES_TO));
-    }
-    forwardDeviceMessageAndReturnFirstResponse(message, connectionsToForwardTo) {
-        return new Promise((resolve) => {
-            const pendingDevices = new Set(connectionsToForwardTo.map(c => c.remoteDeviceInfo.deviceId));
-            if (pendingDevices.size === 0) {
-                return resolve(exports.TTL0);
-            }
-            let responseSent = false;
-            function checkResponse(deviceId, response) {
-                if (responseSent) {
-                    return;
-                }
-                pendingDevices.delete(deviceId);
-                if (response !== ACK_DUP && response !== exports.TTL0) {
-                    responseSent = true;
-                    resolve(response);
-                }
-                if (pendingDevices.size === 0) {
-                    responseSent = true;
-                    resolve(exports.TTL0);
-                }
-            }
-            for (const conn of connectionsToForwardTo) {
-                const deviceId = conn.remoteDeviceInfo.deviceId;
-                conn.emit("sendDeviceMessage", message)
-                    .then(response => checkResponse(deviceId, response))
-                    .catch(err => checkResponse(deviceId, err));
-            }
-        });
+    sendDeviceMessage(partialMessage) {
+        return this.deviceMessages.sendDeviceMessage(partialMessage);
     }
     /**
      * this is used for testing setup, it's not intended for normal use
@@ -825,21 +410,7 @@ class ConnectionManager {
         };
     }
     getConnectionIndirectRemoteDeviceIds(connection, excludeDeviceIds) {
-        const remoteDeviceId = connection.remoteDeviceInfo.deviceId;
-        const allSyncGroups = Object.values(this.syncGroups);
-        const connectedIds = new Set();
-        for (const syncDevice of allSyncGroups) {
-            syncDevice.reportRemoteDeviceConnectedIds(remoteDeviceId, connectedIds);
-        }
-        if (excludeDeviceIds?.length) {
-            for (const excludeId of excludeDeviceIds) {
-                connectedIds.delete(excludeId);
-            }
-        }
-        // remove self which will always be there but we should never care about (hmmm, this might confuse things since it should be there but never will be?)
-        // MAYBE: use this as a way to detect out-of-date network info caches if it's _not_ there?
-        connectedIds.delete(this.userContext.deviceId());
-        return Array.from(connectedIds);
+        return this.deviceMessages.getConnectionIndirectRemoteDeviceIds(connection, excludeDeviceIds);
     }
     getPathToDevice(deviceId) {
         if (this.allConnections[deviceId]) {
@@ -861,24 +432,12 @@ class ConnectionManager {
             throughDeviceIds: [],
         };
     }
-    cleanupExpiredAliases() {
-        const now = Date.now();
-        for (const [alias, expires] of this.deviceAliasesExpires) {
-            if (expires < now) {
-                this.deviceAliases.delete(alias);
-                this.deviceAliasesExpires.delete(alias);
-            }
-        }
-    }
     async dispose() {
-        this.userConnectCodeOfferSubscription.dispose();
-        this.userConnectCodeAnswerSubscription.dispose();
+        this.deviceMessages.dispose();
         for (const syncGroup of Object.values(this.syncGroups)) {
             await syncGroup?.dispose();
         }
-        clearInterval(this.cleanOldDeviceMessagesSeenInterval);
         clearInterval(this.pingInterval);
-        clearInterval(this.cleanupExpiredAliasesInterval);
         const connections = Array.from(this.connectionStates.keys());
         for (const connection of connections) {
             await this.removeConnection(connection);