@peers-app/peers-sdk 0.1.4

package/dist/device/connection.test.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const keys_1 = require("../keys");
+const connection_1 = require("./connection");
+const device_1 = require("./device");
+function createTestSocket(localHandlers, remoteHandlers) {
+    const socket = {
+        id: (0, utils_1.newid)(),
+        emit(eventName, args, callback) {
+            remoteHandlers.forEach(async ({ eventName: _eventName, handler }) => {
+                if (eventName === _eventName) {
+                    handler(args, callback);
+                }
+            });
+        },
+        on(eventName, handler) {
+            localHandlers.push({
+                eventName,
+                handler: async (...args) => handler(...args)
+            });
+        },
+        removeAllListeners(eventName) {
+            while (localHandlers.find(({ eventName: _eventName }) => eventName === _eventName)) {
+                const index = localHandlers.findIndex(({ eventName: _eventName }) => eventName === _eventName);
+                localHandlers.splice(index, 1);
+            }
+        },
+        disconnect() {
+            // Simulate disconnection logic if needed
+        }
+    };
+    return socket;
+}
+function createTestSocketPair() {
+    const clientHandlers = [];
+    const serverHandlers = [];
+    const clientSocket = createTestSocket(clientHandlers, serverHandlers);
+    const serverSocket = createTestSocket(serverHandlers, clientHandlers);
+    const connectionId = (0, utils_1.newid)();
+    clientSocket.id = connectionId;
+    serverSocket.id = connectionId;
+    return {
+        clientSocket,
+        serverSocket,
+    };
+}
+describe(connection_1.Connection, () => {
+    it("should allow simulating a client and server connection handshake", async () => {
+        const { clientSocket, serverSocket } = createTestSocketPair();
+        const clientDevice = new device_1.Device();
+        const serverDevice = new device_1.Device();
+        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
+        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ['localhost']);
+        expect(clientConnection.connectionId).toBe(serverConnection.connectionId);
+        const response = await clientConnection.doHandshake('localhost');
+        expect(response.userId).toBe(serverDevice.userId);
+        expect(response.deviceId).toBe(serverDevice.deviceId);
+        expect(response.publicKey).toBe(serverDevice.publicKey);
+        expect(response.publicBoxKey).toBe(serverDevice.publicBoxKey);
+        expect(response.serverAddress).toBe('localhost');
+        expect(response.connectionId).toBe(serverConnection.connectionId);
+        serverConnection.exposeRPC('ping', async (n, s) => `pong - ${n}, ${s}`);
+        const pong = await clientConnection.emit('ping', 1, "hello");
+        expect(pong).toBe('pong - 1, hello');
+    });
+    it("should create a new id if socket doesn't have one", async () => {
+        const socket = {
+            id: (0, utils_1.newid)(),
+            emit(eventName, args, callback) {
+                // do nothing
+            },
+            on(eventName, handler) {
+                // do nothing
+            },
+            removeAllListeners(eventName) {
+                // do nothing
+            },
+            disconnect() {
+                // do nothing
+            }
+        };
+        const connection = new connection_1.Connection(socket, new device_1.Device());
+        expect(connection.connectionId).toBeTruthy();
+    });
+    it("client should requestSecure if both are using https", async () => {
+        const { clientSocket, serverSocket } = createTestSocketPair();
+        const clientDevice = new device_1.Device();
+        const serverDevice = new device_1.Device();
+        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
+        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ['https://localhost']);
+        await clientConnection.doHandshake('https://localhost');
+        expect(clientConnection.secure).toBe(true);
+        // and allow forcing insecure
+        clientConnection.forceInsecure = true;
+        expect(clientConnection.secure).toBe(false);
+        // and only return a copy of the remoteDeviceInfo
+        expect(clientConnection.remoteDeviceInfo).not.toBe(clientConnection.remoteDeviceInfo);
+    });
+    it("should gracefully handle remote errors for secure connections", async () => {
+        const { clientSocket, serverSocket } = createTestSocketPair();
+        const clientDevice = new device_1.Device();
+        const serverDevice = new device_1.Device();
+        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
+        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ['https://localhost']);
+        await clientConnection.doHandshake('https://localhost');
+        // for secure connections
+        expect(clientConnection.secure).toBe(true);
+        expect(serverConnection.secure).toBe(true);
+        serverConnection.exposeRPC('ping', async () => { throw new Error("fake error"); });
+        const response = await clientConnection.emit('ping').catch((err) => err);
+        expect(response).toEqual({
+            errorType: "RPC_ERROR",
+            error: "fake error",
+        });
+    });
+    it("should gracefully handle remote errors for unsecure connections", async () => {
+        const { clientSocket, serverSocket } = createTestSocketPair();
+        const clientDevice = new device_1.Device();
+        const serverDevice = new device_1.Device();
+        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
+        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ['http://localhost']);
+        await clientConnection.doHandshake('http://localhost');
+        // for secure connections
+        expect(clientConnection.secure).toBe(false);
+        expect(serverConnection.secure).toBe(false);
+        serverConnection.exposeRPC('ping', async () => { throw new Error("fake error"); });
+        const response = await clientConnection.emit('ping').catch((err) => err);
+        expect(response).toEqual({
+            errorType: "RPC_ERROR",
+            error: "fake error",
+        });
+    });
+    it("should ignore other events before the handshake is finished", async () => {
+        const { clientSocket, serverSocket } = createTestSocketPair();
+        const clientDevice = new device_1.Device();
+        const serverDevice = new device_1.Device();
+        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
+        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ['https://localhost']);
+        serverConnection.exposeRPC('ping', async () => 'pong');
+        expect(serverConnection.verified).toBe(false);
+        expect(clientConnection.verified).toBe(false);
+        const response = await clientConnection.emit('ping').catch((err) => err);
+        expect(response).toMatch(/Connection not verified/);
+    });
+    it("client should detect different connection ids during handshake", async () => {
+        const serverAddress = 'http://localhost';
+        const { clientSocket, serverSocket } = createTestSocketPair();
+        const clientDevice = new device_1.Device();
+        const serverDevice = new device_1.Device();
+        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
+        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, [serverAddress]);
+        serverConnection.exposeRPC('ping', async () => 'pong');
+        serverConnection.socket.removeAllListeners('completeHandshake');
+        serverConnection.exposeRPC('completeHandshake', async (handshakeBox) => {
+            const handshake = await serverConnection.completeHandshake(handshakeBox);
+            handshake.connectionId = 'fake';
+            return handshake;
+        });
+        const result = await clientConnection.doHandshake(serverAddress).catch((err) => String(err));
+        expect(result).toMatch(/Invalid connectionId/);
+    });
+    it("client should detect different device ids during handshake", async () => {
+        const serverAddress = 'http://localhost';
+        const { clientSocket, serverSocket } = createTestSocketPair();
+        const clientDevice = new device_1.Device();
+        const serverDevice = new device_1.Device();
+        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
+        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, [serverAddress]);
+        serverConnection.exposeRPC('ping', async () => 'pong');
+        serverConnection.socket.removeAllListeners('completeHandshake');
+        serverConnection.exposeRPC('completeHandshake', async (handshakeBox) => {
+            const handshake = await serverConnection.completeHandshake(handshakeBox);
+            handshake.deviceId = 'fake';
+            return handshake;
+        });
+        const result = await clientConnection.doHandshake(serverAddress).catch((err) => String(err));
+        expect(result).toMatch(/Inconsistent device info/);
+    });
+    it("client should detect different device ids during handshake", async () => {
+        const serverAddress = 'http://localhost';
+        const { clientSocket, serverSocket } = createTestSocketPair();
+        const clientDevice = new device_1.Device();
+        const serverDevice = new device_1.Device();
+        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
+        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, [serverAddress]);
+        serverConnection.exposeRPC('ping', async () => 'pong');
+        serverConnection.socket.removeAllListeners('completeHandshake');
+        serverConnection.exposeRPC('completeHandshake', async (handshakeBox) => {
+            const handshake = await serverConnection.completeHandshake(handshakeBox);
+            handshake.userId = 'fake';
+            return handshake;
+        });
+        const result = await clientConnection.doHandshake(serverAddress).catch((err) => String(err));
+        expect(result).toMatch(/Inconsistent device info/);
+    });
+    it("client should detect different box key during handshake", async () => {
+        const serverAddress = 'http://localhost';
+        const { clientSocket, serverSocket } = createTestSocketPair();
+        const clientDevice = new device_1.Device();
+        const serverDevice = new device_1.Device();
+        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
+        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, [serverAddress]);
+        serverConnection.exposeRPC('ping', async () => 'pong');
+        serverConnection.socket.removeAllListeners('completeHandshake');
+        serverConnection.exposeRPC('completeHandshake', async (handshakeBox) => {
+            const handshake = await serverConnection.completeHandshake(handshakeBox);
+            const _keys = (0, keys_1.newKeys)();
+            handshake.publicBoxKey = _keys.publicBoxKey;
+            return handshake;
+        });
+        const result = await clientConnection.doHandshake(serverAddress).catch((err) => String(err));
+        expect(result).toMatch(/Inconsistent public keys/);
+    });
+    it("client should detect different public key during handshake", async () => {
+        const serverAddress = 'http://localhost';
+        const { clientSocket, serverSocket } = createTestSocketPair();
+        const clientDevice = new device_1.Device();
+        const serverDevice = new device_1.Device();
+        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
+        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, [serverAddress]);
+        serverConnection.exposeRPC('ping', async () => 'pong');
+        serverConnection.socket.removeAllListeners('completeHandshake');
+        serverConnection.exposeRPC('completeHandshake', async (handshakeBox) => {
+            const handshake = await serverConnection.completeHandshake(handshakeBox);
+            const _keys = (0, keys_1.newKeys)();
+            handshake.publicKey = _keys.publicKey;
+            return handshake;
+        });
+        const result = await clientConnection.doHandshake(serverAddress).catch((err) => String(err));
+        expect(result).toMatch(/Inconsistent public keys/);
+    });
+    it("should handle RPC calls with large arguments through chunking", async () => {
+        const { clientSocket, serverSocket } = createTestSocketPair();
+        const clientDevice = new device_1.Device();
+        const serverDevice = new device_1.Device();
+        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
+        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ['localhost']);
+        clientConnection.maxChunkSize = 50;
+        serverConnection.maxChunkSize = 50;
+        clientConnection.socket.maxChunkSize = 50;
+        serverConnection.socket.maxChunkSize = 50;
+        await clientConnection.doHandshake('localhost');
+        const clientEmitSpy = jest.spyOn(clientConnection.socket.socket, 'emit');
+        const serverEmitSpy = jest.spyOn(serverConnection.socket.socket, 'emit');
+        // Create large data that will definitely need chunking
+        const largeData = {
+            message: "A".repeat(500), // 500 characters
+            metadata: "B".repeat(300), // 300 characters
+            payload: "C".repeat(400) // 400 characters
+        };
+        serverConnection.exposeRPC('processLargeData', async (data) => {
+            return {
+                received: data,
+                processedSize: JSON.stringify(data).length
+            };
+        });
+        const result = await clientConnection.emit('processLargeData', largeData);
+        expect(result.received.message).toBe("A".repeat(500));
+        expect(result.received.metadata).toBe("B".repeat(300));
+        expect(result.received.payload).toBe("C".repeat(400));
+        expect(result.processedSize).toBeGreaterThan(1000); // Should be large
+        // Count chunk emissions
+        const clientChunkCalls = clientEmitSpy.mock.calls.filter((call) => call[0] === clientConnection.socket.safeSocketChunkEventName);
+        const serverChunkCalls = serverEmitSpy.mock.calls.filter((call) => call[0] === serverConnection.socket.safeSocketChunkEventName);
+        // The data gets wrapped by Connection layer (encryption/signing), making it larger
+        // 41 chunks at 50 bytes each = ~2050 bytes (41 * 50)
+        // 43 chunks at 50 bytes each = ~2150 bytes (43 * 50)
+        expect(clientChunkCalls.length).toBe(41); // ~2050 bytes wrapped data / 50 bytes per chunk
+        expect(serverChunkCalls.length).toBe(43); // ~2150 bytes wrapped data / 50 bytes per chunk
+    });
+    it("should reject handshake if device timestamps are too far apart", async () => {
+        const { clientSocket, serverSocket } = createTestSocketPair();
+        const clientDevice = new device_1.Device();
+        const serverDevice = new device_1.Device();
+        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
+        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ['localhost']);
+        // Set a very strict timestamp tolerance (1 second) to make test reliable
+        serverConnection.handshakeTimestampToleranceMs = 1000;
+        // Mock the client device to send an old timestamp
+        const originalGetHandshake = clientDevice.getHandshake.bind(clientDevice);
+        clientDevice.getHandshake = function (connectionId, serverAddress) {
+            const handshake = originalGetHandshake(connectionId, serverAddress);
+            // Make timestamp 2 seconds in the past (beyond tolerance)
+            handshake.contents.timestamp = Date.now() - 2000;
+            return handshake;
+        };
+        const result = await clientConnection.doHandshake('localhost').catch((err) => err.message || err.error || String(err));
+        expect(result).toMatch(/Remote device's system clock is too far out of sync/);
+    });
+    it.todo("should handle RPC calls that return undefined");
+});

package/dist/device/device-election.d.ts

@@ -0,0 +1,36 @@
+import { IDeviceConnection, INetworkInfo } from "../types/peer-device";
+export interface IElectionData {
+    deviceId: string;
+    myConnections: IDeviceConnection[];
+    allNetworkInfo: INetworkInfo[];
+}
+export declare function electDevices({ deviceId, myConnections, allNetworkInfo, }: IElectionData): {
+    preferredDeviceIds: string[];
+    preferredByDeviceIds: string[];
+};
+export interface ISortableConnection extends INetworkInfo {
+    connectedDeviceIds: string[];
+    preferredByDeviceIds: string[];
+    myConnection: IDeviceConnection | undefined;
+}
+export interface ISortConnectionsArgs {
+    myDeviceId: string;
+    unconnectedDeviceIds: Set<string>;
+    connections: ISortableConnection[];
+}
+/**
+ * Sort connections from most preferred to least preferred
+ *   The most preferred connections are ones that link us to the most new devices
+ *    (i.e. not already connected to by other preferred connections).
+ *   Ties go to connections that are most preferred by other devices.
+ *   Further ties go to connections with the lowest latency * error rate
+ */
+export declare function sortConnections({ myDeviceId, connections, unconnectedDeviceIds }: ISortConnectionsArgs): ISortableConnection[];
+export interface IGetLeastPreferredConnectionArgs {
+    connections: (IDeviceConnection & {
+        groups: string[];
+    })[];
+    preferredDeviceIds: string[];
+    preferredByDeviceIds: string[];
+}
+export declare function getLeastPreferredConnection({ connections, preferredDeviceIds, preferredByDeviceIds, }: IGetLeastPreferredConnectionArgs): IDeviceConnection | undefined;

package/dist/device/device-election.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.electDevices = electDevices;
+exports.sortConnections = sortConnections;
+exports.getLeastPreferredConnection = getLeastPreferredConnection;
+const lodash_1 = require("lodash");
+const peer_device_1 = require("../types/peer-device");
+function electDevices({ deviceId, myConnections, allNetworkInfo, }) {
+    const allDeviceIdsSet = new Set();
+    const _preferredByDeviceIdsSet = new Set();
+    const allConnectionInfos = allNetworkInfo.map(networkInfo => {
+        const deviceIds = [networkInfo.deviceId, ...networkInfo.connections.map(c => c.deviceId)];
+        deviceIds.forEach(id => allDeviceIdsSet.add(id));
+        allDeviceIdsSet.add(networkInfo.deviceId);
+        if (networkInfo.preferredDeviceIds.includes(deviceId)) {
+            _preferredByDeviceIdsSet.add(networkInfo.deviceId);
+        }
+        const preferredByDeviceIds = allNetworkInfo.filter(n => n.preferredDeviceIds.includes(networkInfo.deviceId))
+            .map(n => n.deviceId);
+        const myConnection = myConnections.find(c => c.deviceId === networkInfo.deviceId);
+        return {
+            ...networkInfo,
+            myConnection,
+            connectedDeviceIds: deviceIds,
+            preferredByDeviceIds,
+        };
+    });
+    allDeviceIdsSet.delete(deviceId);
+    const preferredConnections = [];
+    let sortedConnections = allConnectionInfos.filter(c => c.myConnection);
+    while (allDeviceIdsSet.size && sortedConnections.length) {
+        // sort connections (best will be first)
+        sortedConnections = sortConnections({
+            myDeviceId: deviceId,
+            connections: sortedConnections,
+            unconnectedDeviceIds: allDeviceIdsSet
+        });
+        const connection = sortedConnections.shift();
+        if (connection) {
+            preferredConnections.push(connection.myConnection);
+            connection.connectedDeviceIds.forEach(id => allDeviceIdsSet.delete(id));
+        }
+        else {
+            break;
+        }
+    }
+    return {
+        preferredDeviceIds: preferredConnections.map(c => c.deviceId),
+        preferredByDeviceIds: Array.from(_preferredByDeviceIdsSet),
+    };
+}
+/**
+ * Sort connections from most preferred to least preferred
+ *   The most preferred connections are ones that link us to the most new devices
+ *    (i.e. not already connected to by other preferred connections).
+ *   Ties go to connections that are most preferred by other devices.
+ *   Further ties go to connections with the lowest latency * error rate
+ */
+function sortConnections({ myDeviceId, connections, unconnectedDeviceIds }) {
+    // sort by latency * error rate (smaller is better)
+    connections.sort((a, b) => {
+        const aLatency = (a.myConnection.latencyMs || 1) * (a.myConnection.errorRate || 0.00001);
+        const bLatency = (b.myConnection.latencyMs || 1) * (b.myConnection.errorRate || 0.00001);
+        return aLatency - bLatency;
+    });
+    // sort by preferred by other devices count (higher is better)
+    connections.sort((a, b) => {
+        const aPreferredCount = a.preferredDeviceIds.length;
+        const bPreferredCount = b.preferredDeviceIds.length;
+        return bPreferredCount - aPreferredCount;
+    });
+    // sort by links to new devices - in general, this is most important except for the later edge-cases
+    connections.sort((a, b) => {
+        const linksToDeviceA = a.connectedDeviceIds.filter(id => unconnectedDeviceIds.has(id)).length;
+        const linksToDeviceB = b.connectedDeviceIds.filter(id => unconnectedDeviceIds.has(id)).length;
+        return linksToDeviceB - linksToDeviceA;
+    });
+    //=============================================
+    // Edge Cases - these should _usually_ return 0
+    //=============================================
+    const MAX_CONNECTIONS = peer_device_1.PeerDeviceConsts.MAX_CONNECTIONS;
+    // deprioritize devices that are close to max connections
+    connections.sort((a, b) => {
+        const aConnCnt = a.preferredByDeviceIds.length + a.preferredDeviceIds.length;
+        const bConnCnt = b.preferredByDeviceIds.length + b.preferredDeviceIds.length;
+        const nearingMaxA = aConnCnt >= MAX_CONNECTIONS * 0.9;
+        const nearingMaxB = bConnCnt >= MAX_CONNECTIONS * 0.9;
+        if (nearingMaxA && !nearingMaxB)
+            return 1;
+        if (!nearingMaxA && nearingMaxB)
+            return -1;
+        return 0;
+    });
+    // prefer devices that have a connection back to me
+    //   I think this is an artifact of testing and in the real world this should be a no-op (connections should be bidirectional)
+    connections.sort((a, b) => {
+        const aHasConn = a.connections.some(c => c.deviceId === myDeviceId);
+        const bHasConn = b.connections.some(c => c.deviceId === myDeviceId);
+        if (aHasConn && !bHasConn)
+            return -1;
+        if (!aHasConn && bHasConn)
+            return 1;
+        return 0;
+    });
+    return connections;
+}
+function getLeastPreferredConnection({ connections, preferredDeviceIds, preferredByDeviceIds, }) {
+    // first consider connections that are not critical to me and I'm not critical to them
+    let candidates = connections.filter(c => !(preferredByDeviceIds.includes(c.deviceId) || preferredDeviceIds.includes(c.deviceId)));
+    if (!candidates.length) {
+        // if none, next consider connections that are not critical to me
+        candidates = connections.filter(c => !preferredDeviceIds.includes(c.deviceId));
+    }
+    if (!candidates.length) {
+        // if none, next consider connections that I am not critical to
+        candidates = connections.filter(c => !preferredByDeviceIds.includes(c.deviceId));
+    }
+    if (!candidates.length) {
+        // if none, then just consider all connections
+        candidates = [...connections];
+    }
+    // start with random order to avoid biasing the selection to newer connections
+    candidates = (0, lodash_1.shuffle)(candidates);
+    // sort by latency * error rate (smaller is better)
+    candidates.sort((a, b) => {
+        const aLatency = (a.latencyMs || 1) * (a.errorRate || 0.00001);
+        const bLatency = (b.latencyMs || 1) * (b.errorRate || 0.00001);
+        return aLatency - bLatency;
+    });
+    // sort by least number of groups (higher is better)
+    candidates.sort((a, b) => {
+        const aGroupCount = a.groups.length;
+        const bGroupCount = b.groups.length;
+        return bGroupCount - aGroupCount;
+    });
+    return candidates[candidates.length - 1];
+}

package/dist/device/device.d.ts

@@ -0,0 +1,22 @@
+import { IDataBox, ISignedObject } from "../keys";
+import { IDeviceHandshake, IDeviceInfo } from "../data";
+export declare class Device implements IDeviceInfo {
+    readonly userId: string;
+    readonly deviceId: string;
+    private readonly keys;
+    constructor(userId?: string, deviceId?: string, keys?: import("../keys").IPublicPrivateKeys);
+    get publicKey(): string;
+    get publicBoxKey(): string;
+    signMessageWithSecretKey(msg: string): string;
+    signObjectWithSecretKey<T>(obj: T): ISignedObject<T>;
+    boxDataWithKeys(data: any, toPublicKey: string): IDataBox;
+    boxDataForDevice(data: any, device: IDeviceInfo): IDataBox;
+    openBoxWithSecretKey(data: IDataBox): any;
+    signAndBoxDataForDevice<T>(data: T, device: IDeviceInfo): IDataBox;
+    unwrapResponse<T>(response: T | ISignedObject<T> | IDataBox): T;
+    openBoxedAndSignedData<T>(response: IDataBox): T;
+    getHandshake(connectionId: string, serverAddress: string): ISignedObject<IDeviceHandshake>;
+    handshakeResponse(remoteHandshake: ISignedObject<IDeviceHandshake>, connectionId: string, thisServerAddress: string): IDeviceHandshake;
+    private deviceInfoSigned;
+    getDeviceInfo(): ISignedObject<IDeviceInfo>;
+}

package/dist/device/device.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Device = void 0;
+const utils_1 = require("../utils");
+const keys_1 = require("../keys");
+class Device {
+    userId;
+    deviceId;
+    keys;
+    constructor(userId = (0, utils_1.newid)(), deviceId = (0, utils_1.newid)(), keys = (0, keys_1.newKeys)()) {
+        this.userId = userId;
+        this.deviceId = deviceId;
+        this.keys = keys;
+    }
+    get publicKey() {
+        return this.keys.publicKey;
+    }
+    get publicBoxKey() {
+        return this.keys.publicBoxKey;
+    }
+    signMessageWithSecretKey(msg) {
+        return (0, keys_1.signMessageWithSecretKey)(msg, this.keys.secretKey);
+    }
+    signObjectWithSecretKey(obj) {
+        return (0, keys_1.signObjectWithSecretKey)(obj, this.keys.secretKey);
+    }
+    boxDataWithKeys(data, toPublicKey) {
+        return (0, keys_1.boxDataWithKeys)(data, toPublicKey, this.keys.secretKey);
+    }
+    boxDataForDevice(data, device) {
+        return this.boxDataWithKeys(data, device.publicBoxKey);
+    }
+    openBoxWithSecretKey(data) {
+        return (0, keys_1.openBoxWithSecretKey)(data, this.keys.secretKey);
+    }
+    signAndBoxDataForDevice(data, device) {
+        const signedData = this.signObjectWithSecretKey(data);
+        return this.boxDataForDevice(signedData, device);
+    }
+    unwrapResponse(response) {
+        if (!response) {
+            return response;
+        }
+        if (typeof response === 'object' && 'contents' in response && 'nonce' in response && 'fromPublicKey' in response) {
+            const signedResponse = this.openBoxWithSecretKey(response);
+            return this.unwrapResponse(signedResponse);
+        }
+        if (typeof response === 'object' && 'contents' in response && 'signature' in response && 'publicKey' in response) {
+            const signedResponse = response;
+            return (0, keys_1.openSignedObject)(signedResponse);
+        }
+        return response;
+    }
+    openBoxedAndSignedData(response) {
+        const signedResponse = this.openBoxWithSecretKey(response);
+        return (0, keys_1.openSignedObject)(signedResponse);
+    }
+    getHandshake(connectionId, serverAddress) {
+        try {
+            const localDeviceInfo = {
+                connectionId,
+                userId: this.userId,
+                deviceId: this.deviceId,
+                publicKey: this.publicKey,
+                publicBoxKey: this.publicBoxKey,
+                serverAddress,
+                timestamp: Date.now(),
+            };
+            const localDeviceInfoSigned = this.signObjectWithSecretKey(localDeviceInfo);
+            return localDeviceInfoSigned;
+        }
+        catch (e) {
+            throw new Error(`Failed to handshake: ${e.message}`);
+        }
+    }
+    handshakeResponse(remoteHandshake, connectionId, thisServerAddress) {
+        try {
+            const deviceInfo = (0, keys_1.openSignedObject)(remoteHandshake);
+            if (deviceInfo.connectionId !== connectionId) {
+                throw new Error(`Invalid connectionId ${deviceInfo.connectionId}, expected ${connectionId}`);
+            }
+            const handshakeResponse = {
+                connectionId,
+                userId: this.userId,
+                deviceId: this.deviceId,
+                publicKey: this.publicKey,
+                publicBoxKey: this.publicBoxKey,
+                serverAddress: thisServerAddress,
+                timestamp: Date.now(),
+            };
+            return handshakeResponse;
+        }
+        catch (e) {
+            throw new Error(`Failed to handshake: ${e.message}`);
+        }
+    }
+    deviceInfoSigned;
+    getDeviceInfo() {
+        if (!this.deviceInfoSigned) {
+            this.deviceInfoSigned = this.signObjectWithSecretKey({
+                userId: this.userId,
+                deviceId: this.deviceId,
+                publicKey: this.publicKey,
+                publicBoxKey: this.publicBoxKey,
+            });
+        }
+        return this.deviceInfoSigned;
+    }
+}
+exports.Device = Device;

package/dist/device/device.test.d.ts

@@ -0,0 +1 @@
+export {};