@peers-app/peers-sdk 0.20.5 → 0.21.0

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

@@ -152,16 +152,27 @@ function decodeMessage(bytes) {
     }
     return message;
 }
+const DEFAULT_RECEIVE_LIMITS = Object.freeze({
+    maxRpcMessageBytes: 256 * 1024 * 1024,
+    maxStreamMessageBytes: 256 * 1024 * 1024,
+    reassemblyTimeoutMs: 30_000,
+});
 /**
  * Creates an ISocket from a binary peer without creating a full Connection.
  * Useful when you need to pass custom localServerAddresses to the Connection.
  */
-function createBinaryPeerSocket(connectionId, peer, protocol = "binary") {
+function createBinaryPeerSocket(connectionId, peer, protocol = "binary", receiveLimitOverrides = {}) {
     const handlers = {};
     const callbacks = {};
     const rawBytesHandlers = {};
     let isClosed = false;
     const stats = (0, streamed_socket_1.createSocketStats)();
+    const receiveLimits = { ...DEFAULT_RECEIVE_LIMITS, ...receiveLimitOverrides };
+    for (const [name, value] of Object.entries(receiveLimits)) {
+        if (!Number.isSafeInteger(value) || value <= 0) {
+            throw new Error(`Invalid binary peer receive limit ${name}: ${value}`);
+        }
+    }
     // Map protocol string to TransportType (needed early for threshold calculations)
     const transportType = protocol === "wrtc" ? "wrtc" : protocol === "ws" ? "ws" : "unknown";
     // Transport-specific thresholds (computed once)
@@ -246,6 +257,25 @@ function createBinaryPeerSocket(connectionId, peer, protocol = "binary") {
     // Reassembly state for chunked __rpc messages
     let rpcReassemblyBuffer = null;
     let rpcReassemblyOffset = 0;
+    let rpcReassemblyTimer;
+    function clearRpcReassembly() {
+        if (rpcReassemblyTimer) {
+            clearTimeout(rpcReassemblyTimer);
+            rpcReassemblyTimer = undefined;
+        }
+        rpcReassemblyBuffer = null;
+        rpcReassemblyOffset = 0;
+    }
+    function closeForProtocolViolation(reason) {
+        if (isClosed) {
+            return;
+        }
+        console.warn(`Closing ${protocol} peer after binary protocol violation: ${reason}`);
+        isClosed = true;
+        clearRpcReassembly();
+        socket.connected = false;
+        peer.destroy();
+    }
     // Handle incoming data
     peer.on("data", async (data) => {
         try {
@@ -266,6 +296,10 @@ function createBinaryPeerSocket(connectionId, peer, protocol = "binary") {
                 const streamIdBytes = bytes.subarray(3, 3 + streamIdLength);
                 const streamId = decodeStreamId(streamIdBytes);
                 const payload = bytes.subarray(3 + streamIdLength);
+                if (payload.length > receiveLimits.maxStreamMessageBytes) {
+                    closeForProtocolViolation("raw stream frame exceeds the message-size limit");
+                    return;
+                }
                 // Check if this is an RPC message sent via raw bytes (for large payloads)
                 if (streamId === RPC_STREAM_ID) {
                     if (payload.length === 0)
@@ -273,6 +307,10 @@ function createBinaryPeerSocket(connectionId, peer, protocol = "binary") {
                     const flag = payload[0];
                     if (flag === RPC_FLAG_SINGLE) {
                         // Complete message in one raw bytes send
+                        if (payload.length - 1 > receiveLimits.maxRpcMessageBytes) {
+                            closeForProtocolViolation("complete RPC exceeds the message-size limit");
+                            return;
+                        }
                         handleRPCMessage(payload.subarray(1), handlers, callbacks, sendRPCData);
                     }
                     else if (flag === RPC_FLAG_START) {
@@ -280,16 +318,24 @@ function createBinaryPeerSocket(connectionId, peer, protocol = "binary") {
                         if (payload.length < 5)
                             return; // flag + 4 bytes size minimum
                         const totalSize = new DataView(payload.buffer, payload.byteOffset + 1, 4).getUint32(0, false);
+                        const chunkData = payload.subarray(5);
+                        if (totalSize === 0 ||
+                            totalSize > receiveLimits.maxRpcMessageBytes ||
+                            chunkData.length > totalSize ||
+                            rpcReassemblyBuffer) {
+                            closeForProtocolViolation("invalid, duplicate, or oversized RPC start frame");
+                            return;
+                        }
                         rpcReassemblyBuffer = new Uint8Array(totalSize);
                         rpcReassemblyOffset = 0;
-                        const chunkData = payload.subarray(5);
                         rpcReassemblyBuffer.set(chunkData, 0);
                         rpcReassemblyOffset = chunkData.length;
+                        rpcReassemblyTimer = setTimeout(() => closeForProtocolViolation("RPC reassembly timed out"), receiveLimits.reassemblyTimeoutMs);
+                        rpcReassemblyTimer.unref?.();
                         // Check if this single START chunk completes the message (unlikely but safe)
-                        if (rpcReassemblyOffset >= totalSize) {
+                        if (rpcReassemblyOffset === totalSize) {
                             handleRPCMessage(rpcReassemblyBuffer, handlers, callbacks, sendRPCData);
-                            rpcReassemblyBuffer = null;
-                            rpcReassemblyOffset = 0;
+                            clearRpcReassembly();
                         }
                     }
                     else if (flag === RPC_FLAG_CONT) {
@@ -297,17 +343,24 @@ function createBinaryPeerSocket(connectionId, peer, protocol = "binary") {
                         if (!rpcReassemblyBuffer)
                             return; // no START received, discard
                         const chunkData = payload.subarray(1);
+                        if (chunkData.length > rpcReassemblyBuffer.length - rpcReassemblyOffset) {
+                            closeForProtocolViolation("RPC continuation exceeds declared size");
+                            return;
+                        }
                         rpcReassemblyBuffer.set(chunkData, rpcReassemblyOffset);
                         rpcReassemblyOffset += chunkData.length;
-                        if (rpcReassemblyOffset >= rpcReassemblyBuffer.length) {
+                        if (rpcReassemblyOffset === rpcReassemblyBuffer.length) {
                             handleRPCMessage(rpcReassemblyBuffer, handlers, callbacks, sendRPCData);
-                            rpcReassemblyBuffer = null;
-                            rpcReassemblyOffset = 0;
+                            clearRpcReassembly();
                         }
                     }
                     else {
                         // Legacy/unknown: treat entire payload as a complete RPC message
                         // (backwards compat with code before chunking was added)
+                        if (payload.length > receiveLimits.maxRpcMessageBytes) {
+                            closeForProtocolViolation("legacy RPC exceeds the message-size limit");
+                            return;
+                        }
                         handleRPCMessage(payload, handlers, callbacks, sendRPCData);
                     }
                     return;
@@ -320,10 +373,18 @@ function createBinaryPeerSocket(connectionId, peer, protocol = "binary") {
             // Handle RPC messages
             if (protocolType === PROTOCOL_RPC) {
                 const rpcBytes = bytes.subarray(1);
+                if (rpcBytes.length > receiveLimits.maxRpcMessageBytes) {
+                    closeForProtocolViolation("complete RPC exceeds the message-size limit");
+                    return;
+                }
                 handleRPCMessage(rpcBytes, handlers, callbacks, sendRPCData);
                 return;
             }
             // Legacy format (no discriminator) for backwards compatibility
+            if (bytes.length > receiveLimits.maxRpcMessageBytes) {
+                closeForProtocolViolation("legacy RPC exceeds the message-size limit");
+                return;
+            }
             handleRPCMessage(bytes, handlers, callbacks, sendRPCData);
         }
         catch (err) {
@@ -335,6 +396,7 @@ function createBinaryPeerSocket(connectionId, peer, protocol = "binary") {
         if (isClosed)
             return;
         isClosed = true;
+        clearRpcReassembly();
         socket.connected = false;
     });
     const socket = {
@@ -389,9 +451,10 @@ function handleRPCMessage(bytes, handlers, callbacks, sendRPCData) {
         return;
     }
     if (message.type === "call") {
-        const handler = handlers[message.eventName];
+        const eventName = message.eventName;
+        const handler = eventName ? handlers[eventName] : undefined;
         if (!handler) {
-            console.warn(`No handler for event: ${message.eventName}`);
+            console.warn(eventName ? `No handler for event: ${eventName}` : "RPC call did not include an event name");
             return;
         }
         try {
@@ -427,9 +490,9 @@ function handleRPCMessage(bytes, handlers, callbacks, sendRPCData) {
  * This is the main implementation that handles all binary protocols.
  */
 function wrapBinaryPeer(connectionId, peer, localDevice, initiator, options, getTrustLevel) {
-    const { protocol, markTransportSecure } = options;
+    const { protocol, markTransportSecure, receiveLimits } = options;
     // Create the socket wrapper using shared implementation
-    const socket = createBinaryPeerSocket(connectionId, peer, protocol);
+    const socket = createBinaryPeerSocket(connectionId, peer, protocol, receiveLimits);
     const serverAddress = `${protocol}://${connectionId}`;
     const localServerAddresses = initiator ? undefined : [serverAddress];
     if (process.env.NODE_ENV !== "test") {
@@ -448,6 +511,6 @@ function wrapBinaryPeer(connectionId, peer, localDevice, initiator, options, get
  * Backwards-compatible wrapper around wrapBinaryPeer.
  * WebRTC is encrypted at the transport layer (DTLS-SRTP), so we skip application-level encryption.
  */
-function wrapWrtc(connectionId, peer, localDevice, initiator, getTrustLevel) {
-    return wrapBinaryPeer(connectionId, peer, localDevice, initiator, { protocol: "wrtc", markTransportSecure: true }, getTrustLevel);
+function wrapWrtc(connectionId, peer, localDevice, initiator, getTrustLevel, receiveLimits) {
+    return wrapBinaryPeer(connectionId, peer, localDevice, initiator, { protocol: "wrtc", markTransportSecure: true, receiveLimits }, getTrustLevel);
 }

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

@@ -8,8 +8,8 @@ const device_1 = require("./device");
 class MockBinaryPeer {
     dataHandler;
     closeHandler;
-    drainHandler;
     otherPeer;
+    destroyed = false;
     on(event, handler) {
         if (event === "data") {
             this.dataHandler = handler;
@@ -17,9 +17,6 @@ class MockBinaryPeer {
         else if (event === "close") {
             this.closeHandler = handler;
         }
-        else if (event === "drain") {
-            this.drainHandler = handler;
-        }
     }
     send(data) {
         if (this.otherPeer?.dataHandler) {
@@ -35,11 +32,15 @@ class MockBinaryPeer {
         }
     }
     destroy() {
+        this.destroyed = true;
         this.dataHandler = undefined;
         if (this.closeHandler) {
             this.closeHandler();
         }
     }
+    receive(data) {
+        this.dataHandler?.(data);
+    }
 }
 async function getMockPeerPair() {
     const iPeer = new MockBinaryPeer();
@@ -75,6 +76,22 @@ describe("binary-peer-connection", () => {
             rPeer.destroy();
         });
     });
+    it("closes the legacy parser before allocating an oversized declared RPC", async () => {
+        const { iPeer } = await getMockPeerPair();
+        (0, binary_peer_connection_1.createBinaryPeerSocket)("limited", iPeer, "wrtc", {
+            maxRpcMessageBytes: 32,
+        });
+        const streamId = new TextEncoder().encode("__rpc");
+        const frame = new Uint8Array(3 + streamId.length + 5);
+        frame[0] = 0x01;
+        const view = new DataView(frame.buffer);
+        view.setUint16(1, streamId.length, false);
+        frame.set(streamId, 3);
+        frame[3 + streamId.length] = 0x01;
+        view.setUint32(4 + streamId.length, 33, false);
+        iPeer.receive(frame);
+        expect(iPeer.destroyed).toBe(true);
+    });
     describe("wrapBinaryPeer", () => {
         it("should successfully handshake over wrtc protocol", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();

package/dist/device/connection.d.ts

@@ -41,8 +41,8 @@ export declare class Connection {
         publicBoxKey: string;
         userId: string;
         deviceId: string;
-        userName?: string | undefined;
         deviceName?: string | undefined;
+        userName?: string | undefined;
     };
     get connectionId(): string;
     /**

package/dist/device/device.d.ts

@@ -37,8 +37,8 @@ export declare class Device implements IDeviceInfo {
         deviceId: string;
         connectionId: string;
         serverAddress: string;
-        userName?: string | undefined;
         deviceName?: string | undefined;
+        userName?: string | undefined;
     };
     private deviceInfoSigned;
     /** Returns cached signed identity information, refreshing after display metadata changes. */

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

@@ -0,0 +1,34 @@
+/** Wire-protocol version for the temporary device-pairing ceremony. */
+export declare const DEVICE_PAIRING_PROTOCOL_VERSION: 1;
+/** Maximum lifetime of a pairing invitation and signaling room. */
+export declare const DEVICE_PAIRING_TTL_MS: number;
+/** Socket.IO namespace reserved for device-pairing signaling. */
+export declare const DEVICE_PAIRING_SIGNALING_NAMESPACE = "/device-pairing-v1";
+/** Dedicated Socket.IO engine path with a pairing-sized transport buffer. */
+export declare const DEVICE_PAIRING_SIGNALING_PATH = "/device-pairing-v1/socket.io";
+/** Socket.IO event names used by the bounded signaling room. */
+export declare const DEVICE_PAIRING_SIGNALING_EVENTS: {
+    readonly createRoom: "pairing:create-room";
+    readonly joinRoom: "pairing:join-room";
+    readonly getIceServers: "pairing:get-ice-servers";
+    readonly signal: "pairing:signal";
+    readonly deleteRoom: "pairing:delete-room";
+    readonly peerJoined: "pairing:peer-joined";
+    readonly peerLeft: "pairing:peer-left";
+};
+/** Maximum UTF-8 bytes accepted for a serialized signaling envelope. */
+export declare const DEVICE_PAIRING_MAX_SIGNAL_BYTES: number;
+/** Maximum packet size accepted by the anonymous pairing Socket.IO engine. */
+export declare const DEVICE_PAIRING_MAX_TRANSPORT_BYTES: number;
+/** Maximum ICE candidates accepted from either endpoint. */
+export declare const DEVICE_PAIRING_MAX_ICE_CANDIDATES_PER_ROLE = 64;
+/** Maximum tolerated source/destination wall-clock difference. */
+export declare const DEVICE_PAIRING_CLOCK_SKEW_MS: number;
+/** Event name used to publish renderer-safe pairing state. */
+export declare const DEVICE_PAIRING_STATE_EVENT = "device-pairing:state";
+/** Domain-separation label for the room bearer credential. */
+export declare const DEVICE_PAIRING_ROOM_ACCESS_LABEL = "peers-pairing-room-access-v1";
+/** Domain-separation label for signaling message authentication. */
+export declare const DEVICE_PAIRING_SIGNALING_LABEL = "peers-pairing-signaling-v1";
+/** Domain-separation label for the six-digit short authentication string. */
+export declare const DEVICE_PAIRING_SAS_LABEL = "peers-pairing-sas-v1";

package/dist/device-pairing/constants.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEVICE_PAIRING_SAS_LABEL = exports.DEVICE_PAIRING_SIGNALING_LABEL = exports.DEVICE_PAIRING_ROOM_ACCESS_LABEL = exports.DEVICE_PAIRING_STATE_EVENT = exports.DEVICE_PAIRING_CLOCK_SKEW_MS = exports.DEVICE_PAIRING_MAX_ICE_CANDIDATES_PER_ROLE = exports.DEVICE_PAIRING_MAX_TRANSPORT_BYTES = exports.DEVICE_PAIRING_MAX_SIGNAL_BYTES = exports.DEVICE_PAIRING_SIGNALING_EVENTS = exports.DEVICE_PAIRING_SIGNALING_PATH = exports.DEVICE_PAIRING_SIGNALING_NAMESPACE = exports.DEVICE_PAIRING_TTL_MS = exports.DEVICE_PAIRING_PROTOCOL_VERSION = void 0;
+/** Wire-protocol version for the temporary device-pairing ceremony. */
+exports.DEVICE_PAIRING_PROTOCOL_VERSION = 1;
+/** Maximum lifetime of a pairing invitation and signaling room. */
+exports.DEVICE_PAIRING_TTL_MS = 5 * 60 * 1000;
+/** Socket.IO namespace reserved for device-pairing signaling. */
+exports.DEVICE_PAIRING_SIGNALING_NAMESPACE = "/device-pairing-v1";
+/** Dedicated Socket.IO engine path with a pairing-sized transport buffer. */
+exports.DEVICE_PAIRING_SIGNALING_PATH = "/device-pairing-v1/socket.io";
+/** Socket.IO event names used by the bounded signaling room. */
+exports.DEVICE_PAIRING_SIGNALING_EVENTS = {
+    createRoom: "pairing:create-room",
+    joinRoom: "pairing:join-room",
+    getIceServers: "pairing:get-ice-servers",
+    signal: "pairing:signal",
+    deleteRoom: "pairing:delete-room",
+    peerJoined: "pairing:peer-joined",
+    peerLeft: "pairing:peer-left",
+};
+/** Maximum UTF-8 bytes accepted for a serialized signaling envelope. */
+exports.DEVICE_PAIRING_MAX_SIGNAL_BYTES = 72 * 1024;
+/** Maximum packet size accepted by the anonymous pairing Socket.IO engine. */
+exports.DEVICE_PAIRING_MAX_TRANSPORT_BYTES = 96 * 1024;
+/** Maximum ICE candidates accepted from either endpoint. */
+exports.DEVICE_PAIRING_MAX_ICE_CANDIDATES_PER_ROLE = 64;
+/** Maximum tolerated source/destination wall-clock difference. */
+exports.DEVICE_PAIRING_CLOCK_SKEW_MS = 2 * 60 * 1000;
+/** Event name used to publish renderer-safe pairing state. */
+exports.DEVICE_PAIRING_STATE_EVENT = "device-pairing:state";
+/** Domain-separation label for the room bearer credential. */
+exports.DEVICE_PAIRING_ROOM_ACCESS_LABEL = "peers-pairing-room-access-v1";
+/** Domain-separation label for signaling message authentication. */
+exports.DEVICE_PAIRING_SIGNALING_LABEL = "peers-pairing-signaling-v1";
+/** Domain-separation label for the six-digit short authentication string. */
+exports.DEVICE_PAIRING_SAS_LABEL = "peers-pairing-sas-v1";

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

@@ -0,0 +1,45 @@
+import type { IDeviceInfo } from "../data/devices";
+import type { Device } from "../device/device";
+import { type PairingCredentialContents, type PairingRole, type SignedPairingApproval, type SignedPairingInstallationReceipt, type UnsignedPairingSignal } from "./types";
+/** Derives the high-entropy bearer credential presented when joining a room. */
+export declare function derivePairingRoomAccessToken(roomSecret: string): string;
+/** Hashes a room bearer credential before the source gives its verifier to the service. */
+export declare function hashPairingRoomAccessToken(roomAccessToken: string): string;
+/** Derives the client-only key used to authenticate SDP and ICE messages. */
+export declare function derivePairingSignalingKey(roomSecret: string): string;
+/** Computes the MAC over the canonical unsigned signaling envelope. */
+export declare function computePairingSignalMac(signal: UnsignedPairingSignal, signalingKey: string): string;
+/** Verifies a signaling MAC without short-circuiting on the first differing byte. */
+export declare function isPairingSignalMacValid(signal: UnsignedPairingSignal, mac: string, signalingKey: string): boolean;
+/** Creates a signed, expiring approval for one pairing transcript. */
+export declare function createSignedPairingApproval(device: Device, role: PairingRole, transcriptHash: string, expiresAt: number): SignedPairingApproval;
+/** Verifies an approval's signature, endpoint identity, transcript, role, and lifetime. */
+export declare function verifySignedPairingApproval(approval: SignedPairingApproval, expected: {
+    publicKey: string;
+    transcriptHash: string;
+    role: PairingRole;
+    now?: number;
+}): string;
+/** Signs and encrypts account credentials directly to the temporary destination identity. */
+export declare function createPairingCredentialEnvelope(sourceDevice: Device, destinationDevice: IDeviceInfo, credentials: {
+    userId: string;
+    secretKey: string;
+}, transcriptHash: string, expiresAt: number): {
+    nonce: string;
+    contents: string;
+    fromPublicKey: string;
+};
+/** Opens and validates credentials on the temporary destination endpoint. */
+export declare function openPairingCredentialEnvelope(destinationDevice: Device, envelope: unknown, expected: {
+    sourcePublicKey: string;
+    sourcePublicBoxKey: string;
+    transcriptHash: string;
+    now?: number;
+}): PairingCredentialContents;
+/** Creates the temporary destination identity's receipt after normal runtime initialization. */
+export declare function createSignedPairingInstallationReceipt(temporaryDestinationDevice: Device, transcriptHash: string, initializedDevice: IDeviceInfo, installedAt?: number): SignedPairingInstallationReceipt;
+/** Verifies that an installation receipt came from the authenticated temporary destination. */
+export declare function verifySignedPairingInstallationReceipt(receipt: SignedPairingInstallationReceipt, expected: {
+    temporaryDestinationPublicKey: string;
+    transcriptHash: string;
+}): IDeviceInfo;

package/dist/device-pairing/crypto.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.derivePairingRoomAccessToken = derivePairingRoomAccessToken;
+exports.hashPairingRoomAccessToken = hashPairingRoomAccessToken;
+exports.derivePairingSignalingKey = derivePairingSignalingKey;
+exports.computePairingSignalMac = computePairingSignalMac;
+exports.isPairingSignalMacValid = isPairingSignalMacValid;
+exports.createSignedPairingApproval = createSignedPairingApproval;
+exports.verifySignedPairingApproval = verifySignedPairingApproval;
+exports.createPairingCredentialEnvelope = createPairingCredentialEnvelope;
+exports.openPairingCredentialEnvelope = openPairingCredentialEnvelope;
+exports.createSignedPairingInstallationReceipt = createSignedPairingInstallationReceipt;
+exports.verifySignedPairingInstallationReceipt = verifySignedPairingInstallationReceipt;
+const hmac_1 = require("@noble/hashes/hmac");
+const sha2_1 = require("@noble/hashes/sha2");
+const keys_1 = require("../keys");
+const constants_1 = require("./constants");
+const types_1 = require("./types");
+const textEncoder = new TextEncoder();
+function computeHmac(key, value) {
+    return (0, hmac_1.hmac)(sha2_1.sha256, key, textEncoder.encode(value));
+}
+function equalBytes(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    let difference = 0;
+    for (let index = 0; index < left.length; index++) {
+        difference |= left[index] ^ right[index];
+    }
+    return difference === 0;
+}
+/** Derives the high-entropy bearer credential presented when joining a room. */
+function derivePairingRoomAccessToken(roomSecret) {
+    return (0, keys_1.encodeBase64)(computeHmac((0, keys_1.decodeBase64)(roomSecret), constants_1.DEVICE_PAIRING_ROOM_ACCESS_LABEL));
+}
+/** Hashes a room bearer credential before the source gives its verifier to the service. */
+function hashPairingRoomAccessToken(roomAccessToken) {
+    return (0, keys_1.hashValue)(roomAccessToken);
+}
+/** Derives the client-only key used to authenticate SDP and ICE messages. */
+function derivePairingSignalingKey(roomSecret) {
+    return (0, keys_1.encodeBase64)(computeHmac((0, keys_1.decodeBase64)(roomSecret), constants_1.DEVICE_PAIRING_SIGNALING_LABEL));
+}
+/** Computes the MAC over the canonical unsigned signaling envelope. */
+function computePairingSignalMac(signal, signalingKey) {
+    return (0, keys_1.encodeBase64)(computeHmac((0, keys_1.decodeBase64)(signalingKey), (0, keys_1.stableStringify)(signal)));
+}
+/** Verifies a signaling MAC without short-circuiting on the first differing byte. */
+function isPairingSignalMacValid(signal, mac, signalingKey) {
+    try {
+        const expected = (0, keys_1.decodeBase64)(computePairingSignalMac(signal, signalingKey));
+        return equalBytes(expected, (0, keys_1.decodeBase64)(mac));
+    }
+    catch {
+        return false;
+    }
+}
+/** Creates a signed, expiring approval for one pairing transcript. */
+function createSignedPairingApproval(device, role, transcriptHash, expiresAt) {
+    const contents = types_1.pairingApprovalContentsSchema.parse({
+        version: constants_1.DEVICE_PAIRING_PROTOCOL_VERSION,
+        approvalId: (0, keys_1.newToken)(32),
+        transcriptHash,
+        role,
+        expiresAt,
+    });
+    return types_1.signedPairingApprovalSchema.parse(device.signObjectWithSecretKey(contents));
+}
+/** Verifies an approval's signature, endpoint identity, transcript, role, and lifetime. */
+function verifySignedPairingApproval(approval, expected) {
+    const parsed = types_1.signedPairingApprovalSchema.parse(approval);
+    if (parsed.publicKey !== expected.publicKey) {
+        throw new Error("Pairing approval came from an unexpected device");
+    }
+    const contents = types_1.pairingApprovalContentsSchema.parse((0, keys_1.openSignedObject)(parsed));
+    if (contents.transcriptHash !== expected.transcriptHash || contents.role !== expected.role) {
+        throw new Error("Pairing approval does not match this ceremony");
+    }
+    if (contents.expiresAt < (expected.now ?? Date.now())) {
+        throw new Error("Pairing approval has expired");
+    }
+    return contents.approvalId;
+}
+/** Signs and encrypts account credentials directly to the temporary destination identity. */
+function createPairingCredentialEnvelope(sourceDevice, destinationDevice, credentials, transcriptHash, expiresAt) {
+    const contents = types_1.pairingCredentialContentsSchema.parse({
+        version: constants_1.DEVICE_PAIRING_PROTOCOL_VERSION,
+        transcriptHash,
+        expiresAt,
+        ...credentials,
+    });
+    return types_1.pairingCredentialEnvelopeSchema.parse(sourceDevice.signAndBoxDataForDevice(contents, destinationDevice));
+}
+/** Opens and validates credentials on the temporary destination endpoint. */
+function openPairingCredentialEnvelope(destinationDevice, envelope, expected) {
+    const parsedEnvelope = types_1.pairingCredentialEnvelopeSchema.parse(envelope);
+    if (parsedEnvelope.fromPublicKey !== expected.sourcePublicBoxKey) {
+        throw new Error("Pairing credentials came from an unexpected device");
+    }
+    const signedContents = destinationDevice.openBoxWithSecretKey(parsedEnvelope);
+    if (signedContents.publicKey !== expected.sourcePublicKey) {
+        throw new Error("Pairing credentials were signed by an unexpected device");
+    }
+    const contents = types_1.pairingCredentialContentsSchema.parse((0, keys_1.openSignedObject)(signedContents));
+    if (contents.transcriptHash !== expected.transcriptHash) {
+        throw new Error("Pairing credentials do not match this ceremony");
+    }
+    if (contents.expiresAt < (expected.now ?? Date.now())) {
+        throw new Error("Pairing credentials have expired");
+    }
+    return contents;
+}
+/** Creates the temporary destination identity's receipt after normal runtime initialization. */
+function createSignedPairingInstallationReceipt(temporaryDestinationDevice, transcriptHash, initializedDevice, installedAt = Date.now()) {
+    const contents = types_1.pairingInstallationReceiptContentsSchema.parse({
+        version: constants_1.DEVICE_PAIRING_PROTOCOL_VERSION,
+        transcriptHash,
+        initializedDevice,
+        installedAt,
+    });
+    return types_1.signedPairingInstallationReceiptSchema.parse(temporaryDestinationDevice.signObjectWithSecretKey(contents));
+}
+/** Verifies that an installation receipt came from the authenticated temporary destination. */
+function verifySignedPairingInstallationReceipt(receipt, expected) {
+    const parsed = types_1.signedPairingInstallationReceiptSchema.parse(receipt);
+    if (parsed.publicKey !== expected.temporaryDestinationPublicKey) {
+        throw new Error("Pairing receipt came from an unexpected device");
+    }
+    const contents = types_1.pairingInstallationReceiptContentsSchema.parse((0, keys_1.openSignedObject)(parsed));
+    if (contents.transcriptHash !== expected.transcriptHash) {
+        throw new Error("Pairing receipt does not match this ceremony");
+    }
+    return contents.initializedDevice;
+}

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

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