@matter/thread-br-client 0.0.1 → 0.17.5-alpha.0-20260706-fd4c49e2e

package/src/crypto/Pskc.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { ImplementationError } from "@matter/general";
+import { Bytes, Crypto, ImplementationError } from "@matter/general";
 import { pbkdf2AesCmac } from "./Pbkdf2AesCmac.js";
 
 const SALT_PREFIX = new TextEncoder().encode("Thread");
@@ -25,15 +25,16 @@ const PSKC_LENGTH = 16;
  * || networkName` ordering is wrong).
  */
 export namespace Pskc {
-    export function derive(args: { passphrase: string; extPanId: Uint8Array; networkName: string }): Uint8Array {
+    export function derive(crypto: Crypto, args: { passphrase: string; extPanId: Bytes; networkName: string }): Bytes {
         const password = new TextEncoder().encode(args.passphrase);
         if (password.length < PASSPHRASE_MIN_BYTES || password.length > PASSPHRASE_MAX_BYTES) {
             throw new ImplementationError(
                 `passphrase UTF-8 length must be ${PASSPHRASE_MIN_BYTES}..${PASSPHRASE_MAX_BYTES} bytes, got ${password.length}`,
             );
         }
-        if (args.extPanId.length !== EXT_PAN_ID_LENGTH) {
-            throw new ImplementationError(`extPanId must be ${EXT_PAN_ID_LENGTH} bytes, got ${args.extPanId.length}`);
+        const extPanId = Bytes.of(args.extPanId);
+        if (extPanId.length !== EXT_PAN_ID_LENGTH) {
+            throw new ImplementationError(`extPanId must be ${EXT_PAN_ID_LENGTH} bytes, got ${extPanId.length}`);
         }
         const networkNameBytes = new TextEncoder().encode(args.networkName);
         if (networkNameBytes.length === 0 || networkNameBytes.length > NETWORK_NAME_MAX_BYTES) {
@@ -44,10 +45,10 @@ export namespace Pskc {
 
         const salt = new Uint8Array(SALT_PREFIX.length + EXT_PAN_ID_LENGTH + networkNameBytes.length);
         salt.set(SALT_PREFIX, 0);
-        salt.set(args.extPanId, SALT_PREFIX.length);
+        salt.set(extPanId, SALT_PREFIX.length);
         salt.set(networkNameBytes, SALT_PREFIX.length + EXT_PAN_ID_LENGTH);
 
-        return pbkdf2AesCmac({
+        return pbkdf2AesCmac(crypto, {
             password,
             salt,
             iterations: ITERATIONS,

package/src/crypto/index.ts

@@ -4,6 +4,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-export { AesCmac, AesCmacPrf128 } from "./AesCmacPrf128.js";
+export { AesCmacPrf128 } from "./AesCmacPrf128.js";
 export { pbkdf2AesCmac } from "./Pbkdf2AesCmac.js";
 export { Pskc } from "./Pskc.js";

package/src/dataset/OperationalDataset.ts

@@ -27,18 +27,18 @@ export { ThreadDatasetError } from "./errors.js";
 export interface OperationalDataset {
     channel?: number;
     panId?: number;
-    extPanId?: Uint8Array;
+    extPanId?: Bytes;
     networkName?: string;
-    pskc?: Uint8Array;
-    networkKey?: Uint8Array;
-    meshLocalPrefix?: Uint8Array;
+    pskc?: Bytes;
+    networkKey?: Bytes;
+    meshLocalPrefix?: Bytes;
     securityPolicy?: SecurityPolicy;
-    activeTimestamp?: Uint8Array;
-    pendingTimestamp?: Uint8Array;
+    activeTimestamp?: Bytes;
+    pendingTimestamp?: Bytes;
     delayTimer?: number;
-    channelMask?: Uint8Array;
-    unknownTlvs: Array<{ type: number; value: Uint8Array }>;
-    raw: Uint8Array;
+    channelMask?: Bytes;
+    unknownTlvs: Array<{ type: number; value: Bytes }>;
+    raw: Bytes;
 }
 
 export namespace OperationalDataset {
@@ -53,8 +53,8 @@ export namespace OperationalDataset {
     export function decode(input: Bytes | string): OperationalDataset {
         const blob = typeof input === "string" ? Bytes.of(Bytes.fromHex(input.replace(/\s+/g, ""))) : Bytes.of(input);
         const entries = BasicTlv.walk(blob);
-        const unknownTlvs = new Array<{ type: number; value: Uint8Array }>();
-        const originalTlvs = entries.map(e => ({ type: e.type, value: e.value.slice() }));
+        const unknownTlvs = new Array<{ type: number; value: Bytes }>();
+        const originalTlvs = entries.map(e => ({ type: e.type, value: Bytes.of(e.value).slice() }));
         const ds: OperationalDataset = {
             unknownTlvs,
             raw: blob.slice(),
@@ -80,12 +80,12 @@ export namespace OperationalDataset {
      * @param ds - Dataset to encode; may be a decoded or manually constructed object.
      * @returns MeshCoP TLV byte sequence.
      */
-    export function encode(ds: OperationalDataset): Uint8Array {
+    export function encode(ds: OperationalDataset): Bytes {
         const originals = ORIGINAL_TLVS.get(ds);
         if (originals !== undefined) {
             return encodeWithReplay(ds, originals);
         }
-        return BasicTlv.encode(canonicalEntries(ds));
+        return Bytes.of(BasicTlv.encode(canonicalEntries(ds)));
     }
 
     /**
@@ -112,73 +112,74 @@ const ORIGINAL_TLVS = new WeakMap<OperationalDataset, ReadonlyArray<BasicTlvEntr
 function applyKnownTlvToDataset(
     ds: OperationalDataset,
     entry: BasicTlvEntry,
-    unknownTlvs: Array<{ type: number; value: Uint8Array }>,
+    unknownTlvs: Array<{ type: number; value: Bytes }>,
 ): void {
+    const value = Bytes.of(entry.value);
     switch (entry.type) {
         case MeshCopTlvType.CHANNEL:
-            ds.channel = decodeChannel(entry.value);
+            ds.channel = decodeChannel(value);
             break;
         case MeshCopTlvType.PANID:
-            if (entry.value.length !== 2) {
-                throw new ThreadDatasetError(`PANID TLV must be 2 bytes, got ${entry.value.length}`);
+            if (value.length !== 2) {
+                throw new ThreadDatasetError(`PANID TLV must be 2 bytes, got ${value.length}`);
             }
-            ds.panId = (entry.value[0] << 8) | entry.value[1];
+            ds.panId = (value[0] << 8) | value[1];
             break;
         case MeshCopTlvType.EXTPANID:
-            if (entry.value.length !== 8) {
-                throw new ThreadDatasetError(`EXTPANID TLV must be 8 bytes, got ${entry.value.length}`);
+            if (value.length !== 8) {
+                throw new ThreadDatasetError(`EXTPANID TLV must be 8 bytes, got ${value.length}`);
             }
-            ds.extPanId = entry.value.slice();
+            ds.extPanId = value.slice();
             break;
         case MeshCopTlvType.NETWORK_NAME:
-            ds.networkName = new TextDecoder("utf-8").decode(entry.value);
+            ds.networkName = new TextDecoder("utf-8").decode(value);
             break;
         case MeshCopTlvType.PSKC:
-            ds.pskc = entry.value.slice();
+            ds.pskc = value.slice();
             break;
         case MeshCopTlvType.NETWORK_KEY:
-            if (entry.value.length !== 16) {
-                throw new ThreadDatasetError(`NETWORK_KEY TLV must be 16 bytes, got ${entry.value.length}`);
+            if (value.length !== 16) {
+                throw new ThreadDatasetError(`NETWORK_KEY TLV must be 16 bytes, got ${value.length}`);
             }
-            ds.networkKey = entry.value.slice();
+            ds.networkKey = value.slice();
             break;
         case MeshCopTlvType.MESH_LOCAL_PREFIX:
-            if (entry.value.length !== 8) {
-                throw new ThreadDatasetError(`MESH_LOCAL_PREFIX TLV must be 8 bytes, got ${entry.value.length}`);
+            if (value.length !== 8) {
+                throw new ThreadDatasetError(`MESH_LOCAL_PREFIX TLV must be 8 bytes, got ${value.length}`);
             }
-            ds.meshLocalPrefix = entry.value.slice();
+            ds.meshLocalPrefix = value.slice();
             break;
         case MeshCopTlvType.SECURITY_POLICY:
-            ds.securityPolicy = SecurityPolicy.decode(entry.value);
+            ds.securityPolicy = SecurityPolicy.decode(value);
             break;
         case MeshCopTlvType.ACTIVE_TIMESTAMP:
-            if (entry.value.length !== 8) {
-                throw new ThreadDatasetError(`ACTIVE_TIMESTAMP TLV must be 8 bytes, got ${entry.value.length}`);
+            if (value.length !== 8) {
+                throw new ThreadDatasetError(`ACTIVE_TIMESTAMP TLV must be 8 bytes, got ${value.length}`);
             }
-            ds.activeTimestamp = entry.value.slice();
+            ds.activeTimestamp = value.slice();
             break;
         case MeshCopTlvType.PENDING_TIMESTAMP:
-            if (entry.value.length !== 8) {
-                throw new ThreadDatasetError(`PENDING_TIMESTAMP TLV must be 8 bytes, got ${entry.value.length}`);
+            if (value.length !== 8) {
+                throw new ThreadDatasetError(`PENDING_TIMESTAMP TLV must be 8 bytes, got ${value.length}`);
             }
-            ds.pendingTimestamp = entry.value.slice();
+            ds.pendingTimestamp = value.slice();
             break;
         case MeshCopTlvType.DELAY_TIMER:
-            if (entry.value.length !== 4) {
-                throw new ThreadDatasetError(`DELAY_TIMER TLV must be 4 bytes, got ${entry.value.length}`);
+            if (value.length !== 4) {
+                throw new ThreadDatasetError(`DELAY_TIMER TLV must be 4 bytes, got ${value.length}`);
             }
-            ds.delayTimer = (entry.value[0] << 24) | (entry.value[1] << 16) | (entry.value[2] << 8) | entry.value[3];
+            ds.delayTimer = (value[0] << 24) | (value[1] << 16) | (value[2] << 8) | value[3];
             break;
         case MeshCopTlvType.CHANNEL_MASK:
-            ds.channelMask = entry.value.slice();
+            ds.channelMask = value.slice();
             break;
         default:
-            unknownTlvs.push({ type: entry.type, value: entry.value.slice() });
+            unknownTlvs.push({ type: entry.type, value: value.slice() });
             break;
     }
 }
 
-function encodeWithReplay(ds: OperationalDataset, originals: ReadonlyArray<BasicTlvEntry>): Uint8Array {
+function encodeWithReplay(ds: OperationalDataset, originals: ReadonlyArray<BasicTlvEntry>): Bytes {
     const seenKnownTypes = new Set<number>();
     const unknownCursor = new Map<number, number>();
     const out = new Array<BasicTlvEntry>();
@@ -216,7 +217,7 @@ function encodeWithReplay(ds: OperationalDataset, originals: ReadonlyArray<Basic
         out.push({ type: known.type, value: canonical });
     }
 
-    return BasicTlv.encode(out);
+    return Bytes.of(BasicTlv.encode(out));
 }
 
 const EMPTY_BYTES = new Uint8Array();
@@ -229,7 +230,7 @@ function canonicalEntries(ds: OperationalDataset): BasicTlvEntry[] {
         out.push({ type: known.type, value: canonical });
     }
     for (const u of ds.unknownTlvs) {
-        out.push({ type: u.type, value: u.value.slice() });
+        out.push({ type: u.type, value: Bytes.of(u.value).slice() });
     }
     return out;
 }
@@ -241,7 +242,7 @@ function canonicalEntries(ds: OperationalDataset): BasicTlvEntry[] {
 interface KnownTlvHandler {
     type: number;
     /** Returns the canonical encoding of the named accessor, or undefined when unset. */
-    encodeCurrent(ds: OperationalDataset): Uint8Array | undefined;
+    encodeCurrent(ds: OperationalDataset): Bytes | undefined;
     /** Whether ds[field] structurally equals other[field]. Used for replay decisions. */
     equalsCurrent(ds: OperationalDataset, other: OperationalDataset): boolean;
 }
@@ -249,7 +250,7 @@ interface KnownTlvHandler {
 function handler<K extends keyof OperationalDataset>(
     type: number,
     field: K,
-    encodeValue: (value: OperationalDataset[K] & {}) => Uint8Array,
+    encodeValue: (value: OperationalDataset[K] & {}) => Bytes,
     equals: (a: OperationalDataset[K] & {}, b: OperationalDataset[K] & {}) => boolean,
 ): KnownTlvHandler {
     return {
@@ -270,7 +271,7 @@ function handler<K extends keyof OperationalDataset>(
 
 const eqNumber = (a: number, b: number): boolean => a === b;
 const eqString = (a: string, b: string): boolean => a === b;
-const eqBytes = (a: Uint8Array, b: Uint8Array): boolean => Bytes.areEqual(a, b);
+const eqBytes = (a: Bytes, b: Bytes): boolean => Bytes.areEqual(a, b);
 const eqSecurityPolicy = (a: SecurityPolicy, b: SecurityPolicy): boolean =>
     a.rotationTime === b.rotationTime && a.flags === b.flags;
 

package/src/dataset/SecurityPolicy.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { ImplementationError } from "@matter/general";
+import { Bytes, ImplementationError } from "@matter/general";
 import { ThreadDatasetError } from "./errors.js";
 
 /**
@@ -21,17 +21,18 @@ export interface SecurityPolicy {
 }
 
 export namespace SecurityPolicy {
-    export function decode(value: Uint8Array): SecurityPolicy {
-        if (value.length !== 4) {
-            throw new ThreadDatasetError(`Security policy must be 4 bytes, got ${value.length}`);
+    export function decode(value: Bytes): SecurityPolicy {
+        const buf = Bytes.of(value);
+        if (buf.length !== 4) {
+            throw new ThreadDatasetError(`Security policy must be 4 bytes, got ${buf.length}`);
         }
         return {
-            rotationTime: (value[0] << 8) | value[1],
-            flags: (value[2] << 8) | value[3],
+            rotationTime: (buf[0] << 8) | buf[1],
+            flags: (buf[2] << 8) | buf[3],
         };
     }
 
-    export function encode(policy: SecurityPolicy): Uint8Array {
+    export function encode(policy: SecurityPolicy): Bytes {
         if (policy.rotationTime < 0 || policy.rotationTime > 0xffff) {
             throw new ImplementationError(`Security policy rotationTime out of range: ${policy.rotationTime}`);
         }

package/src/diagnostic/DiagnosticResponse.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import type { Bytes } from "@matter/general";
 import type { ChildIpv6Addresses } from "../tlv/diag/ChildIpv6AddressList.js";
 import type { ChildTableEntry } from "../tlv/diag/ChildTable.js";
 import type { Connectivity } from "../tlv/diag/Connectivity.js";
@@ -16,7 +17,7 @@ import type { Route64 } from "../tlv/diag/Route64.js";
 import type { RouterNeighborEntry } from "../tlv/diag/RouterNeighbor.js";
 
 export interface DiagnosticResponse {
-    extMacAddress?: Uint8Array;
+    extMacAddress?: Bytes;
     rloc16?: number;
     mode?: Mode;
     timeout?: number;
@@ -24,7 +25,7 @@ export interface DiagnosticResponse {
     route64?: Route64;
     leaderData?: LeaderData;
     networkData?: ThreadNetworkData;
-    ipv6Addresses?: Uint8Array[];
+    ipv6Addresses?: Bytes[];
     macCounters?: MacCounters;
     batteryLevel?: number;
     supplyVoltage?: number;
@@ -33,7 +34,7 @@ export interface DiagnosticResponse {
     routerNeighbors?: RouterNeighborEntry[];
     channelPages?: number[];
     maxChildTimeout?: number;
-    eui64?: Uint8Array;
+    eui64?: Bytes;
     version?: number;
     vendorName?: string;
     vendorModel?: string;
@@ -41,5 +42,5 @@ export interface DiagnosticResponse {
     threadStackVersion?: string;
     vendorAppUrl?: string;
     mleCounters?: MleCounters;
-    unknown: Array<{ type: number; value: Uint8Array }>;
+    unknown: Array<{ type: number; value: Bytes }>;
 }

package/src/diagnostic/DiagnosticSource.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import type { Observable } from "@matter/general";
+import type { Bytes, Observable } from "@matter/general";
 import { NetworkDiagTlvType } from "../tlv/networkDiagTlvTypes.js";
 import type { DiagnosticResponse } from "./DiagnosticResponse.js";
 
@@ -41,7 +41,7 @@ export interface QueryMulticastHandle {
 
 export interface DiagnosticSource {
     readonly kind: "meshcop" | "otbr-rest";
-    canQuery(extPanId: Uint8Array): boolean;
+    canQuery(extPanId: Bytes): boolean;
     queryUnicast(target: { rloc16?: number; ip?: string }, tlvTypes: number[]): Promise<DiagnosticResponse>;
     /**
      * Issue a multicast diagnostic query (DIAG_GET for MeshCoP, /diagnostics