@matter/general 0.14.1-alpha.0-20250607-a93593303 → 0.15.0-alpha.0-20250612-ddd428561

package/src/crypto/aes/Ccm.ts

@@ -0,0 +1,350 @@
+/**
+ * @license
+ * Copyright 2022-2025 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * NIST: https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38c.pdf
+ *
+ * SJCL: https://github.com/bitwiseshiftleft/sjcl/blob/master/core/ccm.js
+ *
+ * OpenSSL: https://github.com/openssl/openssl/blob/master/crypto/modes/ccm128.c
+ */
+
+import { CRYPTO_AEAD_MIC_LENGTH_BYTES, CRYPTO_AEAD_NONCE_LENGTH_BYTES } from "#crypto/CryptoConstants.js";
+import { CryptoInputError } from "#crypto/CryptoError.js";
+import { Aes } from "./Aes.js";
+import { WordArray } from "./WordArray.js";
+
+/**
+ * WARNING: Unaudited.  Consider platform replacement if available.
+ *
+ * This AES-CCM implementation is tailored for Matter:
+ *
+ * * Only supports 2-byte length
+ *
+ * * Only supports 13-byte nonce
+ *
+ * * Stores the MIC in the ciphertext buffer following the ciphertext
+ *
+ * * Our AES implementation supports multiple key sizes but only 16 bytes are legal
+ *
+ * We take a few approaches to improve performance:
+ *
+ * * Uses singletons for temporary working buffers to avoid GC
+ *
+ * * Uses Uint8Array, Int32Array and DataView depending on which is most efficient while addressing platform byte order
+ *
+ * * Performs data conversion one block at a time rather than converting entire input/output buffer
+ *
+ * * Functions are monomorphic and should JIT well
+ *
+ * Implementation notes:
+ *
+ * * Data operations operate on 128-bit blocks, either as bytes or as 4 32-bit words in platform byte order.  We share
+ *   underlying memory for both formats, but on little-endian platforms they are not directly interchangeable without a
+ *   round-trip through a DataView
+ *
+ * * We encode words as a signed Int32Array because JS bit operations operate on signed 32-bit integers and a
+ *   Uint32Array would require manually casting from signed to unsigned
+ *
+ * * Use of singleton buffers require this code to be synchronous.  If that were to change we would need to convert to a
+ *   buffer pool
+ *
+ * * Some functions only modify singleton buffers and thus do not directly return a value
+ *
+ * * We use {@link DataView} to read/write words where possible.  However, byte buffers may not align to word
+ *   boundaries.  We detect this case and manually read/write the last word
+ */
+export function Ccm(key: Uint8Array) {
+    const aes = Aes(key);
+
+    return {
+        encrypt(input: Ccm.EncryptInput): Uint8Array {
+            validateNonceAndAdata(input);
+
+            const ptLength = input.pt.length;
+            if (ptLength > MAX_PLAINTEXT_LENGTH) {
+                throw new CryptoInputError(
+                    `Cannot encrypt plaintext exceeding maximum length of ${MAX_PLAINTEXT_LENGTH}`,
+                );
+            }
+
+            // Create view for loading plaintext words in platform byte order
+            const ptView = new DataView(input.pt.buffer);
+
+            // Allocate ciphertext output buffer
+            const ct = new Uint8Array(ptLength + CRYPTO_AEAD_MIC_LENGTH_BYTES);
+            const ctView = new DataView(ct.buffer);
+
+            // Compute MIC using CBC-MAC
+            cbcMac(input, ptView, ptLength);
+
+            // Encrypt using CTR mode
+            ctr(input, ptView, ctView, ptLength, computedMic);
+
+            for (let i = 0; i < computedMic.words.length; i++) {
+                ctView.setInt32(input.pt.length + i * 4, computedMic.words[i]);
+            }
+
+            return ct;
+        },
+
+        decrypt(input: Ccm.DecryptInput): Uint8Array {
+            validateNonceAndAdata(input);
+
+            if (input.ct.length > MAX_CIPHERTEXT_LENGTH) {
+                throw new CryptoInputError(
+                    `Cannot decrypt ciphertext longer than maximum length of ${MAX_CIPHERTEXT_LENGTH}`,
+                );
+            }
+
+            const ptLength = input.ct.length - CRYPTO_AEAD_MIC_LENGTH_BYTES;
+
+            if (ptLength < 0) {
+                throw new CryptoInputError(
+                    `Cannot decrypt ciphertext shorter than minimum length of ${CRYPTO_AEAD_MIC_LENGTH_BYTES}`,
+                );
+            }
+
+            // Extract ciphertext (zero copy using a DataView) and MIC from input ciphertext
+            const ctView = new DataView(input.ct.buffer, input.ct.byteOffset, ptLength);
+            WordArray.bytesToBlock(
+                new DataView(input.ct.buffer, input.ct.byteOffset, input.ct.byteLength),
+                inputMic.words,
+                ptLength,
+            );
+
+            // Allocate plaintext output buffer
+            const pt = new Uint8Array(ptLength);
+            const ptView = new DataView(pt.buffer);
+
+            // Decrypt using CTR mode
+            ctr(input, ctView, ptView, ptLength, inputMic);
+
+            // Compute MIC using CBC-MAC
+            cbcMac(input, ptView, ptLength);
+
+            for (let i = 0; i < computedMic.words.length; i++) {
+                if (inputMic.words[i] !== computedMic.words[i]) {
+                    throw new CryptoInputError("Message authentication failed due to invalid signature");
+                }
+            }
+
+            return pt;
+        },
+    };
+
+    /**
+     * CBC-MAC MIC computation.
+     *
+     * This includes header generation then CBC-MAC passes on the header, adata and plaintext.
+     *
+     * Writes to {@link computedMic}.
+     */
+    function cbcMac(input: Ccm.Input, pt: DataView, ptLength: number) {
+        const adataLength = input.adata?.length;
+
+        // Create the header; first add the flag byte and nonce
+        computedMic.bytes[0] =
+            (adataLength ? 1 << 6 : 0) | ((CRYPTO_AEAD_MIC_LENGTH_BYTES - 2) << 2) | (BYTES_IN_LENGTH - 1);
+        computedMic.bytes.set(input.nonce, 1);
+
+        // Convert header to platform byte order
+        WordArray.bytesToBlock(computedMic.view, computedMic.words); // Convert to platform byte order
+
+        // Add plaintext length (must occur after conversion to platform byte order)
+        computedMic.words[3] = (computedMic.words[3] & 0xffff0000) | ptLength;
+
+        // Start computation
+        aes.encrypt(computedMic.words);
+
+        // Add adata
+        if (adataLength) {
+            // Add length (2 bytes) + first 14 bytes of adata
+            tempBlock1.view.setInt16(0, input.adata!.length);
+            for (let i = 0; i < 14; i++) {
+                tempBlock1.bytes[i + 2] = i < adataLength ? input.adata![i] : 0;
+            }
+
+            // Flip to platform byte order and add
+            WordArray.bytesToBlock(tempBlock1.view, tempBlock1.words);
+            add();
+
+            // Add remainder of adata
+            if (adataLength > 14) {
+                const adataView = new DataView(input.adata!.buffer);
+                for (let i = 14; i < adataLength; i += 16) {
+                    WordArray.bytesToBlock(adataView, tempBlock1.words, i);
+                    add();
+                }
+            }
+        }
+
+        // Add plaintext
+        if (ptLength) {
+            for (let i = 0; i < ptLength; i += 16) {
+                WordArray.bytesToBlock(pt, tempBlock1.words, i);
+                add();
+            }
+        }
+
+        function add() {
+            computedMic.words[0] ^= tempBlock1.words[0];
+            computedMic.words[1] ^= tempBlock1.words[1];
+            computedMic.words[2] ^= tempBlock1.words[2];
+            computedMic.words[3] ^= tempBlock1.words[3];
+            aes.encrypt(computedMic.words);
+        }
+    }
+
+    /**
+     * A CTR mode implementation specialized for CCM.
+     *
+     * Used both for encryption and decryption.
+     *
+     * Encrypts/decrypts {@link ptLength} bytes of {@link input} into {@link output}.  Also encrypts/decrypts
+     * {@link mic} in place.
+     */
+    function ctr(input: Ccm.Input, from: DataView, to: DataView, ptLength: number, mic: SingletonBuffer) {
+        // Initialize the counter (big endian)
+        tempBlock1.bytes[0] = BYTES_IN_LENGTH - 1;
+        tempBlock1.bytes.set(input.nonce, 1); // Bytes 1 - 13
+        tempBlock1.bytes[14] = 0;
+        tempBlock1.bytes[15] = 0;
+
+        // Change to platform byte order for CTR computation
+        WordArray.bytesToBlock(tempBlock1.view, ctrBlock.words);
+
+        // Encrypt the MIC
+        aes.encrypt(ctrBlock.words, tempBlock1.words);
+        mic.words[0] ^= tempBlock1.words[0];
+        mic.words[1] ^= tempBlock1.words[1];
+        mic.words[2] ^= tempBlock1.words[2];
+        mic.words[3] ^= tempBlock1.words[3];
+
+        // Process the data
+        for (let i = 0; i < ptLength; ) {
+            ctrBlock.words[3]++;
+
+            // Convert input block to platform-endian words
+            WordArray.bytesToBlock(from, tempBlock1.words, i);
+
+            // Encrypt CTR
+            aes.encrypt(ctrBlock.words, tempBlock2.words);
+
+            // Copy block to output buffer
+            for (let j = 0; j < 4 && i < ptLength; j++, i += 4) {
+                const tempWord = tempBlock2.words[j];
+                if (i + 4 < ptLength) {
+                    // Full word
+                    to.setInt32(i, from.getInt32(i) ^ tempWord);
+                } else {
+                    // Partial word
+                    const partial = WordArray.readPartialWord(from, i, ptLength - i) ^ tempWord;
+                    WordArray.writePartialWord(partial, to, i, ptLength - i);
+                }
+            }
+        }
+    }
+}
+
+export namespace Ccm {
+    export interface Input {
+        nonce: Uint8Array;
+        adata: Uint8Array | undefined; // Do not use ? to ensure object shape remains stable
+    }
+
+    export interface EncryptInput extends Input {
+        /**
+         * Plaintext
+         */
+        pt: Uint8Array;
+    }
+
+    export interface DecryptInput extends Input {
+        /**
+         * Ciphertext + tag
+         */
+        ct: Uint8Array;
+    }
+}
+
+export const BYTES_IN_LENGTH = 2; // NIST q parameter, length of payload length; only 2 bytes supported by Matter
+export const MAX_CIPHERTEXT_LENGTH = Math.pow(2, BYTES_IN_LENGTH * 8);
+export const MAX_PLAINTEXT_LENGTH = MAX_CIPHERTEXT_LENGTH - CRYPTO_AEAD_MIC_LENGTH_BYTES;
+
+/**
+ * A buffer used for encryption.
+ *
+ * We encrypt/decrypt synchronously, so it is safe to use singletons to avoid GC hit.
+ */
+class SingletonBuffer {
+    #words?: Int32Array;
+    #bytes?: Uint8Array;
+    #view?: DataView;
+
+    get words() {
+        if (this.#words === undefined) {
+            this.#words = new Int32Array(4);
+        }
+        return this.#words;
+    }
+
+    get bytes() {
+        if (this.#bytes === undefined) {
+            this.#bytes = new Uint8Array(this.words.buffer);
+        }
+        return this.#bytes;
+    }
+
+    /**
+     * The word and byte views of the buffer above are insufficient because we must account for platform endianness.  So
+     * we also make a DataView available.
+     */
+    get view() {
+        if (this.#view === undefined) {
+            this.#view = new DataView(this.words.buffer);
+        }
+        return this.#view;
+    }
+}
+
+/**
+ * The "MIC" is the 16-byte authentication tag, called the "MAC" in the NIST spec and "tag" in SJCL.  We store
+ * concatenated to the end of the ciphertext as required by Matter.
+ *
+ * This buffer is for the MIC we compute from the input plaintext.
+ */
+const computedMic = new SingletonBuffer();
+
+/**
+ * This buffer is for the MIC we receive as input on decryption.
+ */
+const inputMic = new SingletonBuffer();
+
+/**
+ * CTR block buffer.
+ */
+const ctrBlock = new SingletonBuffer();
+
+/**
+ * General-purpose block buffer.
+ */
+const tempBlock1 = new SingletonBuffer();
+
+/**
+ * General-purpose block buffer.
+ */
+const tempBlock2 = new SingletonBuffer();
+
+function validateNonceAndAdata(input: Ccm.Input) {
+    if (input.nonce.length !== CRYPTO_AEAD_NONCE_LENGTH_BYTES) {
+        throw new CryptoInputError("Nonce must be 13 bytes");
+    }
+
+    if (input.adata && input.adata.length > 0xffff) {
+        throw new CryptoInputError(`Associated adata exceeds maximum length of ${MAX_PLAINTEXT_LENGTH}`);
+    }
+}

package/src/crypto/aes/README.md

@@ -0,0 +1,4 @@
+This pure-JS AES-CCM implementation is necessary because the Web Crypto does not support AES CCM mode.
+
+Implemented based on the NIST and Matter specifications, and SJCL and OpenSSL as reference implementations.  See source
+files for specific links.

package/src/crypto/aes/WordArray.ts

@@ -0,0 +1,105 @@
+/**
+ * @license
+ * Copyright 2022-2025 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * A 32-bit word array for AES algorithm.
+ *
+ * Note that we use signed integers so we can use JS bit shifts with signed 32-bit numbers.
+ */
+export type WordArray = Int32Array;
+
+export function WordArray(length: number): WordArray {
+    return new Int32Array(length);
+}
+
+const endianConversionView = new DataView(new ArrayBuffer(4));
+const endianConversionBytes = new Uint8Array(endianConversionView.buffer);
+
+export namespace WordArray {
+    export function fromByteArray(bytes: Uint8Array, alignment = 1) {
+        return fromByteView(new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength), alignment);
+    }
+
+    export function fromByteView(bytes: DataView, alignment = 1) {
+        const inputBytes = bytes.byteLength;
+        const allocWords = Math.ceil(inputBytes / 4 / alignment) * alignment;
+        const result = WordArray(allocWords);
+
+        // Convert full words from bytes to words
+        let i = 0;
+        for (; i + 4 <= inputBytes; i += 4) {
+            result[i / 4] = bytes.getInt32(i);
+        }
+
+        // If byte array is not aligned to words, compute final word manually
+        if (i < inputBytes) {
+            result[i / 4] = readPartialWord(bytes, i, inputBytes - i);
+        }
+
+        return result;
+    }
+
+    /**
+     * Copy bytes into a 4-word block.  If the input bytes is too short sets missing bytes to zero.
+     */
+    export function bytesToBlock(bytes: DataView, block: WordArray, byteOffset?: number) {
+        if (byteOffset === undefined) {
+            byteOffset = 0;
+        }
+        for (let i = 0; i < 4; i++, byteOffset += 4) {
+            if (byteOffset + 4 <= bytes.byteLength) {
+                block[i] = bytes.getInt32(byteOffset);
+            } else if (byteOffset >= bytes.byteLength) {
+                block[i] = 0;
+            } else {
+                block[i] = readPartialWord(bytes, byteOffset);
+            }
+        }
+    }
+
+    /**
+     * Read a word from a byte array that may be smaller than four bytes.  On little-endian platforms, flips the byte
+     * order.
+     */
+    export function readPartialWord(
+        bytes: DataView,
+        offset: number,
+        bytesAvailable = bytes.byteLength - offset,
+    ): number {
+        // Write big-endian word to conversion buffer
+        for (let i = 0; i < 4; i++) {
+            if (i < bytesAvailable) {
+                endianConversionBytes[i] = bytes.getUint8(offset + i);
+            } else {
+                endianConversionBytes[i] = 0;
+            }
+        }
+
+        // Flip to platform endianness
+        return endianConversionView.getUint32(0);
+    }
+
+    /**
+     * Inverse of {@link writePartialWord}.
+     */
+    export function writePartialWord(
+        word: number,
+        bytes: DataView,
+        offset: number,
+        bytesAvailable = Math.max(bytes.byteLength - offset, 4),
+    ) {
+        endianConversionView.setUint32(0, word);
+        endianConversionBytes[0] = word >>> 24;
+        endianConversionBytes[1] = (word >> 16) & 0xff;
+        endianConversionBytes[2] = (word >> 8) & 0xff;
+        endianConversionBytes[3] = word & 0xff;
+
+        // Buffer is now LE if platform is LE but this will flip
+        for (let i = 0; i < bytesAvailable; i++) {
+            bytes.setUint8(offset + i, endianConversionBytes[i]);
+        }
+    }
+}

package/src/crypto/index.ts

@@ -6,5 +6,8 @@
 
 export * from "./Crypto.js";
 export * from "./CryptoConstants.js";
+export * from "./CryptoError.js";
 export * from "./Key.js";
+export * from "./nonentropic.js";
 export * from "./Spake2p.js";
+export * from "./StandardCrypto.js";

package/src/crypto/nonentropic.ts

@@ -0,0 +1,65 @@
+/**
+ * @license
+ * Copyright 2022-2025 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ImplementationError } from "#MatterError.js";
+import { MaybePromise } from "#util/Promises.js";
+import { Crypto, ec } from "./Crypto.js";
+import { CurveType, Key, KeyType, PrivateKey } from "./Key.js";
+
+/**
+ * WARNING: ONLY FOR USE IN PROTECTED TESTING ENVIRONMENTS WHERE SECURITY IS NOT A CONCERN
+ *
+ * Execute {@link actor} with sources of entropy replaced to produce stable values based on an input index.
+ *
+ * This is useful in testing environments where Matter logic is difficult to test with true entropy.
+ *
+ * I believe there are some crypto functions that are not fully mocked here but this covers current test cases.
+ */
+export function nonentropic<T>(index: number, actor: () => T): T {
+    if (index < 0 || index > 255) {
+        throw new ImplementationError(`Index for stable crypto must be 0-255`);
+    }
+
+    const crypto = Crypto.default;
+    const { getRandomData, createKeyPair } = crypto;
+    let isAsync = false;
+
+    try {
+        // Create random data consisting of index repeated
+        crypto.getRandomData = function getRandomDataNONENTROPIC(length) {
+            const result = new Uint8Array(length);
+            result.fill(index);
+            return result;
+        };
+
+        // Ensure EC key generation uses our own "entropy" source rather than the platform's
+        crypto.createKeyPair = function getRandomDataNONENTROPIC() {
+            const privateBits = ec.mapHashToField(crypto.getRandomData(48), ec.p256.CURVE.n);
+            return Key({
+                kty: KeyType.EC,
+                crv: CurveType.p256,
+                privateBits,
+            }) as PrivateKey;
+        };
+
+        let result = actor();
+        if (MaybePromise.is(result)) {
+            isAsync = true;
+            result = Promise.resolve(result).finally(revert) as T;
+        }
+
+        return result;
+    } finally {
+        if (!isAsync) {
+            revert();
+        }
+    }
+
+    function revert() {
+        crypto.getRandomData = getRandomData;
+        crypto.createKeyPair = createKeyPair;
+    }
+}

package/src/environment/Environment.ts

@@ -4,7 +4,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Boot } from "#util/Boot.js";
 import { MaybePromise } from "#util/Promises.js";
 import { DiagnosticSource } from "../log/DiagnosticSource.js";
 import { Logger } from "../log/Logger.js";
@@ -242,8 +241,4 @@ export class Environment {
     }
 }
 
-let global: Environment;
-
-Boot.init(() => {
-    global = new Environment("default");
-});
+let global = new Environment("default");

package/src/environment/RuntimeService.ts

@@ -155,16 +155,16 @@ export class RuntimeService implements Multiplex {
     }
 
     /**
-     * Interrupt handler.  Triggered by e.g. on SIGINT on unixish systems.
+     * Interrupt handler.  Triggered by e.g. SIGINT on unixish systems.
      *
      * The default implementation cancels the runtime.
-     *
-     * @returns a boolean indicating whether to continue trapping interrupts
      */
-    interrupt(): boolean {
+    interrupt() {
         this.cancel();
 
-        return false;
+        if (typeof MatterHooks !== "undefined") {
+            MatterHooks.interrupt();
+        }
     }
 
     /**

package/src/environment/VariableService.ts

@@ -158,6 +158,7 @@ export class VariableService {
 
             case null:
             case 0:
+            case "0":
             case false:
             case "false":
             case "off":

package/src/log/LogFormat.ts

@@ -557,8 +557,8 @@ function valueFor(value: unknown) {
     if (typeof value !== "object" || value === null) {
         return value;
     }
-    const proxied = (value as Diagnostic)[Diagnostic.value];
-    if (proxied) {
+    if (Diagnostic.value in value) {
+        const proxied = (value as Diagnostic)[Diagnostic.value];
         if (proxied === value) {
             throw new InternalError("Diagnostic value proxies to itself");
         }
@@ -586,9 +586,17 @@ function presentationFor(value: unknown) {
 /**
  * Render a value with presentation support
  */
-function renderDiagnostic(value: unknown, formatter: Formatter): string {
-    const presentation = presentationFor(value);
-    value = valueFor(value);
+function renderDiagnostic(value: unknown, formatter: Formatter, ignorePresentation?: boolean): string {
+    const presentation = ignorePresentation ? undefined : presentationFor(value);
+
+    const logValue = valueFor(value);
+    if (logValue === value) {
+        // Ignore presentation when we recurse or it would be an infinite loop
+        ignorePresentation = true;
+    } else {
+        ignorePresentation = undefined;
+        value = logValue;
+    }
 
     switch (presentation) {
         case undefined:
@@ -610,22 +618,22 @@ function renderDiagnostic(value: unknown, formatter: Formatter): string {
             return renderValue(value, formatter, true);
 
         case Diagnostic.Presentation.Strong:
-            return formatter.strong(() => renderDiagnostic(value, formatter));
+            return formatter.strong(() => renderDiagnostic(value, formatter, ignorePresentation));
 
         case Diagnostic.Presentation.Weak:
-            return formatter.weak(() => renderDiagnostic(value, formatter));
+            return formatter.weak(() => renderDiagnostic(value, formatter, ignorePresentation));
 
         case Diagnostic.Presentation.Added:
-            return formatter.added(() => renderDiagnostic(value, formatter));
+            return formatter.added(() => renderDiagnostic(value, formatter, ignorePresentation));
 
         case Diagnostic.Presentation.Deleted:
-            return formatter.deleted(() => renderDiagnostic(value, formatter));
+            return formatter.deleted(() => renderDiagnostic(value, formatter, ignorePresentation));
 
         case Diagnostic.Presentation.Flag:
             return (value as string).length ? formatter.keylike(value as string) : "";
 
         case Diagnostic.Presentation.Error:
-            return formatter.error(() => renderDiagnostic(value, formatter));
+            return formatter.error(() => renderDiagnostic(value, formatter, ignorePresentation));
 
         case Diagnostic.Presentation.Via:
             return formatter.via(`${value}`);
@@ -642,7 +650,7 @@ function renderDiagnostic(value: unknown, formatter: Formatter): string {
         case Lifecycle.Status.Active:
         case Lifecycle.Status.Crashed:
         case Lifecycle.Status.Destroyed:
-            return formatter.status(presentation, () => renderDiagnostic(value, formatter));
+            return formatter.status(presentation, () => renderDiagnostic(value, formatter, ignorePresentation));
 
         default:
             throw new ImplementationError(`Unsupported diagnostic presentation "${presentation}"`);

package/src/net/Network.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { MatterError, NoProviderError } from "../MatterError.js";
+import { MatterError } from "../MatterError.js";
 import { MaybePromise } from "../util/Promises.js";
 import { UdpChannel, UdpChannelOptions } from "./UdpChannel.js";
 
@@ -57,13 +57,7 @@ export type NetworkInterfaceDetails = {
 };
 
 export type NetworkInterfaceDetailed = NetworkInterface & NetworkInterfaceDetails;
-
 export abstract class Network {
-    // TODO - remove this singleton
-    static get: () => Network = () => {
-        throw new NoProviderError("No provider configured");
-    };
-
     abstract getNetInterfaces(configuration?: NetworkInterface[]): MaybePromise<NetworkInterface[]>;
     abstract getIpMac(netInterface: string): MaybePromise<NetworkInterfaceDetails | undefined>;
     abstract createUdpChannel(options: UdpChannelOptions): Promise<UdpChannel>;