@peers-app/peers-sdk 0.14.0 → 0.15.0

package/dist/device/binary-peer-connection.test.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const keys_1 = require("../keys");
-const device_1 = require("./device");
 const utils_1 = require("../utils");
 const binary_peer_connection_1 = require("./binary-peer-connection");
+const device_1 = require("./device");
 // Mock binary peer for testing - simulates WebRTC peers
 class MockBinaryPeer {
     dataHandler;
@@ -11,26 +11,26 @@ class MockBinaryPeer {
     drainHandler;
     otherPeer;
     on(event, handler) {
-        if (event === 'data') {
+        if (event === "data") {
             this.dataHandler = handler;
         }
-        else if (event === 'close') {
+        else if (event === "close") {
             this.closeHandler = handler;
         }
-        else if (event === 'drain') {
+        else if (event === "drain") {
             this.drainHandler = handler;
         }
     }
     send(data) {
         if (this.otherPeer?.dataHandler) {
-            const bytes = typeof data === 'string'
+            const bytes = typeof data === "string"
                 ? Buffer.from(data)
                 : Buffer.isBuffer(data)
                     ? data
                     : Buffer.from(data);
             // Simulate async delivery
             setImmediate(() => {
-                this.otherPeer.dataHandler(bytes);
+                this.otherPeer?.dataHandler?.(bytes);
             });
         }
     }
@@ -53,41 +53,45 @@ async function getMockPeerPair() {
         rPeer,
     };
 }
-describe('binary-peer-connection', () => {
-    describe('MockBinaryPeer', () => {
-        it('should exchange data between mock peers', async () => {
+describe("binary-peer-connection", () => {
+    describe("MockBinaryPeer", () => {
+        it("should exchange data between mock peers", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
-            let iPeerDataReceived = '';
-            iPeer.on('data', (data) => {
+            let iPeerDataReceived = "";
+            iPeer.on("data", (data) => {
                 iPeerDataReceived += data.toString();
             });
-            let rPeerDataReceived = '';
-            rPeer.on('data', (data) => {
+            let rPeerDataReceived = "";
+            rPeer.on("data", (data) => {
                 rPeerDataReceived += data.toString();
             });
-            rPeer.send('rPeer');
-            iPeer.send('iPeer');
+            rPeer.send("rPeer");
+            iPeer.send("iPeer");
             await (0, utils_1.sleep)(50);
-            expect(iPeerDataReceived).toBe('rPeer');
-            expect(rPeerDataReceived).toBe('iPeer');
+            expect(iPeerDataReceived).toBe("rPeer");
+            expect(rPeerDataReceived).toBe("iPeer");
             // Clean up
             iPeer.destroy();
             rPeer.destroy();
         });
     });
-    describe('wrapBinaryPeer', () => {
-        it('should successfully handshake over wrtc protocol', async () => {
+    describe("wrapBinaryPeer", () => {
+        it("should successfully handshake over wrtc protocol", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
             const userId = `00000000000000000user001`;
             const keys = (0, keys_1.newKeys)();
             const connectionId = `00000000000000000conn001`;
             const iPeerDeviceId = `000000000000000device001`;
             const iPeerDevice = new device_1.Device(userId, iPeerDeviceId, keys);
-            const iPeerConnection = (0, binary_peer_connection_1.wrapBinaryPeer)(connectionId, iPeer, iPeerDevice, true, { protocol: 'wrtc' });
+            const iPeerConnection = (0, binary_peer_connection_1.wrapBinaryPeer)(connectionId, iPeer, iPeerDevice, true, {
+                protocol: "wrtc",
+            });
             const rPeerDeviceId = `000000000000000device002`;
             const rPeerDevice = new device_1.Device(userId, rPeerDeviceId, keys);
-            const rPeerConnection = (0, binary_peer_connection_1.wrapBinaryPeer)(connectionId, rPeer, rPeerDevice, false, { protocol: 'wrtc' });
-            await iPeerConnection.doHandshake('wrtc://' + connectionId);
+            const rPeerConnection = (0, binary_peer_connection_1.wrapBinaryPeer)(connectionId, rPeer, rPeerDevice, false, {
+                protocol: "wrtc",
+            });
+            await iPeerConnection.doHandshake(`wrtc://${connectionId}`);
             expect(rPeerConnection.remoteDeviceInfo).toBeDefined();
             expect(rPeerConnection.remoteDeviceInfo?.deviceId).toBe(iPeerDeviceId);
             expect(iPeerConnection.remoteDeviceInfo).toBeDefined();
@@ -96,7 +100,7 @@ describe('binary-peer-connection', () => {
             iPeer.destroy();
             rPeer.destroy();
         });
-        it('should set secureLocal/secureRemote when markTransportSecure is true', async () => {
+        it("should set secureLocal/secureRemote when markTransportSecure is true", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
             const userId = `00000000000000000user001`;
             const keys = (0, keys_1.newKeys)();
@@ -104,14 +108,14 @@ describe('binary-peer-connection', () => {
             const iPeerDeviceId = `000000000000000device001`;
             const iPeerDevice = new device_1.Device(userId, iPeerDeviceId, keys);
             const iPeerConnection = (0, binary_peer_connection_1.wrapBinaryPeer)(connectionId, iPeer, iPeerDevice, true, {
-                protocol: 'wrtc',
-                markTransportSecure: true
+                protocol: "wrtc",
+                markTransportSecure: true,
             });
             const rPeerDeviceId = `000000000000000device002`;
             const rPeerDevice = new device_1.Device(userId, rPeerDeviceId, keys);
             const rPeerConnection = (0, binary_peer_connection_1.wrapBinaryPeer)(connectionId, rPeer, rPeerDevice, false, {
-                protocol: 'wrtc',
-                markTransportSecure: true
+                protocol: "wrtc",
+                markTransportSecure: true,
             });
             expect(iPeerConnection.secureLocal).toBe(true);
             expect(iPeerConnection.secureRemote).toBe(true);
@@ -122,8 +126,8 @@ describe('binary-peer-connection', () => {
             rPeer.destroy();
         });
     });
-    describe('backwards compatibility', () => {
-        it('wrapWrtc should work as alias and set secure flags', async () => {
+    describe("backwards compatibility", () => {
+        it("wrapWrtc should work as alias and set secure flags", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
             const userId = `00000000000000000user001`;
             const keys = (0, keys_1.newKeys)();
@@ -137,14 +141,14 @@ describe('binary-peer-connection', () => {
             // wrapWrtc should set secure flags by default (transport-level encryption)
             expect(iPeerConnection.secureLocal).toBe(true);
             expect(iPeerConnection.secureRemote).toBe(true);
-            await iPeerConnection.doHandshake('wrtc://' + connectionId);
+            await iPeerConnection.doHandshake(`wrtc://${connectionId}`);
             expect(rPeerConnection.remoteDeviceInfo).toBeDefined();
             expect(rPeerConnection.remoteDeviceInfo?.deviceId).toBe(iPeerDeviceId);
             // Clean up
             iPeer.destroy();
             rPeer.destroy();
         });
-        it('binary peers should bypass StreamedSocket (handlesOwnEncoding)', async () => {
+        it("binary peers should bypass StreamedSocket (handlesOwnEncoding)", async () => {
             const { iPeer } = await getMockPeerPair();
             const userId = `00000000000000000user001`;
             const keys = (0, keys_1.newKeys)();

package/dist/device/connection.d.ts

@@ -1,7 +1,7 @@
-import { IDataBox } from "../keys";
-import { Device } from "./device";
-import { IDeviceHandshake, IDeviceInfo } from "../data";
-import { ISocket, TrustLevel } from "./socket.type";
+import type { IDeviceHandshake, IDeviceInfo } from "../data";
+import { type IDataBox } from "../keys";
+import type { Device } from "./device";
+import { type ISocket, TrustLevel } from "./socket.type";
 export type GetTrustLevel = (deviceInfo: IDeviceInfo, registerNew?: boolean) => Promise<TrustLevel>;
 export declare class Connection {
     readonly localDevice: Device;
@@ -11,7 +11,7 @@ export declare class Connection {
     private _remoteDeviceInfo;
     secureLocal: boolean;
     secureRemote: boolean;
-    overrideEncryption?: 'encrypt-traffic-regardless-of-protocol' | 'dont-encrypt-traffic-after-handshake';
+    overrideEncryption?: "encrypt-traffic-regardless-of-protocol" | "dont-encrypt-traffic-after-handshake";
     trustLevel: TrustLevel;
     onHandshakeComplete: ((deviceInfo: IDeviceInfo) => void) | undefined;
     timeoutMs: number;

package/dist/device/connection.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Connection = void 0;
 exports.normalizeAddress = normalizeAddress;
-const utils_1 = require("../utils");
 const keys_1 = require("../keys");
+const utils_1 = require("../utils");
 const socket_type_1 = require("./socket.type");
 const HANDSHAKE_TIMESTAMP_TOLERANCE_MS = 300_000; // 5 minutes
 class Connection {
@@ -12,10 +12,10 @@ class Connection {
     getTrustLevel;
     _verified = false;
     _remoteDeviceInfo = {
-        deviceId: '',
-        userId: '',
-        publicKey: '',
-        publicBoxKey: '',
+        deviceId: "",
+        userId: "",
+        publicKey: "",
+        publicBoxKey: "",
     };
     secureLocal = false;
     secureRemote = false;
@@ -41,27 +41,27 @@ class Connection {
             socket.id = (0, utils_1.newid)();
         }
         // Only the server side of a connection should expose these methods
-        this.exposeRPC('close', () => {
+        this.exposeRPC("close", () => {
             (0, utils_1.sleep)(100).then(() => {
                 this.closeLocal();
             });
         });
-        this.exposeRPC('ping', () => {
+        this.exposeRPC("ping", () => {
             return Date.now();
         });
         if (localDeviceServerAddresses) {
-            this.exposeRPC('reset', this.reset.bind(this));
-            this.exposeRPC('getTrustLevel', async (deviceInfo) => {
+            this.exposeRPC("reset", this.reset.bind(this));
+            this.exposeRPC("getTrustLevel", async (deviceInfo) => {
                 const trustLevel = await this.getTrustLevel(deviceInfo, false);
                 console.log(`Sending client trust level ${trustLevel}`);
                 return trustLevel;
             });
-            this.exposeRPC('requestDeviceInfo', this.localDevice.getDeviceInfo.bind(this.localDevice));
-            this.exposeRPC('completeHandshake', async (handshakeBox) => {
+            this.exposeRPC("requestDeviceInfo", this.localDevice.getDeviceInfo.bind(this.localDevice));
+            this.exposeRPC("completeHandshake", async (handshakeBox) => {
                 const handshakeResponse = await this.completeHandshake(handshakeBox);
                 return handshakeResponse;
             });
-            this.exposeRPC('requestSecure', () => {
+            this.exposeRPC("requestSecure", () => {
                 this.secureRemote = true;
                 return !this.encryptTraffic;
             });
@@ -82,10 +82,10 @@ class Connection {
      * - Insecure WebSockets (ws/http): Data travels over unencrypted channel
      */
     get encryptTraffic() {
-        if (this.overrideEncryption === 'dont-encrypt-traffic-after-handshake') {
+        if (this.overrideEncryption === "dont-encrypt-traffic-after-handshake") {
             return false;
         }
-        if (this.overrideEncryption === 'encrypt-traffic-regardless-of-protocol') {
+        if (this.overrideEncryption === "encrypt-traffic-regardless-of-protocol") {
             return true;
         }
         // Encrypt only if EITHER side is using an insecure protocol
@@ -95,7 +95,7 @@ class Connection {
         return { ...this._remoteDeviceInfo };
     }
     get connectionId() {
-        return this.socket.id || '';
+        return this.socket.id || "";
     }
     /**
      * Get connection throughput stats with calculated rates.
@@ -158,9 +158,9 @@ class Connection {
         };
     }
     exposeRPC(fn, name) {
-        if (typeof name === 'function') {
+        if (typeof name === "function") {
             const _fn = name;
-            // @ts-ignore
+            // @ts-expect-error
             name = fn;
             fn = _fn;
         }
@@ -188,7 +188,7 @@ class Connection {
                             err = this.localDevice.unwrapResponse(err);
                             return reject(err);
                         }
-                        if (eventName === 'requestSecure') {
+                        if (eventName === "requestSecure") {
                             this.secureRemote = this.localDevice.unwrapResponse(result);
                             result = this.secureRemote;
                         }
@@ -205,7 +205,7 @@ class Connection {
                 });
             }
             catch (e) {
-                if (typeof e?.message === 'string' && e.message.includes('bad public key size')) {
+                if (typeof e?.message === "string" && e.message.includes("bad public key size")) {
                     this.close();
                 }
                 console.error(`Error connection.emit for ${eventName}(${JSON.stringify(args)})`, e);
@@ -214,7 +214,13 @@ class Connection {
         });
     }
     on(eventName, handler) {
-        const safeEvents = ['requestDeviceInfo', 'completeHandshake', 'reset', 'getTrustLevel', 'close'];
+        const safeEvents = [
+            "requestDeviceInfo",
+            "completeHandshake",
+            "reset",
+            "getTrustLevel",
+            "close",
+        ];
         this.socket.on(eventName, async (args, callback) => {
             if (!this.verified && !safeEvents.includes(eventName)) {
                 console.error(`Ignoring event from unverified connection: ${eventName}`);
@@ -236,13 +242,13 @@ class Connection {
             }
             catch (e) {
                 console.error(`Error handling ${eventName}(${JSON.stringify(args)})`, e);
-                let rpcError = { error: e.message, errorType: 'RPC_ERROR' };
+                let rpcError = { error: e.message, errorType: "RPC_ERROR" };
                 if (this._verified && this.encryptTraffic) {
                     try {
                         rpcError = this.localDevice.signAndBoxDataForDevice(rpcError, this._remoteDeviceInfo);
                     }
                     catch (e) {
-                        console.error('Error signing and boxing RPC error', e);
+                        console.error("Error signing and boxing RPC error", e);
                     }
                 }
                 callback(rpcError);
@@ -255,10 +261,10 @@ class Connection {
     reset() {
         this._connectionAddress = undefined;
         this._remoteDeviceInfo = {
-            deviceId: '',
-            userId: '',
-            publicKey: '',
-            publicBoxKey: '',
+            deviceId: "",
+            userId: "",
+            publicKey: "",
+            publicBoxKey: "",
         };
         this._verified = false;
         this.secureLocal = false;
@@ -280,11 +286,12 @@ class Connection {
             throw new Error(`Remote device's system clock is too far out of sync`);
         }
         const clientServerAddress = normalizeAddress(signedHandshake.contents.serverAddress);
-        const thisServerAddress = this.localDeviceServerAddresses?.find(a => a === clientServerAddress) ||
+        const thisServerAddress = this.localDeviceServerAddresses?.find((a) => a === clientServerAddress) ||
             this.localDeviceServerAddresses?.[0] ||
-            'unknown';
+            "unknown";
         // only set local secure if the server address matches the client's address and the address is using https
-        this.secureLocal = clientServerAddress === thisServerAddress && thisServerAddress.startsWith('https');
+        this.secureLocal =
+            clientServerAddress === thisServerAddress && thisServerAddress.startsWith("https");
         this._connectionAddress = thisServerAddress;
         const handshakeResponse = this.localDevice.handshakeResponse(signedHandshake, this.connectionId, thisServerAddress);
         this._remoteDeviceInfo = {
@@ -296,8 +303,8 @@ class Connection {
         this.trustLevel = await this.getTrustLevel(signedHandshake.contents, true);
         if (this.trustLevel < socket_type_1.TrustLevel.Unknown) {
             this.reset();
-            this.emit('reset');
-            throw new Error('Untrusted connection');
+            this.emit("reset");
+            throw new Error("Untrusted connection");
         }
         // console.log(`Connection ${this.connectionId} verified on server side with trust level ${this.trustLevel}`);
         this._verified = true;
@@ -311,37 +318,41 @@ class Connection {
     async doHandshake(remoteAddress) {
         remoteAddress = normalizeAddress(remoteAddress);
         this.reset();
-        await this.emit('reset');
-        const remoteDeviceInfoSigned = await this.emit('requestDeviceInfo');
+        await this.emit("reset");
+        const remoteDeviceInfoSigned = await this.emit("requestDeviceInfo");
         const remoteDeviceInfo = (0, keys_1.openSignedObject)(remoteDeviceInfoSigned);
         if (remoteDeviceInfoSigned.publicKey !== remoteDeviceInfo.publicKey) {
-            throw new Error('Device info signing key does not match claimed identity key');
+            throw new Error("Device info signing key does not match claimed identity key");
         }
         const handshake = await this.initiateHandshake(remoteAddress, remoteDeviceInfo);
-        const handshakeResponseBox = await this.emit('completeHandshake', handshake);
+        const handshakeResponseBox = await this.emit("completeHandshake", handshake);
         const handshakeResponse = await this.localDevice.openBoxedAndSignedData(handshakeResponseBox);
         if (handshakeResponse.connectionId !== this.connectionId) {
             throw new Error(`Invalid connectionId ${handshakeResponse.connectionId}, expected ${this.connectionId}`);
         }
-        if (remoteDeviceInfo.publicKey != handshakeResponse.publicKey || remoteDeviceInfo.publicBoxKey != handshakeResponse.publicBoxKey) {
-            throw new Error('Inconsistent public keys');
+        if (remoteDeviceInfo.publicKey !== handshakeResponse.publicKey ||
+            remoteDeviceInfo.publicBoxKey !== handshakeResponse.publicBoxKey) {
+            throw new Error("Inconsistent public keys");
         }
-        if (remoteDeviceInfo.userId != handshakeResponse.userId || remoteDeviceInfo.deviceId != handshakeResponse.deviceId) {
-            throw new Error('Inconsistent device info');
+        if (remoteDeviceInfo.userId !== handshakeResponse.userId ||
+            remoteDeviceInfo.deviceId !== handshakeResponse.deviceId) {
+            throw new Error("Inconsistent device info");
         }
         this._verified = true;
         this._connectionAddress = remoteAddress;
-        const secureProtocols = ['https', 'wss', 'wrtc'];
+        const secureProtocols = ["https", "wss", "wrtc"];
         // const secureProtocols = ['https', 'wss',]
-        this.secureLocal = secureProtocols.some(s => remoteAddress.startsWith(s)) && handshakeResponse.serverAddress === remoteAddress;
+        this.secureLocal =
+            secureProtocols.some((s) => remoteAddress.startsWith(s)) &&
+                handshakeResponse.serverAddress === remoteAddress;
         if (this.secureLocal) {
-            await this.emit('requestSecure');
+            await this.emit("requestSecure");
         }
         this.trustLevel = await this.getTrustLevel(remoteDeviceInfo, true);
         if (this.trustLevel < socket_type_1.TrustLevel.Unknown) {
             this.reset();
-            this.emit('reset');
-            throw new Error('Untrusted connection');
+            this.emit("reset");
+            throw new Error("Untrusted connection");
         }
         // console.log(`Connection ${this.connectionId} (${remoteAddress}) verified on client side with trust level ${this.trustLevel}`);
         return handshakeResponse;
@@ -353,10 +364,10 @@ class Connection {
     }
     async ping() {
         if (!this._verified) {
-            throw new Error('Cannot ping unverified connection');
+            throw new Error("Cannot ping unverified connection");
         }
         const startTime = Date.now();
-        await this.emit('ping');
+        await this.emit("ping");
         return Date.now() - startTime;
     }
     closed = false;
@@ -365,7 +376,7 @@ class Connection {
             return;
         this.closed = true;
         await Promise.race([
-            this.emit('close').catch(err => {
+            this.emit("close").catch((_err) => {
                 // swallow error
                 // console.error('Error sending close event to remote device', err);
             }),
@@ -376,5 +387,5 @@ class Connection {
 }
 exports.Connection = Connection;
 function normalizeAddress(address) {
-    return address.toLowerCase().replace(/\/$/, '');
+    return address.toLowerCase().replace(/\/$/, "");
 }