@peers-app/peers-sdk 0.27.3 → 0.27.5

package/dist/device/device.test.js

@@ -1,243 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const data_1 = require("../data");
-const keys_1 = require("../keys");
-const utils_1 = require("../utils");
-const device_1 = require("./device");
-describe(device_1.Device, () => {
-    it("should create a new device with valid keys", async () => {
-        const userId = (0, utils_1.newid)();
-        const device = new device_1.Device(userId);
-        expect(device.userId).toBe(userId);
-        expect(device.deviceId).toBeTruthy();
-        expect(device.publicKey).toBeTruthy();
-        expect(device.publicBoxKey).toBeTruthy();
-        const msg = "Hello, World!";
-        const signedMsg = device.signMessageWithSecretKey(msg);
-        expect(signedMsg).toBeTruthy();
-        const openedMsg = (0, keys_1.openMessageWithPublicKey)(signedMsg, device.publicKey);
-        expect(openedMsg).toBe(msg);
-        const obj = { msg };
-        const signedObj = device.signObjectWithSecretKey(obj);
-        expect(signedObj.contents).toEqual(obj);
-        const openedObj = (0, keys_1.openSignedObject)(signedObj);
-        expect(openedObj).toEqual(obj);
-        const userId2 = (0, utils_1.newid)();
-        const device2 = new device_1.Device(userId2);
-        {
-            const box = device.boxDataWithKeys(obj, device2.publicBoxKey);
-            expect(box).toBeTruthy();
-            const openedBox = device2.openBoxWithSecretKey(box);
-            expect(openedBox).toEqual(obj);
-        }
-        {
-            const box = device.boxDataForDevice(obj, device2);
-            expect(box).toBeTruthy();
-            const openedBox = device2.openBoxWithSecretKey(box);
-            expect(openedBox).toEqual(obj);
-        }
-    });
-    describe("handshakes", () => {
-        const userId1 = (0, utils_1.newid)();
-        const client = new device_1.Device(userId1);
-        const userId2 = (0, utils_1.newid)();
-        const server = new device_1.Device(userId2);
-        describe("getHandshake", () => {
-            it("should return a valid and correct handshake object", async () => {
-                const connectionId = (0, utils_1.newid)();
-                const handshake = client.getHandshake(connectionId, "localhost");
-                expect(handshake.publicKey).toBe(client.publicKey);
-                expect(handshake.contents.userId).toBe(userId1);
-                expect(handshake.contents.publicKey).toBe(client.publicKey);
-                expect(handshake.contents.publicBoxKey).toBe(client.publicBoxKey);
-                expect(handshake.contents.connectionId).toBe(connectionId);
-            });
-            it("includes bounded display metadata and refreshes cached device info", () => {
-                const device = new device_1.Device((0, utils_1.newid)(), (0, utils_1.newid)(), (0, keys_1.newKeys)(), {
-                    userName: "Mark",
-                    deviceName: "Office laptop",
-                });
-                const originalInfo = device.getDeviceInfo();
-                expect(originalInfo.contents).toMatchObject({
-                    userName: "Mark",
-                    deviceName: "Office laptop",
-                });
-                device.setDisplayInfo({ userName: "Mark Archer", deviceName: "Kitchen display" });
-                const refreshedInfo = device.getDeviceInfo();
-                const handshake = device.getHandshake((0, utils_1.newid)(), "localhost");
-                expect(refreshedInfo).not.toBe(originalInfo);
-                expect(refreshedInfo.contents).toMatchObject({
-                    userName: "Mark Archer",
-                    deviceName: "Kitchen display",
-                });
-                expect(handshake.contents).toMatchObject({
-                    userName: "Mark Archer",
-                    deviceName: "Kitchen display",
-                });
-            });
-            it("bounds invalid local display metadata before signing it", () => {
-                const device = new device_1.Device((0, utils_1.newid)(), (0, utils_1.newid)(), (0, keys_1.newKeys)(), {
-                    deviceName: "x".repeat(data_1.DISPLAY_NAME_MAX_LENGTH + 1),
-                });
-                expect(device.getDeviceInfo().contents.deviceName).toHaveLength(data_1.DISPLAY_NAME_MAX_LENGTH);
-            });
-        });
-        describe("handshakeResponse", () => {
-            it("should return a valid and correct handshake response object", async () => {
-                const connectionId = (0, utils_1.newid)();
-                const handshake = client.getHandshake(connectionId, "localhost");
-                const handshakeResponse = server.handshakeResponse(handshake, connectionId, "localhost");
-                expect(handshakeResponse.userId).toBe(userId2);
-                expect(handshakeResponse.deviceId).toBe(server.deviceId);
-                expect(handshakeResponse.publicKey).toBe(server.publicKey);
-                expect(handshakeResponse.publicBoxKey).toBe(server.publicBoxKey);
-                expect(handshakeResponse.connectionId).toBe(connectionId);
-            });
-            it("should detect when requests and responses are being forwarded through a different connection", async () => {
-                const c1 = {
-                    connectionId: (0, utils_1.newid)(),
-                };
-                const c2 = {
-                    connectionId: (0, utils_1.newid)(),
-                };
-                const handshake = client.getHandshake(c1.connectionId, "localhost");
-                expect(() => server.handshakeResponse(handshake, c2.connectionId, "localhost")).toThrow(/Invalid connectionId/);
-            });
-            it("rejects signed handshake metadata that exceeds the display-name limit", () => {
-                const connectionId = (0, utils_1.newid)();
-                const handshake = client.signObjectWithSecretKey({
-                    connectionId,
-                    userId: client.userId,
-                    deviceId: client.deviceId,
-                    publicKey: client.publicKey,
-                    publicBoxKey: client.publicBoxKey,
-                    userName: "x".repeat(data_1.DISPLAY_NAME_MAX_LENGTH + 1),
-                    serverAddress: "localhost",
-                    timestamp: Date.now(),
-                });
-                expect(() => server.handshakeResponse(handshake, connectionId, "localhost")).toThrow();
-            });
-            it("should reject a handshake signed by a different key than the one claimed in the payload (key confusion)", async () => {
-                const connectionId = (0, utils_1.newid)();
-                // Imposter holds a random secret key but claims the real client's publicKey/publicBoxKey.
-                // getHandshake signs with the random key, so signedObj.publicKey != contents.publicKey.
-                const clientImposter = new device_1.Device(userId1, client.deviceId, {
-                    secretKey: (0, keys_1.newKeys)().secretKey,
-                    publicKey: client.publicKey,
-                    publicBoxKey: client.publicBoxKey,
-                });
-                const handshake = clientImposter.getHandshake(connectionId, "localhost");
-                expect(() => server.handshakeResponse(handshake, connectionId, "localhost")).toThrow(/signing key does not match claimed identity key/i);
-            });
-            it("should detect when requests and responses are being forwarded through a different address", async () => {
-                const connToServer = {
-                    connectionId: (0, utils_1.newid)(),
-                };
-                const _connToClient = {
-                    connectionId: connToServer.connectionId,
-                };
-                const _manInTheMiddle = new device_1.Device(userId2);
-                // const mitmAddress = manInTheMiddle.publicAddress || manInTheMiddle.localAddress;
-                // const connToManInTheMiddle = {
-                //   connectionId: connToServer.connectionId,
-                //   remoteAddress: mitmAddress
-                // };
-                // // client is being intercepted
-                // {
-                //   expect(() => {
-                //     doHandshake(client, connToManInTheMiddle, server, connToClient);
-                //   }).toThrow(/Invalid client address/);
-                // }
-                // // server is being intercepted
-                // {
-                //   expect(() => {
-                //     doHandshake(client, connToServer, server, connToManInTheMiddle);
-                //   }).toThrow(/Invalid server address/);
-                // }
-            });
-        });
-    });
-});
-/*
-describe(ServerDevice, () => {
-  describe("newConnection", () => {
-    it("should create a new connection with a valid server device and valid client device", async () => {
-      const serverDevice = new Device();
-      const server = new ServerDevice(serverDevice);
-
-      const clientDevice = new Device();
-
-      let conn = await server.newConnection(clientDevice.address);
-
-      // don't allow RPC calls to the server before the handshake is complete
-      {
-        const result: any = await conn.rpcCall('ping', {}).catch((err) => err);
-        expect(result?.message).toMatch(/Connection not verified/);
-      }
-
-      const handshakeSigned = clientDevice.getHandshake({ connectionId: conn.connectionId, remoteAddress: serverDevice.address });
-      const handshakeBoxed = clientDevice.boxDataForDevice(handshakeSigned, serverDevice);
-      const responseBox = await conn.completeHandshake(handshakeBoxed);
-      const responseSigned = clientDevice.openBoxWithSecretKey(responseBox);
-      const response = openSignedObject(responseSigned) as IDeviceHandshake;
-      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.localAddress).toBe(serverDevice.localAddress);
-      expect(response.publicAddress).toBe(serverDevice.publicAddress);
-      expect(response.connectionId).toBe(conn.connectionId);
-      expect(response.remoteAddress).toBe(clientDevice.address);
-
-      conn = await server.getConnection(conn.connectionId);
-
-      expect(conn.server).toEqual({
-        userId: serverDevice.userId,
-        deviceId: serverDevice.deviceId,
-        publicKey: serverDevice.publicKey,
-        publicBoxKey: serverDevice.publicBoxKey
-      });
-      expect(conn.client).toEqual({
-        userId: clientDevice.userId,
-        deviceId: clientDevice.deviceId,
-        publicKey: clientDevice.publicKey,
-        publicBoxKey: clientDevice.publicBoxKey
-      });
-      expect(conn.clientAddress).toBe(clientDevice.address);
-      expect(conn.secure).toBe(true);
-      expect(conn.verified).toBe(true);
-
-      // allow RPC calls to the server after the handshake is complete
-      {
-        const result: any = await conn.rpcCall('ping', {}).catch((err) => err);
-        expect(result).toBe('pong');
-      }
-    });
-
-    it("should leave connections as insecure if the remoteAddress doesn't match", async () => {
-      const serverDevice = new Device();
-      const server = new ServerDevice(serverDevice);
-
-      const clientDevice = new Device();
-
-      let conn = await server.newConnection(clientDevice.address);
-
-      const handshakeSigned = clientDevice.getHandshake({ connectionId: conn.connectionId, remoteAddress: 'using proxy' });
-      const handshakeBoxed = clientDevice.boxDataForDevice(handshakeSigned, serverDevice);
-      const responseBox = await conn.completeHandshake(handshakeBoxed);
-      const response = clientDevice.openBoxedAndSignedData(responseBox) as IDeviceHandshake;
-      expect(response.userId).toBe(serverDevice.userId);
-
-      conn = await server.getConnection(conn.connectionId);
-      
-      expect(conn.verified).toBe(true);
-      expect(conn.secure).toBe(false);
-
-      // confirm responses are signed and boxed
-      const resultBox = await conn.rpcCall('ping', {}).catch((err) => err) as IDataBox;
-      const result = clientDevice.openBoxedAndSignedData(resultBox);
-      expect(result).toBe('pong');
-    });
-  });
-})
-*/

package/dist/device/frame-cipher.test.d.ts

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

package/dist/device/frame-cipher.test.js

@@ -1,219 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const nacl = require("tweetnacl");
-const utils_1 = require("../utils");
-const frame_cipher_1 = require("./frame-cipher");
-function randomKey() {
-    return nacl.randomBytes(32);
-}
-function derivationParams() {
-    return {
-        ephemeralSharedSecret: nacl.randomBytes(32),
-        staticSharedSecret: nacl.randomBytes(32),
-        connectionId: (0, utils_1.newid)(),
-        clientDeviceId: (0, utils_1.newid)(),
-        serverDeviceId: (0, utils_1.newid)(),
-        timestamp: Date.now(),
-    };
-}
-function innerFrame(type, payload) {
-    const frame = new Uint8Array(1 + payload.length);
-    frame[0] = type;
-    frame.set(payload, 1);
-    return frame;
-}
-describe("frame-cipher", () => {
-    describe("seal / open", () => {
-        it("round-trips an inner frame with exactly FRAME_CIPHER_OVERHEAD bytes added", () => {
-            const key = randomKey();
-            const connectionId = (0, utils_1.newid)();
-            const sealer = new frame_cipher_1.FrameSealer(key.slice(), connectionId);
-            const opener = new frame_cipher_1.FrameOpener(key.slice(), connectionId);
-            const inner = innerFrame(0x10, new Uint8Array([1, 2, 3, 4, 5]));
-            const sealed = sealer.seal(inner);
-            expect(sealed[0]).toBe(frame_cipher_1.FRAME_ENC);
-            expect(sealed.length).toBe(inner.length + frame_cipher_1.FRAME_CIPHER_OVERHEAD);
-            expect(Buffer.from(opener.open(sealed) ?? [])).toEqual(Buffer.from(inner));
-        });
-        it("round-trips an empty inner frame and a large inner frame", () => {
-            const key = randomKey();
-            const { sealer, opener } = (0, frame_cipher_1.createFrameCiphers)({ sendKey: key.slice(), receiveKey: key.slice() }, "conn");
-            const empty = new Uint8Array(0);
-            expect(opener.open(sealer.seal(empty))?.length).toBe(0);
-            const large = new Uint8Array(512 * 1024);
-            for (let i = 0; i < large.length; i++)
-                large[i] = i % 251;
-            const opened = opener.open(sealer.seal(large));
-            expect(opened).not.toBeNull();
-            expect(Buffer.from(opened)).toEqual(Buffer.from(large));
-        });
-        it("does not leak the inner frame bytes on the wire", () => {
-            const key = randomKey();
-            const sealer = new frame_cipher_1.FrameSealer(key, "conn");
-            const marker = Buffer.from("SECRET-MARKER-0123456789abcdef");
-            const sealed = Buffer.from(sealer.seal(innerFrame(0x00, marker)));
-            expect(sealed.indexOf(marker)).toBe(-1);
-        });
-        it("fails to open with the wrong key", () => {
-            const sealer = new frame_cipher_1.FrameSealer(randomKey(), "conn");
-            const opener = new frame_cipher_1.FrameOpener(randomKey(), "conn");
-            expect(opener.open(sealer.seal(innerFrame(0x00, new Uint8Array([9]))))).toBeNull();
-        });
-        it("fails to open with the wrong connectionId (AAD)", () => {
-            const key = randomKey();
-            const sealer = new frame_cipher_1.FrameSealer(key.slice(), "conn-a");
-            const opener = new frame_cipher_1.FrameOpener(key.slice(), "conn-b");
-            expect(opener.open(sealer.seal(innerFrame(0x00, new Uint8Array([9]))))).toBeNull();
-        });
-        it("fails to open a frame sealed for the other direction", () => {
-            const derived = (0, frame_cipher_1.deriveFrameKeys)(derivationParams());
-            const client = (0, frame_cipher_1.createFrameCiphers)((0, frame_cipher_1.frameKeysForRole)(derived, "client"), "conn");
-            const server = (0, frame_cipher_1.createFrameCiphers)((0, frame_cipher_1.frameKeysForRole)(derived, "server"), "conn");
-            const sealed = client.sealer.seal(innerFrame(0x00, new Uint8Array([1])));
-            // The client's own opener holds the server-to-client key: wrong direction.
-            expect(client.opener.open(sealed)).toBeNull();
-            // The server's opener holds the client-to-server key and is at counter 0.
-            expect(server.opener.open(sealed)).not.toBeNull();
-        });
-        it("fails to open when a ciphertext bit is flipped", () => {
-            const key = randomKey();
-            const sealer = new frame_cipher_1.FrameSealer(key.slice(), "conn");
-            const opener = new frame_cipher_1.FrameOpener(key.slice(), "conn");
-            const sealed = sealer.seal(innerFrame(0x00, new Uint8Array([1, 2, 3])));
-            sealed[2] ^= 0x01;
-            expect(opener.open(sealed)).toBeNull();
-        });
-        it("fails to open when the tag is truncated or the type byte is wrong", () => {
-            const key = randomKey();
-            const sealer = new frame_cipher_1.FrameSealer(key.slice(), "conn");
-            const sealed = sealer.seal(innerFrame(0x00, new Uint8Array([1, 2, 3])));
-            expect(new frame_cipher_1.FrameOpener(key.slice(), "conn").open(sealed.subarray(0, sealed.length - 1))).toBeNull();
-            expect(new frame_cipher_1.FrameOpener(key.slice(), "conn").open(new Uint8Array([frame_cipher_1.FRAME_ENC]))).toBeNull();
-            const wrongType = sealed.slice();
-            wrongType[0] = 0x00;
-            expect(new frame_cipher_1.FrameOpener(key.slice(), "conn").open(wrongType)).toBeNull();
-        });
-        it("fails to open a replayed frame because the receive counter has advanced", () => {
-            const key = randomKey();
-            const sealer = new frame_cipher_1.FrameSealer(key.slice(), "conn");
-            const opener = new frame_cipher_1.FrameOpener(key.slice(), "conn");
-            const sealed = sealer.seal(innerFrame(0x00, new Uint8Array([7])));
-            expect(opener.open(sealed)).not.toBeNull();
-            expect(opener.open(sealed)).toBeNull();
-        });
-        it("fails to open frames delivered out of order", () => {
-            const key = randomKey();
-            const sealer = new frame_cipher_1.FrameSealer(key.slice(), "conn");
-            const opener = new frame_cipher_1.FrameOpener(key.slice(), "conn");
-            sealer.seal(innerFrame(0x00, new Uint8Array([1]))); // frame 0, never delivered
-            const second = sealer.seal(innerFrame(0x00, new Uint8Array([2])));
-            expect(opener.open(second)).toBeNull();
-        });
-        it("advances counters independently per direction", () => {
-            const derived = (0, frame_cipher_1.deriveFrameKeys)(derivationParams());
-            const client = (0, frame_cipher_1.createFrameCiphers)((0, frame_cipher_1.frameKeysForRole)(derived, "client"), "conn");
-            const server = (0, frame_cipher_1.createFrameCiphers)((0, frame_cipher_1.frameKeysForRole)(derived, "server"), "conn");
-            for (let i = 0; i < 5; i++) {
-                const opened = server.opener.open(client.sealer.seal(innerFrame(0x00, new Uint8Array([i]))));
-                expect(opened?.[1]).toBe(i);
-            }
-            expect(client.sealer.count).toBe(5);
-            expect(server.opener.count).toBe(5);
-            expect(server.sealer.count).toBe(0);
-            expect(client.opener.count).toBe(0);
-            const back = client.opener.open(server.sealer.seal(innerFrame(0x00, new Uint8Array([42]))));
-            expect(back?.[1]).toBe(42);
-            expect(server.sealer.count).toBe(1);
-            expect(client.opener.count).toBe(1);
-        });
-        it("produces different ciphertext for identical plaintext on consecutive frames", () => {
-            const sealer = new frame_cipher_1.FrameSealer(randomKey(), "conn");
-            const inner = innerFrame(0x00, new Uint8Array([1, 2, 3, 4]));
-            const a = Buffer.from(sealer.seal(inner));
-            const b = Buffer.from(sealer.seal(inner));
-            expect(a.equals(b)).toBe(false);
-        });
-        it("rejects keys of the wrong length", () => {
-            expect(() => new frame_cipher_1.FrameSealer(new Uint8Array(16), "conn")).toThrow(/32 bytes/);
-            expect(() => new frame_cipher_1.FrameOpener(new Uint8Array(31), "conn")).toThrow(/32 bytes/);
-        });
-    });
-    describe("deriveFrameKeys", () => {
-        it("is symmetric: both peers derive identical directional keys", () => {
-            const params = derivationParams();
-            const a = (0, frame_cipher_1.deriveFrameKeys)({ ...params });
-            const b = (0, frame_cipher_1.deriveFrameKeys)({ ...params });
-            expect(Buffer.from(a.clientToServer)).toEqual(Buffer.from(b.clientToServer));
-            expect(Buffer.from(a.serverToClient)).toEqual(Buffer.from(b.serverToClient));
-            expect(Buffer.from(a.clientToServer).equals(Buffer.from(a.serverToClient))).toBe(false);
-        });
-        it("maps roles onto directions so client.send == server.receive", () => {
-            const derived = (0, frame_cipher_1.deriveFrameKeys)(derivationParams());
-            const client = (0, frame_cipher_1.frameKeysForRole)(derived, "client");
-            const server = (0, frame_cipher_1.frameKeysForRole)(derived, "server");
-            expect(Buffer.from(client.sendKey)).toEqual(Buffer.from(server.receiveKey));
-            expect(Buffer.from(client.receiveKey)).toEqual(Buffer.from(server.sendKey));
-        });
-        it("changes with every input", () => {
-            const base = derivationParams();
-            const reference = (0, frame_cipher_1.deriveFrameKeys)(base);
-            const variants = [
-                { ephemeralSharedSecret: nacl.randomBytes(32) },
-                { staticSharedSecret: nacl.randomBytes(32) },
-                { connectionId: (0, utils_1.newid)() },
-                { clientDeviceId: (0, utils_1.newid)() },
-                { serverDeviceId: (0, utils_1.newid)() },
-                { timestamp: base.timestamp + 1 },
-            ];
-            for (const variant of variants) {
-                const derived = (0, frame_cipher_1.deriveFrameKeys)({ ...base, ...variant });
-                expect(Buffer.from(derived.clientToServer).equals(Buffer.from(reference.clientToServer))).toBe(false);
-                expect(Buffer.from(derived.serverToClient).equals(Buffer.from(reference.serverToClient))).toBe(false);
-            }
-        });
-        it("distinguishes swapped device IDs", () => {
-            const base = derivationParams();
-            const a = (0, frame_cipher_1.deriveFrameKeys)(base);
-            const b = (0, frame_cipher_1.deriveFrameKeys)({
-                ...base,
-                clientDeviceId: base.serverDeviceId,
-                serverDeviceId: base.clientDeviceId,
-            });
-            expect(Buffer.from(a.clientToServer).equals(Buffer.from(b.clientToServer))).toBe(false);
-        });
-        it("rejects malformed inputs", () => {
-            const base = derivationParams();
-            expect(() => (0, frame_cipher_1.deriveFrameKeys)({ ...base, ephemeralSharedSecret: new Uint8Array(31) })).toThrow(/32-byte/);
-            expect(() => (0, frame_cipher_1.deriveFrameKeys)({ ...base, connectionId: "" })).toThrow(/connectionId/);
-            expect(() => (0, frame_cipher_1.deriveFrameKeys)({ ...base, timestamp: -1 })).toThrow(/timestamp/);
-            expect(() => (0, frame_cipher_1.deriveFrameKeys)({ ...base, timestamp: 1.5 })).toThrow(/timestamp/);
-        });
-        it("works end to end with real X25519 shared secrets", () => {
-            const clientEph = nacl.box.keyPair();
-            const serverEph = nacl.box.keyPair();
-            const clientStatic = nacl.box.keyPair();
-            const serverStatic = nacl.box.keyPair();
-            const common = {
-                connectionId: (0, utils_1.newid)(),
-                clientDeviceId: (0, utils_1.newid)(),
-                serverDeviceId: (0, utils_1.newid)(),
-                timestamp: Date.now(),
-            };
-            const clientKeys = (0, frame_cipher_1.frameKeysForRole)((0, frame_cipher_1.deriveFrameKeys)({
-                ...common,
-                ephemeralSharedSecret: nacl.scalarMult(clientEph.secretKey, serverEph.publicKey),
-                staticSharedSecret: nacl.scalarMult(clientStatic.secretKey, serverStatic.publicKey),
-            }), "client");
-            const serverKeys = (0, frame_cipher_1.frameKeysForRole)((0, frame_cipher_1.deriveFrameKeys)({
-                ...common,
-                ephemeralSharedSecret: nacl.scalarMult(serverEph.secretKey, clientEph.publicKey),
-                staticSharedSecret: nacl.scalarMult(serverStatic.secretKey, clientStatic.publicKey),
-            }), "server");
-            const client = (0, frame_cipher_1.createFrameCiphers)(clientKeys, common.connectionId);
-            const server = (0, frame_cipher_1.createFrameCiphers)(serverKeys, common.connectionId);
-            const inner = innerFrame(0x11, Buffer.from("hello over x25519"));
-            expect(Buffer.from(server.opener.open(client.sealer.seal(inner)) ?? [])).toEqual(Buffer.from(inner));
-            expect(Buffer.from(client.opener.open(server.sealer.seal(inner)) ?? [])).toEqual(Buffer.from(inner));
-        });
-    });
-});

package/dist/device/get-trust-level-fn.test.d.ts

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