@peers-app/peers-sdk 0.27.3 → 0.27.5

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 {};

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

@@ -1,211 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const device_1 = require("../device/device");
-const keys_1 = require("../keys");
-const utils_1 = require("../utils");
-const _1 = require(".");
-const NOW = 1_800_000_000_000;
-const ORIGIN = "https://peers.app";
-const FINGERPRINT = Array.from({ length: 32 }, (_, index) => index.toString(16).padStart(2, "0"))
-    .join(":")
-    .toUpperCase();
-describe("pairing code", () => {
-    it("uses the full PGP word lists with no duplicates", () => {
-        expect(_1.PGP_EVEN_WORDS).toHaveLength(256);
-        expect(_1.PGP_ODD_WORDS).toHaveLength(256);
-        expect(new Set([..._1.PGP_EVEN_WORDS, ..._1.PGP_ODD_WORDS]).size).toBe(512);
-    });
-    it("generates even/odd/even words and round-trips through formatting and parsing", () => {
-        const words = (0, _1.generatePairingWords)();
-        expect(_1.PGP_EVEN_WORDS).toContain(words[0]);
-        expect(_1.PGP_ODD_WORDS).toContain(words[1]);
-        expect(_1.PGP_EVEN_WORDS).toContain(words[2]);
-        const text = (0, _1.formatPairingCode)(7, words);
-        expect(text).toBe(`7-${words.join("-")}`);
-        expect((0, _1.parsePairingCode)(text)).toEqual({ nameplate: 7, words });
-        expect((0, _1.parsePairingCode)(`  7 ${words.join(" ").toUpperCase()} `)).toEqual({
-            nameplate: 7,
-            words,
-        });
-    });
-    it("rejects wrong slots, unknown words, bad nameplates, and wrong lengths", () => {
-        expect(() => (0, _1.parsePairingCode)("7-adroitness-aardvark-absurd")).toThrow(/word 1/);
-        expect(() => (0, _1.parsePairingCode)("7-aardvark-absurd-acme")).toThrow(/word 2/);
-        expect(() => (0, _1.parsePairingCode)("7-aardvark-adroitness-nope")).toThrow(/word 3/);
-        expect(() => (0, _1.parsePairingCode)("0-aardvark-adroitness-acme")).toThrow(/room number/);
-        expect(() => (0, _1.parsePairingCode)("10000-aardvark-adroitness-acme")).toThrow(/room number/);
-        expect(() => (0, _1.parsePairingCode)("aardvark-adroitness-acme")).toThrow(/three words/);
-        expect(() => (0, _1.parsePairingCode)("7-aardvark-adroitness")).toThrow(/three words/);
-    });
-});
-describe("pairing PAKE and signaling", () => {
-    const code = (0, _1.parsePairingCode)("42-aardvark-adroitness-acme");
-    it("derives matching keys for the same code and different keys for a wrong code", () => {
-        const source = (0, _1.startPairingPake)("source", code, ORIGIN);
-        const destination = (0, _1.startPairingPake)("destination", code, ORIGIN);
-        const sourceKeys = source.finish(destination.share);
-        const destinationKeys = destination.finish(source.share);
-        expect(sourceKeys).toEqual(destinationKeys);
-        expect(sourceKeys.signalingKey).not.toBe(sourceKeys.confirmKey);
-        const token = (0, _1.derivePairingWebSocketToken)(sourceKeys.signalingKey);
-        expect(token).toBe((0, _1.derivePairingWebSocketToken)(destinationKeys.signalingKey));
-        expect(token).not.toBe(sourceKeys.signalingKey);
-        expect(token).not.toBe(sourceKeys.confirmKey);
-        const wrong = (0, _1.startPairingPake)("source", (0, _1.parsePairingCode)("42-absurd-adroitness-acme"), ORIGIN);
-        const honest = (0, _1.startPairingPake)("destination", code, ORIGIN);
-        expect(wrong.finish(honest.share)).not.toEqual(honest.finish(wrong.share));
-        const otherRoom = (0, _1.startPairingPake)("source", { ...code, nameplate: 43 }, ORIGIN);
-        const thisRoom = (0, _1.startPairingPake)("destination", code, ORIGIN);
-        expect(otherRoom.finish(thisRoom.share)).not.toEqual(thisRoom.finish(otherRoom.share));
-    });
-    it("accepts the pake share unauthenticated and everything else only with the key", () => {
-        const share = (0, _1.startPairingPake)("source", code, ORIGIN).share;
-        const pake = (0, _1.createPairingPakeSignal)({
-            nameplate: 42,
-            senderRole: "source",
-            sequence: 1,
-            share,
-        });
-        expect((0, _1.verifyPairingSignal)(pake, undefined, {
-            nameplate: 42,
-            senderRole: "source",
-            nextSequence: 1,
-        })).toEqual(pake);
-        const keys = (0, _1.startPairingPake)("destination", code, ORIGIN);
-        const signalingKey = keys.finish(share).signalingKey;
-        const options = (0, _1.signPairingSignal)({
-            version: 3,
-            nameplate: 42,
-            senderRole: "destination",
-            sequence: 2,
-            kind: "transport-options",
-            payload: {
-                endpointNonce: (0, keys_1.newToken)(32),
-                webrtc: false,
-                websocket: { urls: ["http://192.168.1.20:3341", "wss://peers.example.com"] },
-            },
-        }, signalingKey);
-        expect((0, _1.verifyPairingSignal)(options, signalingKey, {
-            nameplate: 42,
-            senderRole: "destination",
-            nextSequence: 2,
-        })).toEqual(options);
-        expect(() => (0, _1.signPairingSignal)({
-            ...options,
-            payload: { ...options.payload, websocket: { urls: ["ftp://nope"] } },
-        }, signalingKey)).toThrow();
-        const choice = (0, _1.signPairingSignal)({
-            version: 3,
-            nameplate: 42,
-            senderRole: "source",
-            sequence: 2,
-            kind: "transport-choice",
-            payload: { endpointNonce: (0, keys_1.newToken)(32), selected: "ws", url: "http://192.168.1.20:3341" },
-        }, signalingKey);
-        expect((0, _1.verifyPairingSignal)(choice, signalingKey, {
-            nameplate: 42,
-            senderRole: "source",
-            nextSequence: 2,
-        })).toEqual(choice);
-        const offerSdp = `v=0\r\na=fingerprint:sha-256 ${FINGERPRINT}\r\n`;
-        const signal = (0, _1.signPairingSignal)({
-            version: 3,
-            nameplate: 42,
-            senderRole: "source",
-            sequence: 3,
-            kind: "offer",
-            payload: { type: "offer", sdp: offerSdp },
-        }, signalingKey);
-        const expected = { nameplate: 42, senderRole: "source", nextSequence: 3 };
-        expect((0, _1.verifyPairingSignal)(signal, signalingKey, expected)).toEqual(signal);
-        expect(() => (0, _1.verifyPairingSignal)(signal, undefined, expected)).toThrow(/before authentication/);
-        expect(() => (0, _1.verifyPairingSignal)({ ...signal, payload: { ...signal.payload, sdp: `${offerSdp}modified` } }, signalingKey, expected)).toThrow(/authentication failed/);
-        expect(() => (0, _1.verifyPairingSignal)(signal, signalingKey, { ...expected, senderRole: "destination" })).toThrow(/out of order/);
-        expect(() => (0, _1.verifyPairingSignal)(signal, signalingKey, { ...expected, nextSequence: 4 })).toThrow(/out of order/);
-        expect(() => (0, _1.verifyPairingSignal)(signal, signalingKey, { ...expected, nameplate: 41 })).toThrow(/out of order/);
-    });
-});
-describe("pairing transcript, confirmation, and credentials", () => {
-    const source = new device_1.Device();
-    const destination = new device_1.Device();
-    const sdp = `v=0\r\na=fingerprint:sha-256 ${FINGERPRINT}\r\n`;
-    const transcript = {
-        version: 3,
-        serviceOrigin: ORIGIN,
-        nameplate: 42,
-        sourceIdentity: (0, keys_1.openSignedObject)(source.getDeviceInfo()),
-        destinationIdentity: (0, keys_1.openSignedObject)(destination.getDeviceInfo()),
-        sourceEndpointNonce: (0, keys_1.newToken)(32),
-        destinationEndpointNonce: (0, keys_1.newToken)(32),
-        transport: "wrtc",
-        transportBinding: (0, _1.webRtcPairingTransportBinding)(sdp, sdp),
-    };
-    it("hashes the transcript deterministically and changes with any input", () => {
-        const hash = (0, _1.computeDevicePairingTranscriptHash)(transcript);
-        expect((0, _1.computeDevicePairingTranscriptHash)(transcript)).toBe(hash);
-        expect((0, _1.computeDevicePairingTranscriptHash)({ ...transcript, nameplate: 43 })).not.toBe(hash);
-        expect(transcript.transportBinding).toBe(`${(0, _1.extractSha256SdpFingerprint)(sdp)}|${(0, _1.extractSha256SdpFingerprint)(sdp)}`);
-        expect((0, _1.computeDevicePairingTranscriptHash)({
-            ...transcript,
-            transportBinding: transcript.transportBinding.replace("00", "FF"),
-        })).not.toBe(hash);
-        expect((0, _1.computeDevicePairingTranscriptHash)({
-            ...transcript,
-            transport: "ws",
-            transportBinding: "http://192.168.1.20:3341",
-        })).not.toBe(hash);
-    });
-    it("confirms only with the same key, role, transcript, and identity", () => {
-        const code = (0, _1.parsePairingCode)("42-aardvark-adroitness-acme");
-        const sourcePake = (0, _1.startPairingPake)("source", code, ORIGIN);
-        const destinationPake = (0, _1.startPairingPake)("destination", code, ORIGIN);
-        const keys = sourcePake.finish(destinationPake.share);
-        const wrongKeys = (0, _1.startPairingPake)("destination", (0, _1.parsePairingCode)("42-absurd-adroitness-acme"), ORIGIN).finish((0, _1.startPairingPake)("source", code, ORIGIN).share);
-        const transcriptHash = (0, _1.computeDevicePairingTranscriptHash)(transcript);
-        const confirmation = (0, _1.createPairingConfirmation)({
-            role: "destination",
-            transcriptHash,
-            device: transcript.destinationIdentity,
-            presentation: { deviceName: "Phone", deviceType: "mobile" },
-        }, keys.confirmKey);
-        const expected = {
-            role: "destination",
-            transcriptHash,
-            device: transcript.destinationIdentity,
-        };
-        expect((0, _1.verifyPairingConfirmation)(confirmation, keys.confirmKey, expected)).toEqual(confirmation);
-        expect(() => (0, _1.verifyPairingConfirmation)(confirmation, wrongKeys.confirmKey, expected)).toThrow(/did not match/);
-        expect(() => (0, _1.verifyPairingConfirmation)(confirmation, keys.confirmKey, { ...expected, role: "source" })).toThrow(/does not match/);
-        expect(() => (0, _1.verifyPairingConfirmation)(confirmation, keys.confirmKey, {
-            ...expected,
-            device: transcript.sourceIdentity,
-        })).toThrow(/identity mismatch/);
-        expect(() => (0, _1.verifyPairingConfirmation)({ ...confirmation, presentation: { deviceName: "Evil" } }, keys.confirmKey, expected)).toThrow(/did not match/);
-    });
-    it("requires the expected identities and transcript for credentials and receipt", () => {
-        const transcriptHash = (0, keys_1.newToken)(32);
-        const expiresAt = NOW + 60_000;
-        const credentials = { userId: (0, utils_1.newid)(), secretKey: (0, keys_1.newKeys)().secretKey };
-        const destinationInfo = (0, keys_1.openSignedObject)(destination.getDeviceInfo());
-        const envelope = (0, _1.createPairingCredentialEnvelope)(source, destinationInfo, credentials, transcriptHash, expiresAt);
-        expect((0, _1.openPairingCredentialEnvelope)(destination, envelope, {
-            sourcePublicKey: source.publicKey,
-            sourcePublicBoxKey: source.publicBoxKey,
-            transcriptHash,
-            now: NOW,
-        })).toEqual({ version: 3, transcriptHash, expiresAt, ...credentials });
-        expect(() => (0, _1.openPairingCredentialEnvelope)(new device_1.Device(), envelope, {
-            sourcePublicKey: source.publicKey,
-            sourcePublicBoxKey: source.publicBoxKey,
-            transcriptHash,
-            now: NOW,
-        })).toThrow();
-        const initialized = new device_1.Device(credentials.userId);
-        const initializedInfo = (0, keys_1.openSignedObject)(initialized.getDeviceInfo());
-        const receipt = (0, _1.createSignedPairingInstallationReceipt)(destination, transcriptHash, initializedInfo, NOW);
-        expect((0, _1.verifySignedPairingInstallationReceipt)(receipt, {
-            temporaryDestinationPublicKey: destination.publicKey,
-            transcriptHash,
-        })).toEqual(initializedInfo);
-    });
-});

package/dist/hlc.test.d.ts

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