@matter/general 0.11.0-alpha.0-20241005-e3e4e4a7a

package/dist/cjs/crypto/Crypto.d.ts

@@ -0,0 +1,169 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as mod from "@noble/curves/abstract/modular";
+import * as utils from "@noble/curves/abstract/utils";
+import { MatterError } from "../MatterError.js";
+import { PrivateKey } from "./Key.js";
+export declare const ec: {
+    mod(a: bigint, b: bigint): bigint;
+    pow(num: bigint, power: bigint, modulo: bigint): bigint;
+    pow2(x: bigint, power: bigint, modulo: bigint): bigint;
+    invert(number: bigint, modulo: bigint): bigint;
+    tonelliShanks(P: bigint): <T>(Fp: mod.IField<T>, n: T) => T;
+    FpSqrt(P: bigint): <T>(Fp: mod.IField<T>, n: T) => T;
+    validateField<T>(field: mod.IField<T>): mod.IField<T>;
+    FpPow<T>(f: mod.IField<T>, num: T, power: bigint): T;
+    FpInvertBatch<T>(f: mod.IField<T>, nums: T[]): T[];
+    FpDiv<T>(f: mod.IField<T>, lhs: T, rhs: T | bigint): T;
+    FpLegendre(order: bigint): <T>(f: mod.IField<T>, x: T) => T;
+    FpIsSquare<T>(f: mod.IField<T>): (x: T) => boolean;
+    nLength(n: bigint, nBitLength?: number): {
+        nBitLength: number;
+        nByteLength: number;
+    };
+    Field(ORDER: bigint, bitLen?: number, isLE?: boolean, redef?: Partial<mod.IField<bigint>>): Readonly<mod.IField<bigint> & Required<Pick<mod.IField<bigint>, "isOdd">>>;
+    FpSqrtOdd<T>(Fp: mod.IField<T>, elm: T): T;
+    FpSqrtEven<T>(Fp: mod.IField<T>, elm: T): T;
+    hashToPrivateScalar(hash: string | Uint8Array, groupOrder: bigint, isLE?: boolean): bigint;
+    getFieldBytesLength(fieldOrder: bigint): number;
+    getMinHashLength(fieldOrder: bigint): number;
+    mapHashToField(key: Uint8Array, fieldOrder: bigint, isLE?: boolean): Uint8Array;
+    isNegativeLE: (num: bigint, modulo: bigint) => boolean;
+    isBytes(a: unknown): a is Uint8Array;
+    abytes(item: unknown): void;
+    abool(title: string, value: boolean): void;
+    bytesToHex(bytes: Uint8Array): string;
+    numberToHexUnpadded(num: number | bigint): string;
+    hexToNumber(hex: string): bigint;
+    hexToBytes(hex: string): Uint8Array;
+    bytesToNumberBE(bytes: Uint8Array): bigint;
+    bytesToNumberLE(bytes: Uint8Array): bigint;
+    numberToBytesBE(n: number | bigint, len: number): Uint8Array;
+    numberToBytesLE(n: number | bigint, len: number): Uint8Array;
+    numberToVarBytesBE(n: number | bigint): Uint8Array;
+    ensureBytes(title: string, hex: utils.Hex, expectedLength?: number): Uint8Array;
+    concatBytes(...arrays: Uint8Array[]): Uint8Array;
+    equalBytes(a: Uint8Array, b: Uint8Array): boolean;
+    utf8ToBytes(str: string): Uint8Array;
+    inRange(n: bigint, min: bigint, max: bigint): boolean;
+    aInRange(title: string, n: bigint, min: bigint, max: bigint): void;
+    bitLen(n: bigint): number;
+    bitGet(n: bigint, pos: number): bigint;
+    bitSet(n: bigint, pos: number, value: boolean): bigint;
+    createHmacDrbg<T>(hashLen: number, qByteLen: number, hmacFn: (key: Uint8Array, ...messages: Uint8Array[]) => Uint8Array): (seed: Uint8Array, predicate: (v: Uint8Array) => T | undefined) => T;
+    validateObject<T extends Record<string, any>>(object: T, validators: { [K in keyof T]?: "string" | "bigint" | "boolean" | "function" | "hash" | "stringOrUint8Array" | "isSafeInteger" | "array" | "field" | undefined; }, optValidators?: { [K in keyof T]?: "string" | "bigint" | "boolean" | "function" | "hash" | "stringOrUint8Array" | "isSafeInteger" | "array" | "field" | undefined; }): T;
+    memoized<T extends object, R, O extends any[]>(fn: (arg: T, ...args: O) => R): (arg: T, ...args: O) => R;
+    bitMask: (n: number) => bigint;
+    notImplemented: () => never;
+    p256: Readonly<{
+        create: (hash: import("@noble/curves/abstract/utils").CHash) => import("@noble/curves/abstract/weierstrass").CurveFn;
+        CURVE: ReturnType<(curve: import("@noble/curves/abstract/weierstrass").CurveType) => Readonly<{
+            readonly nBitLength: number;
+            readonly nByteLength: number;
+            readonly Fp: import("@noble/curves/abstract/modular").IField<bigint>;
+            readonly n: bigint;
+            readonly h: bigint;
+            readonly hEff?: bigint;
+            readonly Gx: bigint;
+            readonly Gy: bigint;
+            readonly allowInfinityPoint?: boolean;
+            readonly a: bigint;
+            readonly b: bigint;
+            readonly allowedPrivateKeyLengths?: readonly number[];
+            readonly wrapPrivateKey?: boolean;
+            readonly endo?: {
+                beta: bigint;
+                splitScalar: (k: bigint) => {
+                    k1neg: boolean;
+                    k1: bigint;
+                    k2neg: boolean;
+                    k2: bigint;
+                };
+            };
+            readonly isTorsionFree?: ((c: import("@noble/curves/abstract/weierstrass").ProjConstructor<bigint>, point: import("@noble/curves/abstract/weierstrass").ProjPointType<bigint>) => boolean) | undefined;
+            readonly clearCofactor?: ((c: import("@noble/curves/abstract/weierstrass").ProjConstructor<bigint>, point: import("@noble/curves/abstract/weierstrass").ProjPointType<bigint>) => import("@noble/curves/abstract/weierstrass").ProjPointType<bigint>) | undefined;
+            readonly hash: import("@noble/curves/abstract/utils").CHash;
+            readonly hmac: (key: Uint8Array, ...messages: Uint8Array[]) => Uint8Array;
+            readonly randomBytes: (bytesLength?: number) => Uint8Array;
+            lowS: boolean;
+            readonly bits2int?: (bytes: Uint8Array) => bigint;
+            readonly bits2int_modN?: (bytes: Uint8Array) => bigint;
+            readonly p: bigint;
+        }>>;
+        getPublicKey: (privateKey: import("@noble/curves/abstract/utils").PrivKey, isCompressed?: boolean) => Uint8Array;
+        getSharedSecret: (privateA: import("@noble/curves/abstract/utils").PrivKey, publicB: import("@noble/curves/abstract/utils").Hex, isCompressed?: boolean) => Uint8Array;
+        sign: (msgHash: import("@noble/curves/abstract/utils").Hex, privKey: import("@noble/curves/abstract/utils").PrivKey, opts?: import("@noble/curves/abstract/weierstrass").SignOpts) => import("@noble/curves/abstract/weierstrass").RecoveredSignatureType;
+        verify: (signature: import("@noble/curves/abstract/utils").Hex | {
+            r: bigint;
+            s: bigint;
+        }, msgHash: import("@noble/curves/abstract/utils").Hex, publicKey: import("@noble/curves/abstract/utils").Hex, opts?: import("@noble/curves/abstract/weierstrass").VerOpts) => boolean;
+        ProjectivePoint: import("@noble/curves/abstract/weierstrass").ProjConstructor<bigint>;
+        Signature: import("@noble/curves/abstract/weierstrass").SignatureConstructor;
+        utils: {
+            normPrivateKeyToScalar: (key: import("@noble/curves/abstract/utils").PrivKey) => bigint;
+            isValidPrivateKey(privateKey: import("@noble/curves/abstract/utils").PrivKey): boolean;
+            randomPrivateKey: () => Uint8Array;
+            precompute: (windowSize?: number, point?: import("@noble/curves/abstract/weierstrass").ProjPointType<bigint>) => import("@noble/curves/abstract/weierstrass").ProjPointType<bigint>;
+        };
+    }>;
+};
+export declare const CRYPTO_RANDOM_LENGTH = 32;
+export declare const CRYPTO_ENCRYPT_ALGORITHM = "aes-128-ccm";
+export declare const CRYPTO_HASH_ALGORITHM = "sha256";
+export declare const CRYPTO_EC_CURVE = "prime256v1";
+export declare const CRYPTO_EC_KEY_BYTES = 32;
+export declare const CRYPTO_AUTH_TAG_LENGTH = 16;
+export declare const CRYPTO_SYMMETRIC_KEY_LENGTH = 16;
+export type CryptoDsaEncoding = "ieee-p1363" | "der";
+export declare class CryptoVerifyError extends MatterError {
+}
+export declare abstract class Crypto {
+    static get: () => Crypto;
+    abstract encrypt(key: Uint8Array, data: Uint8Array, nonce: Uint8Array, aad?: Uint8Array): Uint8Array;
+    static readonly encrypt: (key: Uint8Array, data: Uint8Array, nonce: Uint8Array, aad?: Uint8Array) => Uint8Array;
+    abstract decrypt(key: Uint8Array, data: Uint8Array, nonce: Uint8Array, aad?: Uint8Array): Uint8Array;
+    static readonly decrypt: (key: Uint8Array, data: Uint8Array, nonce: Uint8Array, aad?: Uint8Array) => Uint8Array;
+    abstract getRandomData(length: number): Uint8Array;
+    static readonly getRandomData: (length: number) => Uint8Array;
+    static readonly getRandom: () => Uint8Array;
+    static readonly getRandomUInt16: () => number;
+    static readonly getRandomUInt32: () => number;
+    static readonly getRandomBigUInt64: () => bigint;
+    static readonly getRandomBigInt: (size: number, maxValue?: bigint) => bigint;
+    abstract ecdhGeneratePublicKey(): {
+        publicKey: Uint8Array;
+        ecdh: any;
+    };
+    static readonly ecdhGeneratePublicKey: () => {
+        publicKey: Uint8Array;
+        ecdh: any;
+    };
+    abstract ecdhGeneratePublicKeyAndSecret(peerPublicKey: Uint8Array): {
+        publicKey: Uint8Array;
+        sharedSecret: Uint8Array;
+    };
+    static readonly ecdhGeneratePublicKeyAndSecret: (peerPublicKey: Uint8Array) => {
+        publicKey: Uint8Array;
+        sharedSecret: Uint8Array;
+    };
+    abstract ecdhGenerateSecret(peerPublicKey: Uint8Array, ecdh: any): Uint8Array;
+    static readonly ecdhGenerateSecret: (peerPublicKey: Uint8Array, ecdh: any) => Uint8Array;
+    abstract hash(data: Uint8Array | Uint8Array[]): Uint8Array;
+    static readonly hash: (data: Uint8Array | Uint8Array[]) => Uint8Array;
+    abstract pbkdf2(secret: Uint8Array, salt: Uint8Array, iteration: number, keyLength: number): Promise<Uint8Array>;
+    static readonly pbkdf2: (secret: Uint8Array, salt: Uint8Array, iteration: number, keyLength: number) => Promise<Uint8Array>;
+    abstract hkdf(secret: Uint8Array, salt: Uint8Array, info: Uint8Array, length?: number): Promise<Uint8Array>;
+    static readonly hkdf: (secret: Uint8Array, salt: Uint8Array, info: Uint8Array, length?: number) => Promise<Uint8Array>;
+    abstract hmac(key: Uint8Array, data: Uint8Array): Uint8Array;
+    static readonly hmac: (key: Uint8Array, data: Uint8Array) => Uint8Array;
+    abstract sign(privateKey: JsonWebKey, data: Uint8Array | Uint8Array[], dsaEncoding?: CryptoDsaEncoding): Uint8Array;
+    static readonly sign: (privateKey: JsonWebKey, data: Uint8Array | Uint8Array[], dsaEncoding?: CryptoDsaEncoding) => Uint8Array;
+    abstract verify(publicKey: JsonWebKey, data: Uint8Array, signature: Uint8Array, dsaEncoding?: CryptoDsaEncoding): void;
+    static readonly verify: (publicKey: JsonWebKey, data: Uint8Array, signature: Uint8Array, dsaEncoding?: CryptoDsaEncoding) => void;
+    abstract createKeyPair(): PrivateKey;
+    static readonly createKeyPair: () => PrivateKey;
+}
+//# sourceMappingURL=Crypto.d.ts.map

package/dist/cjs/crypto/Crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Crypto.d.ts","sourceRoot":"","sources":["../../../src/crypto/Crypto.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,GAAG,MAAM,gCAAgC,CAAC;AACtD,OAAO,KAAK,KAAK,MAAM,8BAA8B,CAAC;AAEtD,OAAO,EAAE,WAAW,EAAmB,MAAM,mBAAmB,CAAC;AAGjE,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEtC,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mFAsEW,GAAI;;gEAwBiF,GAAI,yBACjG,GAAI;;;;8BA1Gf,8BAAqB,mBAGzB,oCAA2B;yCACP,oCAA2B;;;gCAGlC,gCAAuB;;;yBAIvC,CAAA;;;uCAOG,CAAC;;;6CAEM,CAAC;mCACO,CAAC;yBACN,CAAA;;;;;;;;;kCAOkB,CAAC,cACxB,oCAA0B,yCAG5B,oCAA2B;kCAC1B,CAAC,cAAc,oCAA2B,yCAA0C,oCAA0B,mCACnF,oCAE3B;kCAAoE,8BAAqB;6CACzD,GAAI;8CACnC,CAAD;;6BAEmB,CAAC;kCACO,CAAC;;;0CAEG,8BAAqB,uBAAuB,CAAC;2CAEpC,8BAC/B,2BAA2B,8BAAqB,mBAE5D,CAAJ;+BACQ,8BAAc,uBAAuB,8BAAqB,eAAe,CAAC,SAE3E,oCAA2B,sBAC1B,oCAAoB;mCAExB,8BAAkB;;;2BACd,8BAAqB,yBACf,8BAAqB,WACvB,CAAH,SAAU,oCAA0B;gCAGjC,oCAAc;0BACd,oCAAkB;;iDAIc,8BAAqB;iDACT,8BAAqB;;mCAGvC,CAAC,eAAe,CAAC,SAAS,oCAC/C,mCACK,oCAEf;;;CA3DN,CAAC;AAEF,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,eAAO,MAAM,wBAAwB,gBAAgB,CAAC;AACtD,eAAO,MAAM,qBAAqB,WAAW,CAAC;AAC9C,eAAO,MAAM,eAAe,eAAe,CAAC;AAC5C,eAAO,MAAM,mBAAmB,KAAK,CAAC;AACtC,eAAO,MAAM,sBAAsB,KAAK,CAAC;AACzC,eAAO,MAAM,2BAA2B,KAAK,CAAC;AAC9C,MAAM,MAAM,iBAAiB,GAAG,YAAY,GAAG,KAAK,CAAC;AAErD,qBAAa,iBAAkB,SAAQ,WAAW;CAAG;AAErD,8BAAsB,MAAM;IACxB,MAAM,CAAC,GAAG,EAAE,MAAM,MAAM,CAEtB;IAEF,QAAQ,CAAC,OAAO,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,CAAC,EAAE,UAAU,GAAG,UAAU;IACpG,MAAM,CAAC,QAAQ,CAAC,OAAO,QAAS,UAAU,QAAQ,UAAU,SAAS,UAAU,QAAQ,UAAU,KAAG,UAAU,CAC9D;IAEhD,QAAQ,CAAC,OAAO,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,CAAC,EAAE,UAAU,GAAG,UAAU;IACpG,MAAM,CAAC,QAAQ,CAAC,OAAO,QAAS,UAAU,QAAQ,UAAU,SAAS,UAAU,QAAQ,UAAU,KAAG,UAAU,CAC9D;IAEhD,QAAQ,CAAC,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU;IAClD,MAAM,CAAC,QAAQ,CAAC,aAAa,WAAY,MAAM,KAAG,UAAU,CAAuC;IAEnG,MAAM,CAAC,QAAQ,CAAC,SAAS,QAAO,UAAU,CAAqD;IAE/F,MAAM,CAAC,QAAQ,CAAC,eAAe,QAAO,MAAM,CACkC;IAE9E,MAAM,CAAC,QAAQ,CAAC,eAAe,QAAO,MAAM,CACkC;IAE9E,MAAM,CAAC,QAAQ,CAAC,kBAAkB,QAAO,MAAM,CAC+B;IAE9E,MAAM,CAAC,QAAQ,CAAC,eAAe,SAAU,MAAM,aAAa,MAAM,KAAG,MAAM,CASzE;IAEF,QAAQ,CAAC,qBAAqB,IAAI;QAAE,SAAS,EAAE,UAAU,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAE;IACtE,MAAM,CAAC,QAAQ,CAAC,qBAAqB,QAAO;QAAE,SAAS,EAAE,UAAU,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAE,CACvC;IAEzC,QAAQ,CAAC,8BAA8B,CAAC,aAAa,EAAE,UAAU,GAAG;QAChE,SAAS,EAAE,UAAU,CAAC;QACtB,YAAY,EAAE,UAAU,CAAC;KAC5B;IACD,MAAM,CAAC,QAAQ,CAAC,8BAA8B,kBAC3B,UAAU,KAC1B;QAAE,SAAS,EAAE,UAAU,CAAC;QAAC,YAAY,EAAE,UAAU,CAAA;KAAE,CACS;IAE/D,QAAQ,CAAC,kBAAkB,CAAC,aAAa,EAAE,UAAU,EAAE,IAAI,EAAE,GAAG,GAAG,UAAU;IAC7E,MAAM,CAAC,QAAQ,CAAC,kBAAkB,kBAAmB,UAAU,QAAQ,GAAG,KAAG,UAAU,CAC9B;IAEzD,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,EAAE,GAAG,UAAU;IAC1D,MAAM,CAAC,QAAQ,CAAC,IAAI,SAAU,UAAU,GAAG,UAAU,EAAE,KAAG,UAAU,CAA4B;IAEhG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAChH,MAAM,CAAC,QAAQ,CAAC,MAAM,WACV,UAAU,QACZ,UAAU,aACL,MAAM,aACN,MAAM,KAClB,OAAO,CAAC,UAAU,CAAC,CAA4D;IAElF,QAAQ,CAAC,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAC3G,MAAM,CAAC,QAAQ,CAAC,IAAI,WACR,UAAU,QACZ,UAAU,QACV,UAAU,WACP,MAAM,KAChB,OAAO,CAAC,UAAU,CAAC,CAAkD;IAExE,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,GAAG,UAAU;IAC5D,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAS,UAAU,QAAQ,UAAU,KAAG,UAAU,CAAiC;IAEvG,QAAQ,CAAC,IAAI,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,GAAG,UAAU,EAAE,EAAE,WAAW,CAAC,EAAE,iBAAiB,GAAG,UAAU;IACnH,MAAM,CAAC,QAAQ,CAAC,IAAI,eACJ,UAAU,QAChB,UAAU,GAAG,UAAU,EAAE,gBACjB,iBAAiB,KAChC,UAAU,CAAqD;IAElE,QAAQ,CAAC,MAAM,CACX,SAAS,EAAE,UAAU,EACrB,IAAI,EAAE,UAAU,EAChB,SAAS,EAAE,UAAU,EACrB,WAAW,CAAC,EAAE,iBAAiB,GAChC,IAAI;IACP,MAAM,CAAC,QAAQ,CAAC,MAAM,cACP,UAAU,QACf,UAAU,aACL,UAAU,gBACP,iBAAiB,KAChC,IAAI,CAAiE;IAExE,QAAQ,CAAC,aAAa,IAAI,UAAU;IACpC,MAAM,CAAC,QAAQ,CAAC,aAAa,QAAO,UAAU,CAAiC;CAClF"}

package/dist/cjs/crypto/Crypto.js

@@ -0,0 +1,103 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target,
+  mod2
+));
+var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
+var Crypto_exports = {};
+__export(Crypto_exports, {
+  CRYPTO_AUTH_TAG_LENGTH: () => CRYPTO_AUTH_TAG_LENGTH,
+  CRYPTO_EC_CURVE: () => CRYPTO_EC_CURVE,
+  CRYPTO_EC_KEY_BYTES: () => CRYPTO_EC_KEY_BYTES,
+  CRYPTO_ENCRYPT_ALGORITHM: () => CRYPTO_ENCRYPT_ALGORITHM,
+  CRYPTO_HASH_ALGORITHM: () => CRYPTO_HASH_ALGORITHM,
+  CRYPTO_RANDOM_LENGTH: () => CRYPTO_RANDOM_LENGTH,
+  CRYPTO_SYMMETRIC_KEY_LENGTH: () => CRYPTO_SYMMETRIC_KEY_LENGTH,
+  Crypto: () => Crypto,
+  CryptoVerifyError: () => CryptoVerifyError,
+  ec: () => ec
+});
+module.exports = __toCommonJS(Crypto_exports);
+var mod = __toESM(require("@noble/curves/abstract/modular"), 1);
+var utils = __toESM(require("@noble/curves/abstract/utils"), 1);
+var import_p256 = require("@noble/curves/p256");
+var import_MatterError = require("../MatterError.js");
+var import_Bytes = require("../util/Bytes.js");
+var import_DataReader = require("../util/DataReader.js");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const ec = {
+  p256: import_p256.p256,
+  ...utils,
+  ...mod
+};
+const CRYPTO_RANDOM_LENGTH = 32;
+const CRYPTO_ENCRYPT_ALGORITHM = "aes-128-ccm";
+const CRYPTO_HASH_ALGORITHM = "sha256";
+const CRYPTO_EC_CURVE = "prime256v1";
+const CRYPTO_EC_KEY_BYTES = 32;
+const CRYPTO_AUTH_TAG_LENGTH = 16;
+const CRYPTO_SYMMETRIC_KEY_LENGTH = 16;
+class CryptoVerifyError extends import_MatterError.MatterError {
+}
+class Crypto {
+  static get = () => {
+    throw new import_MatterError.NoProviderError("No provider configured");
+  };
+  static encrypt = (key, data, nonce, aad) => Crypto.get().encrypt(key, data, nonce, aad);
+  static decrypt = (key, data, nonce, aad) => Crypto.get().decrypt(key, data, nonce, aad);
+  static getRandomData = (length) => Crypto.get().getRandomData(length);
+  static getRandom = () => Crypto.get().getRandomData(CRYPTO_RANDOM_LENGTH);
+  static getRandomUInt16 = () => new import_DataReader.DataReader(Crypto.get().getRandomData(2), import_Bytes.Endian.Little).readUInt16();
+  static getRandomUInt32 = () => new import_DataReader.DataReader(Crypto.get().getRandomData(4), import_Bytes.Endian.Little).readUInt32();
+  static getRandomBigUInt64 = () => new import_DataReader.DataReader(Crypto.get().getRandomData(8), import_Bytes.Endian.Little).readUInt64();
+  static getRandomBigInt = (size, maxValue) => {
+    const { bytesToNumberBE } = ec;
+    if (maxValue === void 0) {
+      return bytesToNumberBE(Crypto.getRandomData(size));
+    }
+    while (true) {
+      const random = bytesToNumberBE(Crypto.getRandomData(size));
+      if (random < maxValue) return random;
+    }
+  };
+  static ecdhGeneratePublicKey = () => Crypto.get().ecdhGeneratePublicKey();
+  static ecdhGeneratePublicKeyAndSecret = (peerPublicKey) => Crypto.get().ecdhGeneratePublicKeyAndSecret(peerPublicKey);
+  static ecdhGenerateSecret = (peerPublicKey, ecdh) => Crypto.get().ecdhGenerateSecret(peerPublicKey, ecdh);
+  static hash = (data) => Crypto.get().hash(data);
+  static pbkdf2 = (secret, salt, iteration, keyLength) => Crypto.get().pbkdf2(secret, salt, iteration, keyLength);
+  static hkdf = (secret, salt, info, length) => Crypto.get().hkdf(secret, salt, info, length);
+  static hmac = (key, data) => Crypto.get().hmac(key, data);
+  static sign = (privateKey, data, dsaEncoding) => Crypto.get().sign(privateKey, data, dsaEncoding);
+  static verify = (publicKey, data, signature, dsaEncoding) => Crypto.get().verify(publicKey, data, signature, dsaEncoding);
+  static createKeyPair = () => Crypto.get().createKeyPair();
+}
+if (typeof MatterHooks !== "undefined") {
+  MatterHooks.cryptoSetup?.(Crypto);
+}
+//# sourceMappingURL=Crypto.js.map

package/dist/cjs/crypto/Crypto.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/crypto/Crypto.ts"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/crypto/CryptoConstants.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** @see {@link MatterSpecification.v10.Core} § 3.5.1 */
+export declare const CRYPTO_GROUP_SIZE_BITS = 256;
+export declare const CRYPTO_GROUP_SIZE_BYTES = 32;
+export declare const CRYPTO_PUBLIC_KEY_SIZE_BYTES: number;
+/** @see {@link MatterSpecification.v10.Core} § 3.3 */
+export declare const CRYPTO_HASH_LEN_BYTES = 32;
+export declare const CRYPTO_HASH_BLOCK_LEN_BYTES = 64;
+/** @see {@link MatterSpecification.v10.Core} § 3.6 */
+export declare const CRYPTO_SYMMETRIC_KEY_LENGTH_BITS = 128;
+export declare const CRYPTO_SYMMETRIC_KEY_LENGTH_BYTES = 16;
+export declare const CRYPTO_AEAD_MIC_LENGTH_BITS = 128;
+export declare const CRYPTO_AEAD_MIC_LENGTH_BYTES = 16;
+export declare const CRYPTO_AEAD_NONCE_LENGTH_BYTES = 13;
+//# sourceMappingURL=CryptoConstants.d.ts.map

package/dist/cjs/crypto/CryptoConstants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CryptoConstants.d.ts","sourceRoot":"","sources":["../../../src/crypto/CryptoConstants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,wDAAwD;AACxD,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAC1C,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAC1C,eAAO,MAAM,4BAA4B,QAAkC,CAAC;AAC5E,sDAAsD;AACtD,eAAO,MAAM,qBAAqB,KAAK,CAAC;AACxC,eAAO,MAAM,2BAA2B,KAAK,CAAC;AAC9C,sDAAsD;AACtD,eAAO,MAAM,gCAAgC,MAAM,CAAC;AACpD,eAAO,MAAM,iCAAiC,KAAK,CAAC;AACpD,eAAO,MAAM,2BAA2B,MAAM,CAAC;AAC/C,eAAO,MAAM,4BAA4B,KAAK,CAAC;AAC/C,eAAO,MAAM,8BAA8B,KAAK,CAAC"}

package/dist/cjs/crypto/CryptoConstants.js

@@ -0,0 +1,48 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var CryptoConstants_exports = {};
+__export(CryptoConstants_exports, {
+  CRYPTO_AEAD_MIC_LENGTH_BITS: () => CRYPTO_AEAD_MIC_LENGTH_BITS,
+  CRYPTO_AEAD_MIC_LENGTH_BYTES: () => CRYPTO_AEAD_MIC_LENGTH_BYTES,
+  CRYPTO_AEAD_NONCE_LENGTH_BYTES: () => CRYPTO_AEAD_NONCE_LENGTH_BYTES,
+  CRYPTO_GROUP_SIZE_BITS: () => CRYPTO_GROUP_SIZE_BITS,
+  CRYPTO_GROUP_SIZE_BYTES: () => CRYPTO_GROUP_SIZE_BYTES,
+  CRYPTO_HASH_BLOCK_LEN_BYTES: () => CRYPTO_HASH_BLOCK_LEN_BYTES,
+  CRYPTO_HASH_LEN_BYTES: () => CRYPTO_HASH_LEN_BYTES,
+  CRYPTO_PUBLIC_KEY_SIZE_BYTES: () => CRYPTO_PUBLIC_KEY_SIZE_BYTES,
+  CRYPTO_SYMMETRIC_KEY_LENGTH_BITS: () => CRYPTO_SYMMETRIC_KEY_LENGTH_BITS,
+  CRYPTO_SYMMETRIC_KEY_LENGTH_BYTES: () => CRYPTO_SYMMETRIC_KEY_LENGTH_BYTES
+});
+module.exports = __toCommonJS(CryptoConstants_exports);
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const CRYPTO_GROUP_SIZE_BITS = 256;
+const CRYPTO_GROUP_SIZE_BYTES = 32;
+const CRYPTO_PUBLIC_KEY_SIZE_BYTES = 2 * CRYPTO_GROUP_SIZE_BYTES + 1;
+const CRYPTO_HASH_LEN_BYTES = 32;
+const CRYPTO_HASH_BLOCK_LEN_BYTES = 64;
+const CRYPTO_SYMMETRIC_KEY_LENGTH_BITS = 128;
+const CRYPTO_SYMMETRIC_KEY_LENGTH_BYTES = 16;
+const CRYPTO_AEAD_MIC_LENGTH_BITS = 128;
+const CRYPTO_AEAD_MIC_LENGTH_BYTES = 16;
+const CRYPTO_AEAD_NONCE_LENGTH_BYTES = 13;
+//# sourceMappingURL=CryptoConstants.js.map

package/dist/cjs/crypto/CryptoConstants.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/crypto/CryptoConstants.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOO,MAAM,yBAAyB;AAC/B,MAAM,0BAA0B;AAChC,MAAM,+BAA+B,IAAI,0BAA0B;AAEnE,MAAM,wBAAwB;AAC9B,MAAM,8BAA8B;AAEpC,MAAM,mCAAmC;AACzC,MAAM,oCAAoC;AAC1C,MAAM,8BAA8B;AACpC,MAAM,+BAA+B;AACrC,MAAM,iCAAiC;",
+  "names": []
+}

package/dist/cjs/crypto/Key.d.ts

@@ -0,0 +1,171 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare enum KeyType {
+    EC = "EC",
+    RSA = "RSA",
+    oct = "oct"
+}
+export declare enum CurveType {
+    p256 = "P-256",
+    p384 = "P-384",
+    p521 = "P-521"
+}
+export type BinaryKeyPair = {
+    publicKey: Uint8Array;
+    privateKey: Uint8Array;
+};
+/**
+ * Represents a cryptographic key.
+ *
+ * Models keys as JWK.  Advantages of this format:
+ *
+ *   - Standard
+ *   - Widely supported
+ *   - Fully models relevant key types
+ *   - Where not supported, extracting constituent parts for translation is trivial
+ */
+export interface Key extends JsonWebKey {
+    /**
+     * The key algorithm, alias for JWK "alg" field.
+     */
+    algorithm?: Key["alg"];
+    /**
+     * The elliptic curve type, alias for JWK "crv" field.
+     */
+    curve?: Key["crv"];
+    /**
+     * The key type, alias for JWK "kty" field.
+     */
+    type?: Key["kty"];
+    /**
+     * Operations supported by the key, alias for JWK "key_ops" field.
+     */
+    operations?: Key["key_ops"];
+    /**
+     * The private key, alias for JWK "d" field.
+     */
+    private?: Key["d"];
+    /**
+     * Indicates whether the private key is extractable, alias for JSK "ext"
+     * field.
+     */
+    extractable?: Key["ext"];
+    alg?: string;
+    crv?: CurveType;
+    d?: string;
+    dp?: string;
+    dq?: string;
+    e?: string;
+    ext?: boolean;
+    k?: string;
+    key_ops?: string[];
+    kty?: KeyType;
+    n?: string;
+    oth?: RsaOtherPrimesInfo[];
+    p?: string;
+    q?: string;
+    qi?: string;
+    use?: string;
+    x?: string;
+    y?: string;
+    /**
+     * Binary alias to private key field.  Automatically encodes/decodes the
+     * base-64 private key.
+     */
+    privateBits?: Uint8Array;
+    /**
+     * Binary alias to the x field.  Automatically encodes/decodes the base-64
+     * x-point on EC public keys.
+     */
+    xBits?: Uint8Array;
+    /**
+     * Binary alias to the y field.  Automatically encodes/decodes the base-64
+     * y-point on EC public keys.
+     */
+    yBits?: Uint8Array;
+    /**
+     * Import (write-only) of private keys encoded in SEC1 format.
+     */
+    sec1?: Uint8Array;
+    /**
+     * Import (write-only) of private keys encoded in PKCS #8 format.
+     */
+    pkcs8?: Uint8Array;
+    /**
+     * Import (write-only) of public keys encoded in SPKI format.
+     */
+    spki?: Uint8Array;
+    /**
+     * Import/export of EC public key in SEC1/SPKI format.  Maps to x & y
+     * fields internally.
+     */
+    publicBits?: Uint8Array;
+    /**
+     * Import/export of BinaryKeyPair structure used as an alternate
+     * serialization format for legacy reasons.
+     */
+    keyPairBits?: BinaryKeyPair;
+    /**
+     * Alias for publicBits that throws if no public key is present.
+     */
+    publicKey: Uint8Array;
+    /**
+     * Alias for privateBits that throws if no private key is present.
+     */
+    privateKey: Uint8Array;
+    /**
+     * Alias for keyPairBits that throws if a complete key pair is not present.
+     */
+    keyPair: BinaryKeyPair;
+}
+/**
+ * EC key without private fields.
+ */
+export interface PublicKey extends Key {
+    type: KeyType.EC;
+    curve: CurveType;
+    x: string;
+    y: string;
+    xBits: Uint8Array;
+    yBits: Uint8Array;
+    publicBits: Uint8Array;
+}
+/**
+ * EC key with extractable private fields.
+ */
+export interface PrivateKey extends PublicKey {
+    private: string;
+    d: string;
+    privateBits: Uint8Array;
+    privateKey: Uint8Array;
+    keyPair: BinaryKeyPair;
+    keyPairBits: BinaryKeyPair;
+}
+/**
+ * Symmetric key.
+ */
+export interface SymmetricKey extends Key {
+    type: KeyType.oct;
+    private: string;
+    d: string;
+}
+/**
+ * Generic key factory.
+ */
+export declare function Key(properties: Partial<Key>): Key;
+/**
+ * Private key factory.
+ */
+export declare function PrivateKey(privateKey: Uint8Array | BinaryKeyPair, options?: Partial<Key>): PrivateKey;
+/**
+ * Public key factory.
+ */
+export declare function PublicKey(publicKey: Uint8Array, options?: Partial<Key>): PublicKey;
+/**
+ * Symmetric key factory.
+ */
+export declare function SymmetricKey(privateKey: Uint8Array, options?: Partial<Key>): Key;
+//# sourceMappingURL=Key.d.ts.map

package/dist/cjs/crypto/Key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Key.d.ts","sourceRoot":"","sources":["../../../src/crypto/Key.ts"],"names":[],"mappings":"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"}