@peers-app/peers-sdk 0.27.2 → 0.27.4

package/dist/device/streamed-socket.test.d.ts

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

package/dist/device/streamed-socket.test.js

@@ -1,216 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const msgpack_1 = require("@msgpack/msgpack");
-const utils_1 = require("../utils");
-const streamed_socket_1 = require("./streamed-socket");
-const tx_encoding_1 = require("./tx-encoding");
-// Helper to decode the binary chunk format
-function decodeChunk(bytes) {
-    const view = new DataView(bytes.buffer, bytes.byteOffset);
-    const metadataLength = view.getUint32(0, false);
-    const metadataBytes = bytes.subarray(4, 4 + metadataLength);
-    const metadata = (0, msgpack_1.decode)(metadataBytes);
-    const data = bytes.subarray(4 + metadataLength);
-    return { ...metadata, data };
-}
-function createMockSocket() {
-    const emittedEvents = [];
-    const socket = {
-        id: (0, utils_1.newid)(),
-        emit(eventName, args, callback) {
-            emittedEvents.push({ eventName, args, callback });
-        },
-        on(_eventName, _handler) {
-            // Simple mock - we'll manually trigger events in tests
-        },
-        removeAllListeners(_eventName) {
-            // Simple mock
-        },
-        disconnect() {
-            // Simple mock - we'll assume the socket is disconnected
-        },
-    };
-    return {
-        socket,
-        getEmittedEvents: () => emittedEvents,
-    };
-}
-describe("StreamedSocket", () => {
-    it("should emit a single chunk for small messages", () => {
-        const mock = createMockSocket();
-        const streamedSocket = new streamed_socket_1.StreamedSocket(mock.socket, 1000); // Large chunk size
-        const testData = { message: "hello" };
-        streamedSocket.emit("test-event", testData, () => { });
-        // Should emit a single chunk
-        const emittedEvents = mock.getEmittedEvents();
-        expect(emittedEvents).toHaveLength(1);
-        const chunkEvent = emittedEvents[0];
-        expect(chunkEvent.eventName).toBe("__streamed-socket-chunk");
-        // Args should be a Uint8Array (binary encoded chunk)
-        expect(chunkEvent.args).toBeInstanceOf(Uint8Array);
-        // Decode the binary chunk
-        const decodedChunk = decodeChunk(chunkEvent.args);
-        expect(decodedChunk.messageId).toBeTruthy();
-        expect(decodedChunk.chunkIndex).toBe(0);
-        expect(decodedChunk.totalChunks).toBe(1);
-        expect(decodedChunk.eventName).toBe("test-event");
-        // Decode the actual data
-        const decoded = (0, tx_encoding_1.txDecode)(decodedChunk.data);
-        expect(decoded).toEqual(testData);
-    });
-    it("should emit multiple chunks for large messages", () => {
-        const mock = createMockSocket();
-        const streamedSocket = new streamed_socket_1.StreamedSocket(mock.socket, 256); // Small chunk size to force chunking
-        // Create a large test object
-        const testData = {
-            message: "x".repeat(200),
-            array: [1, 2, 3, 4, 5],
-            nested: { deep: "value" },
-        };
-        streamedSocket.emit("test-event", testData, () => { });
-        const emittedEvents = mock.getEmittedEvents();
-        expect(emittedEvents.length).toBeGreaterThan(1);
-        // Decode all chunks
-        const decodedChunks = emittedEvents.map((event) => {
-            expect(event.args).toBeInstanceOf(Uint8Array);
-            return decodeChunk(event.args);
-        });
-        // Verify first chunk has metadata
-        const firstChunk = decodedChunks[0];
-        expect(firstChunk.eventName).toBe("test-event");
-        expect(firstChunk.totalChunks).toBe(emittedEvents.length);
-        expect(firstChunk.chunkIndex).toBe(0);
-        // Verify all chunks have the same messageId
-        const messageId = firstChunk.messageId;
-        decodedChunks.forEach((chunk) => {
-            expect(chunk.messageId).toBe(messageId);
-        });
-        // Verify chunks are in order
-        decodedChunks.forEach((chunk, index) => {
-            expect(chunk.chunkIndex).toBe(index);
-        });
-        // Verify all chunk data are Uint8Arrays
-        decodedChunks.forEach((chunk) => {
-            expect(chunk.data).toBeInstanceOf(Uint8Array);
-        });
-        // Reassemble chunks and verify data integrity
-        const reassembled = new Uint8Array(decodedChunks.reduce((sum, chunk) => sum + chunk.data.length, 0));
-        let offset = 0;
-        for (const chunk of decodedChunks) {
-            reassembled.set(chunk.data, offset);
-            offset += chunk.data.length;
-        }
-        const decoded = (0, tx_encoding_1.txDecode)(reassembled);
-        expect(decoded).toEqual(testData);
-    });
-    it("should handle binary data in messages", () => {
-        const mock = createMockSocket();
-        const streamedSocket = new streamed_socket_1.StreamedSocket(mock.socket, 1000);
-        const testData = {
-            binaryData: new Uint8Array([1, 2, 3, 4, 5]),
-            metadata: { name: "test" },
-        };
-        streamedSocket.emit("test-event", testData, () => { });
-        const emittedEvents = mock.getEmittedEvents();
-        expect(emittedEvents).toHaveLength(1);
-        const decodedChunk = decodeChunk(emittedEvents[0].args);
-        const decoded = (0, tx_encoding_1.txDecode)(decodedChunk.data);
-        expect(decoded.binaryData).toBeInstanceOf(Uint8Array);
-        expect(decoded.binaryData).toEqual(testData.binaryData);
-        expect(decoded.metadata).toEqual(testData.metadata);
-    });
-    it("should handle special types in messages", () => {
-        const mock = createMockSocket();
-        const streamedSocket = new streamed_socket_1.StreamedSocket(mock.socket, 1000);
-        const testData = {
-            date: new Date("2023-01-01T00:00:00.000Z"),
-            nan: NaN,
-            infinity: Infinity,
-            undef: undefined,
-            nullVal: null,
-        };
-        streamedSocket.emit("test-event", testData, () => { });
-        const emittedEvents = mock.getEmittedEvents();
-        expect(emittedEvents).toHaveLength(1);
-        const decodedChunk = decodeChunk(emittedEvents[0].args);
-        const decoded = (0, tx_encoding_1.txDecode)(decodedChunk.data);
-        expect(decoded.date).toBeInstanceOf(Date);
-        expect(decoded.date.toISOString()).toBe("2023-01-01T00:00:00.000Z");
-        expect(Number.isNaN(decoded.nan)).toBe(true);
-        expect(decoded.infinity).toBe(Infinity);
-        expect(decoded.undef).toBeUndefined();
-        expect(decoded.nullVal).toBeNull();
-    });
-    it("should demonstrate msgpack efficiency: structured data vs JSON string (uncompressed)", () => {
-        const mock1 = createMockSocket();
-        const mock2 = createMockSocket();
-        const streamedSocket1 = new streamed_socket_1.StreamedSocket(mock1.socket, 1000000); // Large chunk to avoid splitting
-        const streamedSocket2 = new streamed_socket_1.StreamedSocket(mock2.socket, 1000000);
-        // Create a small structured object that won't trigger compression (< 1024 bytes)
-        const smallObject = {
-            users: Array.from({ length: 5 }, (_, i) => ({
-                id: i + 1000000, // Use larger numbers to make JSON less compressible
-                name: `User${i}_${Math.random().toString(36).substring(7)}`, // Add randomness
-                email: `user${i}@example.com`,
-                score: Math.random() * 1000,
-                active: i % 2 === 0,
-            })),
-        };
-        // Convert to JSON string
-        const jsonString = JSON.stringify(smallObject);
-        console.log(`Original JSON string size: ${jsonString.length} bytes`);
-        // Send as structured object (msgpack can optimize)
-        streamedSocket1.emit("test-object", smallObject, () => { });
-        // Send as JSON string (msgpack treats it as opaque string)
-        streamedSocket2.emit("test-string", { jsonPayload: jsonString }, () => { });
-        const objectEvents = mock1.getEmittedEvents();
-        const stringEvents = mock2.getEmittedEvents();
-        expect(objectEvents).toHaveLength(1);
-        expect(stringEvents).toHaveLength(1);
-        // Decode and measure sizes
-        const objectChunk = decodeChunk(objectEvents[0].args);
-        const stringChunk = decodeChunk(stringEvents[0].args);
-        const objectSize = objectChunk.data.length;
-        const stringSize = stringChunk.data.length;
-        console.log(`Msgpack with structured data: ${objectSize} bytes (${((1 - objectSize / jsonString.length) * 100).toFixed(1)}% reduction from JSON)`);
-        console.log(`Msgpack with JSON string: ${stringSize} bytes (${((1 - stringSize / jsonString.length) * 100).toFixed(1)}% reduction from JSON)`);
-        console.log(`Efficiency gain: structured data is ${((1 - objectSize / stringSize) * 100).toFixed(1)}% smaller than JSON string`);
-        // Msgpack should be more efficient with structured data than with a JSON string
-        expect(objectSize).toBeLessThan(stringSize);
-        // Structured data should be at least 10% more efficient
-        const efficiency = (1 - objectSize / stringSize) * 100;
-        expect(efficiency).toBeGreaterThan(10);
-        // Verify data integrity
-        const decodedObject = (0, tx_encoding_1.txDecode)(objectChunk.data);
-        const decodedString = (0, tx_encoding_1.txDecode)(stringChunk.data);
-        expect(decodedObject.users).toHaveLength(5);
-        expect(decodedString.jsonPayload).toBe(jsonString);
-    });
-    it("should demonstrate compression effectiveness for large repetitive data", () => {
-        const mock = createMockSocket();
-        const streamedSocket = new streamed_socket_1.StreamedSocket(mock.socket, 1000000);
-        // Create large repetitive object that will compress well
-        const largeObject = {
-            data: Array.from({ length: 200 }, () => ({
-                type: "event",
-                status: "active",
-                category: "user_action",
-                timestamp: new Date("2024-01-01"),
-                metadata: { app: "test", version: "1.0.0" },
-            })),
-        };
-        const jsonString = JSON.stringify(largeObject);
-        console.log(`Large repetitive data - JSON size: ${jsonString.length} bytes`);
-        streamedSocket.emit("test-compressed", largeObject, () => { });
-        const events = mock.getEmittedEvents();
-        const chunk = decodeChunk(events[0].args);
-        console.log(`After msgpack + compression: ${chunk.data.length} bytes`);
-        console.log(`Compression ratio: ${((1 - chunk.data.length / jsonString.length) * 100).toFixed(1)}% reduction`);
-        // Should achieve significant compression (>80% reduction)
-        expect(chunk.data.length).toBeLessThan(jsonString.length * 0.2);
-        // Verify data integrity
-        const decoded = (0, tx_encoding_1.txDecode)(chunk.data);
-        expect(decoded.data).toHaveLength(200);
-        expect(decoded.data[0].type).toBe("event");
-    });
-});

package/dist/device/tx-encoding.test.d.ts

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

package/dist/device/tx-encoding.test.js

@@ -1,295 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const msgpack_1 = require("@msgpack/msgpack");
-const serial_json_1 = require("../serial-json");
-const tx_encoding_1 = require("./tx-encoding");
-describe("tx-encode-decode", () => {
-    describe("txEncode and txDecode", () => {
-        it("should encode and decode simple objects", () => {
-            const testObj = {
-                name: "test",
-                number: 42,
-                bool: true,
-                str: "hello world",
-            };
-            const encoded = (0, tx_encoding_1.txEncode)(testObj);
-            expect(encoded).toBeInstanceOf(Uint8Array);
-            expect(encoded.length).toBeGreaterThan(0);
-            const decoded = (0, tx_encoding_1.txDecode)(encoded);
-            expect(decoded).toEqual(testObj);
-        });
-        it("should encode and decode arrays", () => {
-            const testArray = [1, 2, 3, "four", { five: 5 }];
-            const encoded = (0, tx_encoding_1.txEncode)(testArray);
-            const decoded = (0, tx_encoding_1.txDecode)(encoded);
-            expect(decoded).toEqual(testArray);
-        });
-        it("should encode and decode nested objects", () => {
-            const testObj = {
-                level1: {
-                    level2: {
-                        level3: {
-                            value: "deep nested value",
-                            number: 123,
-                        },
-                        array: [1, 2, 3],
-                    },
-                },
-            };
-            const encoded = (0, tx_encoding_1.txEncode)(testObj);
-            const decoded = (0, tx_encoding_1.txDecode)(encoded);
-            expect(decoded).toEqual(testObj);
-        });
-        it("should encode and decode special types (dates, etc.)", () => {
-            const testObj = {
-                date: new Date("2023-01-01T00:00:00.000Z"),
-                nan: NaN,
-                infinity: Infinity,
-                negInfinity: -Infinity,
-                undef: undefined,
-                nullVal: null,
-            };
-            const encoded = (0, tx_encoding_1.txEncode)(testObj);
-            const decoded = (0, tx_encoding_1.txDecode)(encoded);
-            expect(decoded.date).toBeInstanceOf(Date);
-            expect(decoded.date.toISOString()).toBe("2023-01-01T00:00:00.000Z");
-            expect(Number.isNaN(decoded.nan)).toBe(true);
-            expect(decoded.infinity).toBe(Infinity);
-            expect(decoded.negInfinity).toBe(-Infinity);
-            expect(decoded.undef).toBeUndefined();
-            expect(decoded.nullVal).toBeNull();
-        });
-        it("should encode and decode Uint8Array", () => {
-            const testObj = {
-                data: new Uint8Array([72, 101, 108, 108, 111]),
-                metadata: { size: 5 },
-            };
-            const encoded = (0, tx_encoding_1.txEncode)(testObj);
-            const decoded = (0, tx_encoding_1.txDecode)(encoded);
-            expect(decoded.data).toBeInstanceOf(Uint8Array);
-            expect(decoded.data).toEqual(testObj.data);
-            expect(decoded.metadata).toEqual(testObj.metadata);
-        });
-        it("should encode and decode Buffer", () => {
-            const testObj = {
-                buffer: Buffer.from("Hello Buffer"),
-                name: "test",
-            };
-            const encoded = (0, tx_encoding_1.txEncode)(testObj);
-            const decoded = (0, tx_encoding_1.txDecode)(encoded);
-            expect(Buffer.isBuffer(decoded.buffer)).toBe(true);
-            expect(decoded.buffer).toEqual(testObj.buffer);
-            expect(decoded.name).toBe("test");
-        });
-    });
-    describe("compression threshold", () => {
-        it("should not compress small payloads (< 1024 bytes)", () => {
-            const smallObj = { message: "small" };
-            const encoded = (0, tx_encoding_1.txEncode)(smallObj);
-            // First byte is the flag
-            expect(encoded[0]).toBe(0); // flag = 0 means not compressed
-        });
-        it("should compress large payloads (> 1024 bytes)", () => {
-            // Create an object that will exceed 8KB when msgpack-encoded
-            // msgpack is more compact than JSON, so we need significantly more data
-            // A string of 20,000 chars is roughly 20KB in JSON, but msgpack uses length prefix + bytes
-            // So we need even more to ensure msgpack encoding exceeds 8KB
-            const largeObj = {
-                data: "x".repeat(30000),
-                array: Array.from({ length: 1000 }, (_, i) => ({
-                    id: i,
-                    value: `item ${i} with some extra text to make it larger and ensure we exceed the threshold`,
-                    nested: { prop: `nested value ${i}` },
-                })),
-            };
-            const encoded = (0, tx_encoding_1.txEncode)(largeObj);
-            // Verify the encoded size (without flag byte) exceeds 8KB threshold
-            const encodedSize = encoded.length - 1; // subtract flag byte
-            expect(encodedSize).toBeGreaterThan(8 * 1024);
-            // First byte is the flag
-            expect(encoded[0]).toBe(1); // flag = 1 means compressed
-            // Verify it can still be decoded correctly
-            const decoded = (0, tx_encoding_1.txDecode)(encoded);
-            expect(decoded).toEqual(largeObj);
-        });
-        it("should have smaller encoded size for large compressible data", () => {
-            // Create data that exceeds 8KB when msgpack-encoded and compresses well
-            // Use data with some repetition but also enough variety to ensure msgpack size is large
-            const largeRepetitiveObj = {
-                data: "repeat ".repeat(10000), // Highly repetitive string - will compress well
-                values: Array.from({ length: 5000 }, (_, i) => `item ${i} with some text that repeats to create compressible data pattern`),
-            };
-            // First, verify the msgpack-encoded size exceeds 8KB threshold
-            const noCycles = (0, serial_json_1.toJSON)(largeRepetitiveObj);
-            const msgpackEncoded = (0, msgpack_1.encode)(noCycles);
-            expect(msgpackEncoded.length).toBeGreaterThan(8 * 1024);
-            const encoded = (0, tx_encoding_1.txEncode)(largeRepetitiveObj);
-            // Verify compression flag is set (means compression was applied)
-            expect(encoded[0]).toBe(1); // flag = 1 means compressed
-            // Compressed size should be significantly smaller than the raw msgpack data
-            const compressedSize = encoded.length - 1; // subtract flag byte
-            expect(compressedSize).toBeLessThan(msgpackEncoded.length * 0.8); // Should be at least 20% smaller
-            // Verify correctness
-            const decoded = (0, tx_encoding_1.txDecode)(encoded);
-            expect(decoded).toEqual(largeRepetitiveObj);
-        });
-    });
-    describe("error handling", () => {
-        it("should throw error on empty payload", () => {
-            const emptyPayload = new Uint8Array(0);
-            expect(() => (0, tx_encoding_1.txDecode)(emptyPayload)).toThrow("Empty payload");
-        });
-        it("should throw error on unknown flag", () => {
-            // Create a payload with an invalid flag (2)
-            const invalidPayload = new Uint8Array([2, 0, 0, 0]);
-            expect(() => (0, tx_encoding_1.txDecode)(invalidPayload)).toThrow("Unknown tx flag: 2");
-        });
-        it("should throw error on unknown flag (255)", () => {
-            const invalidPayload = new Uint8Array([255, 0, 0, 0]);
-            expect(() => (0, tx_encoding_1.txDecode)(invalidPayload)).toThrow("Unknown tx flag: 255");
-        });
-    });
-    describe("untrusted input", () => {
-        afterEach(() => {
-            delete Object.prototype.polluted;
-        });
-        it("does not let a decoded message write onto Object.prototype", () => {
-            const decoded = (0, tx_encoding_1.txDecode)((0, tx_encoding_1.txEncode)({ __this_ref: "__proto__", polluted: "yes" }));
-            expect({}.polluted).toBeUndefined();
-            expect(decoded).toEqual({ polluted: "yes" });
-        });
-    });
-    describe("round-trip consistency", () => {
-        it("should handle empty objects", () => {
-            const emptyObj = {};
-            const encoded = (0, tx_encoding_1.txEncode)(emptyObj);
-            const decoded = (0, tx_encoding_1.txDecode)(encoded);
-            expect(decoded).toEqual(emptyObj);
-        });
-        it("should handle empty arrays", () => {
-            const emptyArray = [];
-            const encoded = (0, tx_encoding_1.txEncode)(emptyArray);
-            const decoded = (0, tx_encoding_1.txDecode)(encoded);
-            expect(decoded).toEqual(emptyArray);
-        });
-        it("should handle strings with special characters", () => {
-            const testObj = {
-                emoji: "🚀🎉",
-                unicode: "Hello 世界",
-                special: "line1\nline2\ttab",
-                quotes: 'He said "hello"',
-            };
-            const encoded = (0, tx_encoding_1.txEncode)(testObj);
-            const decoded = (0, tx_encoding_1.txDecode)(encoded);
-            expect(decoded).toEqual(testObj);
-        });
-        it("should handle very large numbers", () => {
-            const testObj = {
-                maxSafeInt: Number.MAX_SAFE_INTEGER,
-                minSafeInt: Number.MIN_SAFE_INTEGER,
-                large: 9007199254740991,
-                small: -9007199254740991,
-            };
-            const encoded = (0, tx_encoding_1.txEncode)(testObj);
-            const decoded = (0, tx_encoding_1.txDecode)(encoded);
-            expect(decoded).toEqual(testObj);
-        });
-        it("should handle mixed type arrays", () => {
-            const testArray = [
-                1,
-                "string",
-                true,
-                null,
-                undefined,
-                { obj: "value" },
-                [1, 2, 3],
-                new Date("2023-01-01"),
-                new Uint8Array([1, 2, 3]),
-            ];
-            const encoded = (0, tx_encoding_1.txEncode)(testArray);
-            const decoded = (0, tx_encoding_1.txDecode)(encoded);
-            expect(decoded[0]).toBe(1);
-            expect(decoded[1]).toBe("string");
-            expect(decoded[2]).toBe(true);
-            expect(decoded[3]).toBeNull();
-            expect(decoded[4]).toBeUndefined();
-            expect(decoded[5]).toEqual({ obj: "value" });
-            expect(decoded[6]).toEqual([1, 2, 3]);
-            expect(decoded[7]).toBeInstanceOf(Date);
-            expect(decoded[8]).toBeInstanceOf(Uint8Array);
-            expect(decoded[8]).toEqual(new Uint8Array([1, 2, 3]));
-        });
-        it("should handle objects with circular references removed by toJSON", () => {
-            // toJSON handles circular references, so this should work
-            const obj = { name: "test" };
-            obj.self = obj; // circular reference
-            const encoded = (0, tx_encoding_1.txEncode)(obj);
-            const decoded = (0, tx_encoding_1.txDecode)(encoded);
-            // The circular reference should be handled by toJSON/fromJSON
-            expect(decoded).toHaveProperty("name", "test");
-            expect(decoded).toHaveProperty("self");
-            expect(decoded.self).toBe(decoded); // self-reference restored
-        });
-        it("should preserve data integrity across multiple encode/decode cycles", () => {
-            const original = {
-                id: 123,
-                name: "multi-cycle test",
-                data: new Uint8Array([1, 2, 3, 4, 5]),
-                timestamp: new Date("2023-06-15T12:00:00.000Z"),
-            };
-            // Encode and decode multiple times
-            let current = original;
-            for (let i = 0; i < 5; i++) {
-                const encoded = (0, tx_encoding_1.txEncode)(current);
-                current = (0, tx_encoding_1.txDecode)(encoded);
-            }
-            expect(current.id).toBe(original.id);
-            expect(current.name).toBe(original.name);
-            expect(current.data).toEqual(original.data);
-            expect(current.timestamp).toEqual(original.timestamp);
-        });
-    });
-    describe("payload structure", () => {
-        it("should have flag byte as first byte", () => {
-            const testObj = { test: "value" };
-            const encoded = (0, tx_encoding_1.txEncode)(testObj);
-            // First byte should be 0 or 1
-            expect(encoded[0]).toBeGreaterThanOrEqual(0);
-            expect(encoded[0]).toBeLessThanOrEqual(1);
-        });
-        it("should have body after flag byte", () => {
-            const testObj = { test: "value" };
-            const encoded = (0, tx_encoding_1.txEncode)(testObj);
-            // Should have at least 2 bytes (flag + body)
-            expect(encoded.length).toBeGreaterThan(1);
-        });
-    });
-    describe("edge cases", () => {
-        it("should handle objects at exactly 1024 bytes threshold", () => {
-            // Create an object that when msgpack-encoded is very close to 1024 bytes
-            // This is tricky to get exact, so we just verify it works
-            const testObj = {
-                data: "x".repeat(1000),
-            };
-            const encoded = (0, tx_encoding_1.txEncode)(testObj);
-            const decoded = (0, tx_encoding_1.txDecode)(encoded);
-            expect(decoded).toEqual(testObj);
-        });
-        it("should handle primitive values", () => {
-            expect((0, tx_encoding_1.txDecode)((0, tx_encoding_1.txEncode)(42))).toBe(42);
-            expect((0, tx_encoding_1.txDecode)((0, tx_encoding_1.txEncode)("string"))).toBe("string");
-            expect((0, tx_encoding_1.txDecode)((0, tx_encoding_1.txEncode)(true))).toBe(true);
-            expect((0, tx_encoding_1.txDecode)((0, tx_encoding_1.txEncode)(false))).toBe(false);
-            expect((0, tx_encoding_1.txDecode)((0, tx_encoding_1.txEncode)(null))).toBe(null);
-        });
-        it("should handle objects with only undefined values", () => {
-            const testObj = {
-                a: undefined,
-                b: undefined,
-            };
-            const encoded = (0, tx_encoding_1.txEncode)(testObj);
-            const decoded = (0, tx_encoding_1.txDecode)(encoded);
-            expect(decoded).toEqual(testObj);
-        });
-    });
-});

package/dist/device-pairing/cpace.test.d.ts

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

package/dist/device-pairing/cpace.test.js

@@ -1,116 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const cpace_1 = require("./cpace");
-// Test vectors from draft-irtf-cfrg-cpace, "CPace using group X25519 and hash SHA-512".
-const VECTOR = {
-    PRS: "50617373776F7264",
-    CI: "0B415F696E69746961746F720B425F726573706F6E646572",
-    sid: "7E4B4791D6A8EF019B936C79FB7F2C57",
-    g: "D04BF6D41F6A289632A2E929FA29BEBD51092512A7829FDDE7D314B62F05A73F",
-    ya: "21B4F4BD9E64ED355C3EB676A28EBEDAF6D8F17BDC365995B319097153044080",
-    ADa: "414461",
-    Ya: "1D13C89278CDADD826F6D8D7F887701430F8380DDC17611CDD6DC989CE0C9F32",
-    yb: "848B0779FF415F0AF4EA14DF9DD1D3C29AC41D836C7808896C4EBA19C51AC40A",
-    ADb: "414462",
-    Yb: "248CCCF6D5CDC3646F0AD593F9E6CEF4E69D4945F8372E623512ECEA32185623",
-    K: "5B067EFFBDC0B2A0E1D907B21EBB25CFEDB96A852179A847C37E43EE71322C6B",
-    ISK_IR: "6E19B875F7A561D6B3CA3DBB9EF42AC55DE3E717881018204B8922B4D5E53BB2AA82C300BEA7B65D2B671DA71922DDF6472301B79BC270ADFA8BF413285F2263",
-};
-// scalar_mult_vfy vectors: low-order (and non-canonical low-order) inputs abort; the rest
-// must produce the draft's exact outputs, proving bit #255 is cleared before the ladder.
-const VFY_SCALAR = "AF46E36BF0527C9D3B16154B82465EDD62144C0AC1FC5A18506A2244BA449AFF";
-const LOW_ORDER_POINTS = [
-    "0000000000000000000000000000000000000000000000000000000000000000",
-    "0100000000000000000000000000000000000000000000000000000000000000",
-    "ECFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7F",
-    "E0EB7A7C3B41B8AE1656E3FAF19FC46ADA098DEB9C32B1FD866205165F49B800",
-    "5F9C95BCA3508C24B1D0B1559C83EF5B04445CC4581C8E86D8224EDDD09F1157",
-    "EDFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7F",
-    "EEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7F",
-];
-const NON_CANONICAL_POINTS = [
-    [
-        "DAFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
-        "D8E2C776BBACD510D09FD9278B7EDCD25FC5AE9ADFBA3B6E040E8D3B71B21806",
-    ],
-    [
-        "DBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
-        "C85C655EBE8BE44BA9C0FFDE69F2FE10194458D137F09BBFF725CE58803CDB38",
-    ],
-    [
-        "D9FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
-        "DB64DAFA9B8FDD136914E61461935FE92AA372CB056314E1231BC4EC12417456",
-    ],
-    [
-        "CDEB7A7C3B41B8AE1656E3FAF19FC46ADA098DEB9C32B1FD866205165F49B880",
-        "E062DCD5376D58297BE2618C7498F55BAA07D7E03184E8AADA20BCA28888BF7A",
-    ],
-    [
-        "4C9C95BCA3508C24B1D0B1559C83EF5B04445CC4581C8E86D8224EDDD09F11D7",
-        "993C6AD11C4C29DA9A56F7691FD0FF8D732E49DE6250B6C2E80003FF4629A175",
-    ],
-];
-function hex(value) {
-    return Uint8Array.from(Buffer.from(value, "hex"));
-}
-function toHex(value) {
-    return Buffer.from(value).toString("hex").toUpperCase();
-}
-describe("cpace string utilities", () => {
-    it("matches prepend_len and lv_cat vectors", () => {
-        expect(toHex((0, cpace_1.cpacePrependLength)(new Uint8Array(0)))).toBe("00");
-        expect(toHex((0, cpace_1.cpacePrependLength)(Buffer.from("1234")))).toBe("0431323334");
-        expect(toHex((0, cpace_1.cpacePrependLength)(new Uint8Array(128))).slice(0, 4)).toBe("8001");
-        expect(toHex((0, cpace_1.cpaceLvCat)(Buffer.from("1234"), Buffer.from("5"), new Uint8Array(0), Buffer.from("678")))).toBe("043132333401350003363738");
-    });
-    it("matches transcript_ir vector", () => {
-        expect(toHex((0, cpace_1.cpaceTranscript)(Buffer.from("123"), Buffer.from("PartyA"), Buffer.from("234"), Buffer.from("PartyB")))).toBe("03313233065061727479410332333406506172747942");
-    });
-});
-describe("cpace CPace255 vectors", () => {
-    it("derives the generator string and secret generator", () => {
-        const generatorString = (0, cpace_1.cpaceGeneratorString)(hex(VECTOR.PRS), hex(VECTOR.CI), hex(VECTOR.sid));
-        expect(generatorString).toHaveLength(170);
-        expect(toHex(generatorString).startsWith("0843506163653235350850617373776F72646D00")).toBe(true);
-        expect(toHex((0, cpace_1.cpaceCalculateGenerator)(hex(VECTOR.PRS), hex(VECTOR.CI), hex(VECTOR.sid)))).toBe(VECTOR.g);
-    });
-    it("derives both shares, the shared point, and the initiator/responder ISK", () => {
-        const parameters = {
-            password: hex(VECTOR.PRS),
-            channelId: hex(VECTOR.CI),
-            sessionId: hex(VECTOR.sid),
-            initiatorAd: hex(VECTOR.ADa),
-            responderAd: hex(VECTOR.ADb),
-        };
-        const initiator = (0, cpace_1.cpaceStart)("initiator", parameters, hex(VECTOR.ya));
-        const responder = (0, cpace_1.cpaceStart)("responder", parameters, hex(VECTOR.yb));
-        expect(toHex(initiator.share)).toBe(VECTOR.Ya);
-        expect(toHex(responder.share)).toBe(VECTOR.Yb);
-        expect(toHex((0, cpace_1.cpaceScalarMultVerify)(hex(VECTOR.ya), hex(VECTOR.Yb)))).toBe(VECTOR.K);
-        expect(toHex((0, cpace_1.cpaceDeriveIsk)(hex(VECTOR.K), hex(VECTOR.sid), (0, cpace_1.cpaceTranscript)(hex(VECTOR.Ya), hex(VECTOR.ADa), hex(VECTOR.Yb), hex(VECTOR.ADb))))).toBe(VECTOR.ISK_IR);
-        const initiatorIsk = toHex(initiator.finish(hex(VECTOR.Yb)));
-        const responderIsk = toHex(responder.finish(hex(VECTOR.Ya)));
-        expect(initiatorIsk).toBe(VECTOR.ISK_IR);
-        expect(responderIsk).toBe(VECTOR.ISK_IR);
-    });
-    it("rejects low-order points and clears bit #255 of non-canonical inputs", () => {
-        for (const point of LOW_ORDER_POINTS) {
-            expect(() => (0, cpace_1.cpaceScalarMultVerify)(hex(VFY_SCALAR), hex(point))).toThrow(/low-order/);
-        }
-        for (const [point, expected] of NON_CANONICAL_POINTS) {
-            expect(toHex((0, cpace_1.cpaceScalarMultVerify)(hex(VFY_SCALAR), hex(point)))).toBe(expected);
-        }
-    });
-    it("produces unrelated keys for different passwords and identical keys for the same password", () => {
-        const shared = { channelId: Buffer.from("channel"), sessionId: new Uint8Array(0) };
-        const good = (0, cpace_1.cpaceStart)("initiator", { ...shared, password: Buffer.from("guitar-revenge") });
-        const right = (0, cpace_1.cpaceStart)("responder", { ...shared, password: Buffer.from("guitar-revenge") });
-        const wrong = (0, cpace_1.cpaceStart)("responder", { ...shared, password: Buffer.from("guitar-reward") });
-        const rightShare = Uint8Array.from(right.share);
-        const wrongShare = Uint8Array.from(wrong.share);
-        const goodShare = Uint8Array.from(good.share);
-        expect(toHex(right.finish(goodShare))).toBe(toHex(good.finish(rightShare)));
-        const second = (0, cpace_1.cpaceStart)("initiator", { ...shared, password: Buffer.from("guitar-revenge") });
-        expect(toHex(wrong.finish(Uint8Array.from(second.share)))).not.toBe(toHex(second.finish(wrongShare)));
-    });
-});

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

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