@project-chip/matter.js 0.11.0-alpha.0-20240926-407400ecb → 0.11.0-alpha.0-20241002-e7b377c34

package/dist/esm/MatterController.js

@@ -6,47 +6,30 @@
 import { GeneralCommissioning } from "#clusters";
 import {
   CRYPTO_SYMMETRIC_KEY_LENGTH,
+  ChannelType,
   Construction,
   Crypto,
   ImplementationError,
   Logger,
-  NoProviderError,
-  NoResponseTimeoutError,
+  NetInterfaceSet,
   StorageBackendMemory,
   StorageManager,
-  Time,
-  anyPromise,
-  createPromise,
-  isIPv6,
   serverAddressToString
 } from "#general";
-import { Specification } from "#model";
 import {
-  Ble,
-  CaseClient,
   ChannelManager,
   ClusterClient,
   CommissioningError,
-  CommissioningSuccessfullyFinished,
   ControllerCommissioner,
-  ControllerDiscovery,
-  DiscoveryError,
   ExchangeManager,
-  ExchangeProvider,
   Fabric,
   FabricBuilder,
-  InteractionClient,
-  MdnsScanner,
-  MessageChannel,
-  NoChannelError,
-  PairRetransmissionLimitReachedError,
-  PaseClient,
+  FabricManager,
+  NodeDiscoveryType,
+  PeerSet,
+  PeerStore,
   RetransmissionLimitReachedError,
   RootCertificateManager,
-  SECURE_CHANNEL_PROTOCOL_ID,
-  SESSION_ACTIVE_INTERVAL_MS,
-  SESSION_ACTIVE_THRESHOLD_MS,
-  SESSION_IDLE_INTERVAL_MS,
   SessionManager,
   StatusReportOnlySecureChannelProtocol
 } from "#protocol";
@@ -67,21 +50,12 @@ const TlvCommissioningSuccessFailureResponse = TlvObject({
   /** Should help developers in troubleshooting errors. The value MAY go into logs or crash reports, not User UIs. */
   debugText: TlvField(1, TlvString.bound({ maxLength: 128 }))
 });
+const DEFAULT_ADMIN_VENDOR_ID = VendorId(65521);
 const DEFAULT_FABRIC_INDEX = FabricIndex(1);
 const DEFAULT_FABRIC_ID = FabricId(1);
-const DEFAULT_ADMIN_VENDOR_ID = VendorId(65521);
-const RECONNECTION_POLLING_INTERVAL_MS = 6e5;
-const RETRANSMISSION_DISCOVERY_TIMEOUT_MS = 5e3;
 const CONTROLLER_CONNECTIONS_PER_FABRIC_AND_NODE = 3;
 const CONTROLLER_MAX_PATHS_PER_INVOKE = 10;
 const logger = Logger.get("MatterController");
-var NodeDiscoveryType = /* @__PURE__ */ ((NodeDiscoveryType2) => {
-  NodeDiscoveryType2[NodeDiscoveryType2["None"] = 0] = "None";
-  NodeDiscoveryType2[NodeDiscoveryType2["RetransmissionDiscovery"] = 1] = "RetransmissionDiscovery";
-  NodeDiscoveryType2[NodeDiscoveryType2["TimedDiscovery"] = 2] = "TimedDiscovery";
-  NodeDiscoveryType2[NodeDiscoveryType2["FullDiscovery"] = 3] = "FullDiscovery";
-  return NodeDiscoveryType2;
-})(NodeDiscoveryType || {});
 class MatterController {
   static async create(options) {
     const {
@@ -89,11 +63,10 @@ class MatterController {
       rootCertificateStorage,
       fabricStorage,
       nodesStorage,
-      mdnsScanner,
-      netInterfaceIpv4,
-      netInterfaceIpv6,
+      scanners,
+      netInterfaces,
       sessionClosedCallback,
-      adminVendorId = VendorId(DEFAULT_ADMIN_VENDOR_ID),
+      adminVendorId,
       adminFabricId = FabricId(DEFAULT_FABRIC_ID),
       adminFabricIndex = FabricIndex(DEFAULT_FABRIC_INDEX),
       caseAuthenticatedTags
@@ -106,18 +79,16 @@ class MatterController {
         sessionStorage,
         fabricStorage,
         nodesStorage,
-        mdnsScanner,
-        netInterfaceIpv4,
-        netInterfaceIpv6,
+        scanners,
+        netInterfaces,
         certificateManager,
         fabric,
-        adminVendorId: fabric.rootVendorId,
         sessionClosedCallback
       });
     } else {
       const rootNodeId = NodeId.randomOperationalNodeId();
       const ipkValue = Crypto.getRandomData(CRYPTO_SYMMETRIC_KEY_LENGTH);
-      const fabricBuilder = new FabricBuilder().setRootCert(certificateManager.rootCert).setRootNodeId(rootNodeId).setIdentityProtectionKey(ipkValue).setRootVendorId(adminVendorId);
+      const fabricBuilder = new FabricBuilder().setRootCert(certificateManager.rootCert).setRootNodeId(rootNodeId).setIdentityProtectionKey(ipkValue).setRootVendorId(adminVendorId ?? DEFAULT_ADMIN_VENDOR_ID);
       fabricBuilder.setOperationalCert(
         certificateManager.generateNoc(
           fabricBuilder.publicKey,
@@ -131,12 +102,10 @@ class MatterController {
         sessionStorage,
         fabricStorage,
         nodesStorage,
-        mdnsScanner,
-        netInterfaceIpv4,
-        netInterfaceIpv6,
+        scanners,
+        netInterfaces,
         certificateManager,
         fabric,
-        adminVendorId,
         sessionClosedCallback
       });
     }
@@ -144,19 +113,9 @@ class MatterController {
     return controller;
   }
   static async createAsPaseCommissioner(options) {
-    const {
-      rootCertificateData,
-      fabricData,
-      mdnsScanner,
-      netInterfaceIpv4,
-      netInterfaceIpv6,
-      sessionClosedCallback
-    } = options;
-    try {
-      Ble.get();
-    } catch (error) {
-      NoProviderError.accept(error);
-      if (!mdnsScanner || !netInterfaceIpv6) {
+    const { rootCertificateData, fabricData, scanners, netInterfaces, sessionClosedCallback } = options;
+    if (!netInterfaces.hasInterfaceFor(ChannelType.BLE)) {
+      if (!scanners.hasScannerFor(ChannelType.UDP) || !netInterfaces.hasInterfaceFor(ChannelType.UDP, "::")) {
         throw new ImplementationError(
           "Ble must be initialized to create a Sub Commissioner without an IP network!"
         );
@@ -172,37 +131,29 @@ class MatterController {
     const controller = new MatterController({
       sessionStorage,
       nodesStorage,
-      mdnsScanner,
-      netInterfaceIpv4,
-      netInterfaceIpv6,
+      scanners,
+      netInterfaces,
       certificateManager,
       fabric,
-      adminVendorId: fabric.rootVendorId,
       sessionClosedCallback
     });
     await controller.construction;
     return controller;
   }
   sessionManager;
+  netInterfaces = new NetInterfaceSet();
   channelManager = new ChannelManager(CONTROLLER_CONNECTIONS_PER_FABRIC_AND_NODE);
   exchangeManager;
-  paseClient = new PaseClient();
-  caseClient = new CaseClient();
-  netInterfaceBle;
-  bleScanner;
-  commissionedNodes = /* @__PURE__ */ new Map();
+  peers;
+  commissioner;
   #construction;
   sessionStorage;
   fabricStorage;
-  nodesStorage;
-  mdnsScanner;
-  netInterfaceIpv4;
-  netInterfaceIpv6;
+  nodesStore;
+  scanners;
   certificateManager;
   fabric;
-  adminVendorId;
   sessionClosedCallback;
-  #runningNodeDiscoveries = /* @__PURE__ */ new Map();
   get construction() {
     return this.#construction;
   }
@@ -211,48 +162,57 @@ class MatterController {
       sessionStorage,
       fabricStorage,
       nodesStorage,
-      mdnsScanner,
-      netInterfaceIpv4,
-      netInterfaceIpv6,
+      scanners,
+      netInterfaces,
       certificateManager,
       fabric,
-      sessionClosedCallback,
-      adminVendorId
+      sessionClosedCallback
     } = options;
     this.sessionStorage = sessionStorage;
     this.fabricStorage = fabricStorage;
-    this.nodesStorage = nodesStorage;
-    this.mdnsScanner = mdnsScanner;
-    this.netInterfaceIpv4 = netInterfaceIpv4;
-    this.netInterfaceIpv6 = netInterfaceIpv6;
+    this.scanners = scanners;
+    this.netInterfaces = netInterfaces;
     this.certificateManager = certificateManager;
     this.fabric = fabric;
     this.sessionClosedCallback = sessionClosedCallback;
-    this.adminVendorId = adminVendorId;
-    this.sessionManager = new SessionManager(this, sessionStorage);
-    this.sessionManager.sessionClosed.on(async (session) => {
-      if (!session.closingAfterExchangeFinished) {
-        await this.exchangeManager.closeSession(session);
+    const fabricManager = new FabricManager();
+    fabricManager.addFabric(fabric);
+    this.sessionManager = new SessionManager({
+      fabrics: fabricManager,
+      storage: sessionStorage,
+      parameters: {
+        maxPathsPerInvoke: CONTROLLER_MAX_PATHS_PER_INVOKE
       }
+    });
+    this.sessionManager.sessions.deleted.on(async (session) => {
       this.sessionClosedCallback?.(session.peerNodeId);
     });
-    this.exchangeManager = new ExchangeManager(this.sessionManager, this.channelManager);
+    this.exchangeManager = new ExchangeManager({
+      sessionManager: this.sessionManager,
+      channelManager: this.channelManager,
+      transportInterfaces: this.netInterfaces
+    });
     this.exchangeManager.addProtocolHandler(new StatusReportOnlySecureChannelProtocol());
-    if (netInterfaceIpv4 !== void 0) {
-      this.addTransportInterface(netInterfaceIpv4);
-    }
-    if (netInterfaceIpv6 !== void 0) {
-      this.addTransportInterface(netInterfaceIpv6);
-    }
+    this.nodesStore = new CommissionedNodeStore(nodesStorage, fabric);
+    this.nodesStore.peers = this.peers = new PeerSet({
+      sessions: this.sessionManager,
+      channels: this.channelManager,
+      exchanges: this.exchangeManager,
+      scanners: this.scanners,
+      netInterfaces: this.netInterfaces,
+      store: this.nodesStore
+    });
+    this.commissioner = new ControllerCommissioner({
+      peers: this.peers,
+      scanners: this.scanners,
+      netInterfaces: this.netInterfaces,
+      exchanges: this.exchangeManager,
+      sessions: this.sessionManager,
+      certificates: this.certificateManager
+    });
     this.#construction = Construction(this, async () => {
-      if (await this.nodesStorage.has("commissionedNodes")) {
-        const commissionedNodes = await this.nodesStorage.get("commissionedNodes");
-        this.commissionedNodes.clear();
-        for (const [nodeId, details] of commissionedNodes) {
-          this.commissionedNodes.set(nodeId, details);
-        }
-      }
-      await this.sessionManager.initFromStorage([this.fabric]);
+      await this.peers.construction.ready;
+      await this.sessionManager.construction.ready;
     });
   }
   get nodeId() {
@@ -267,44 +227,10 @@ class MatterController {
   getFabrics() {
     return [this.fabric];
   }
-  /** Our own client/controller session parameters. */
-  get sessionParameters() {
-    return {
-      idleIntervalMs: SESSION_IDLE_INTERVAL_MS,
-      activeIntervalMs: SESSION_ACTIVE_INTERVAL_MS,
-      activeThresholdMs: SESSION_ACTIVE_THRESHOLD_MS,
-      dataModelRevision: Specification.DATA_MODEL_REVISION,
-      interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
-      specificationVersion: Specification.SPECIFICATION_VERSION,
-      maxPathsPerInvoke: CONTROLLER_MAX_PATHS_PER_INVOKE
-    };
-  }
-  addTransportInterface(netInterface) {
-    this.exchangeManager.addTransportInterface(netInterface);
-  }
   collectScanners(discoveryCapabilities = { onIpNetwork: true }) {
-    const scannersToUse = new Array();
-    if (this.mdnsScanner !== void 0) {
-      scannersToUse.push(this.mdnsScanner);
-    }
-    if (discoveryCapabilities.ble) {
-      if (this.bleScanner === void 0) {
-        let ble;
-        try {
-          ble = Ble.get();
-          this.netInterfaceBle = ble.getBleCentralInterface();
-          this.addTransportInterface(this.netInterfaceBle);
-          this.bleScanner = ble.getBleScanner();
-        } catch (error) {
-          NoProviderError.accept(error);
-          logger.warn("BLE is not supported on this platform. The device to commission might not be found!");
-        }
-      }
-      if (this.bleScanner !== void 0) {
-        scannersToUse.push(this.bleScanner);
-      }
-    }
-    return scannersToUse;
+    return this.scanners.filter(
+      (scanner) => scanner.type === ChannelType.UDP || discoveryCapabilities.ble && scanner.type === ChannelType.BLE
+    );
   }
   /**
    * Commission a device by its identifier and the Passcode. If a known address is provided this is tried first
@@ -318,186 +244,36 @@ class MatterController {
    * Return true when the commissioning process is completed successfully, false on error.
    */
   async commission(options, completeCommissioningCallback) {
-    const {
-      commissioning: commissioningOptions = {
-        regulatoryLocation: GeneralCommissioning.RegulatoryLocationType.Outdoor,
-        // Set to the most restrictive if relevant
-        regulatoryCountryCode: "XX"
-      },
-      discovery: { timeoutSeconds = 30 },
-      passcode
-    } = options;
-    const commissionableDevice = "commissionableDevice" in options.discovery ? options.discovery.commissionableDevice : void 0;
-    let {
-      discovery: { discoveryCapabilities = {}, knownAddress }
-    } = options;
-    let identifierData = "identifierData" in options.discovery ? options.discovery.identifierData : {};
-    if (this.mdnsScanner !== void 0 && this.netInterfaceIpv6 !== void 0) {
-      discoveryCapabilities.onIpNetwork = true;
-    }
-    if (commissionableDevice !== void 0) {
-      let { addresses } = commissionableDevice;
-      if (discoveryCapabilities.ble === true) {
-        discoveryCapabilities = { onIpNetwork: true, ble: addresses.some((address) => address.type === "ble") };
-      } else if (discoveryCapabilities.onIpNetwork === true) {
-        addresses = addresses.filter((address) => address.type !== "ble");
-      }
-      addresses.sort((a) => a.type === "udp" ? -1 : 1);
-      knownAddress = addresses[0];
-      if ("instanceId" in commissionableDevice && commissionableDevice.instanceId !== void 0) {
-        identifierData = { instanceId: commissionableDevice.instanceId };
-      } else {
-        identifierData = { longDiscriminator: commissionableDevice.D };
-      }
-    }
-    const scannersToUse = this.collectScanners(discoveryCapabilities);
-    logger.info(
-      `Commissioning device with identifier ${Logger.toJSON(identifierData)} and ${scannersToUse.length} scanners and knownAddress ${Logger.toJSON(knownAddress)}`
-    );
-    let paseSecureChannel;
-    let discoveryData;
-    if (knownAddress !== void 0) {
-      try {
-        paseSecureChannel = await this.initializePaseSecureChannel(knownAddress, passcode);
-      } catch (error) {
-        NoResponseTimeoutError.accept(error);
-      }
-    }
-    if (paseSecureChannel === void 0) {
-      const discoveredDevices = await ControllerDiscovery.discoverDeviceAddressesByIdentifier(
-        scannersToUse,
-        identifierData,
-        timeoutSeconds
-      );
-      const { result } = await ControllerDiscovery.iterateServerAddresses(
-        discoveredDevices,
-        NoResponseTimeoutError,
-        async () => scannersToUse.flatMap((scanner) => scanner.getDiscoveredCommissionableDevices(identifierData)),
-        async (address, device) => {
-          const channel = await this.initializePaseSecureChannel(address, passcode, device);
-          discoveryData = device;
-          return channel;
+    const commissioningOptions = {
+      ...options.commissioning,
+      fabric: this.fabric,
+      discovery: options.discovery,
+      passcode: options.passcode
+    };
+    if (completeCommissioningCallback) {
+      commissioningOptions.performCaseCommissioning = async (peerAddress, discoveryData) => {
+        const result = await completeCommissioningCallback(peerAddress.nodeId, discoveryData);
+        if (!result) {
+          throw new RetransmissionLimitReachedError("Device could not be discovered");
         }
-      );
-      paseSecureChannel = result;
+      };
     }
-    return await this.commissionDevice(
-      paseSecureChannel,
-      commissioningOptions,
-      discoveryData,
-      completeCommissioningCallback
-    );
+    const address = await this.commissioner.commission(commissioningOptions);
+    await this.fabricStorage?.set("fabric", this.fabric.toStorageObject());
+    return address.nodeId;
   }
   async disconnect(nodeId) {
-    await this.sessionManager.removeAllSessionsForNode(nodeId, true);
-    await this.channelManager.removeAllNodeChannels(this.fabric, nodeId);
+    return this.peers.disconnect(this.fabric.addressOf(nodeId));
   }
   async removeNode(nodeId) {
-    logger.info(`Removing commissioned node ${nodeId} from controller.`);
-    await this.sessionManager.removeAllSessionsForNode(nodeId);
-    await this.sessionManager.removeResumptionRecord(nodeId);
-    await this.channelManager.removeAllNodeChannels(this.fabric, nodeId);
-    this.commissionedNodes.delete(nodeId);
-    await this.storeCommissionedNodes();
-  }
-  /**
-   * Method to start commission process with a PASE pairing.
-   * If this not successful and throws an RetransmissionLimitReachedError the address is invalid or the passcode
-   * is wrong.
-   */
-  async initializePaseSecureChannel(address, passcode, device) {
-    let paseChannel;
-    if (device !== void 0) {
-      logger.info(`Commissioning device`, MdnsScanner.discoveryDataDiagnostics(device));
-    }
-    if (address.type === "udp") {
-      const { ip } = address;
-      const isIpv6Address = isIPv6(ip);
-      const paseInterface = isIpv6Address ? this.netInterfaceIpv6 : this.netInterfaceIpv4;
-      if (paseInterface === void 0) {
-        throw new PairRetransmissionLimitReachedError(
-          `IPv${isIpv6Address ? "6" : "4"} interface not initialized. Cannot use ${ip} for commissioning.`
-        );
-      }
-      paseChannel = await paseInterface.openChannel(address);
-    } else {
-      if (this.netInterfaceBle === void 0) {
-        throw new PairRetransmissionLimitReachedError(
-          `BLE interface not initialized. Cannot use ${address.peripheralAddress} for commissioning.`
-        );
-      }
-      paseChannel = await this.netInterfaceBle.openChannel(address);
-    }
-    const unsecureSession = this.sessionManager.createUnsecureSession({
-      // Use the session parameters from MDNS announcements when available and rest is assumed to be fallbacks
-      sessionParameters: {
-        idleIntervalMs: device?.SII,
-        activeIntervalMs: device?.SAI,
-        activeThresholdMs: device?.SAT
-      },
-      isInitiator: true
-    });
-    const paseUnsecureMessageChannel = new MessageChannel(paseChannel, unsecureSession);
-    const paseExchange = this.exchangeManager.initiateExchangeWithChannel(
-      paseUnsecureMessageChannel,
-      SECURE_CHANNEL_PROTOCOL_ID
-    );
-    let paseSecureSession;
-    try {
-      paseSecureSession = await this.paseClient.pair(this, paseExchange, passcode);
-    } catch (e) {
-      await paseExchange.close();
-      throw e;
-    }
-    await unsecureSession.destroy();
-    return new MessageChannel(paseChannel, paseSecureSession);
-  }
-  /**
-   * Method to commission a device with a PASE secure channel. It returns the NodeId of the commissioned device on
-   * success.
-   */
-  async commissionDevice(paseSecureMessageChannel, commissioningOptions, discoveryData, completeCommissioningCallback) {
-    const peerNodeId = commissioningOptions.nodeId ?? NodeId.randomOperationalNodeId();
-    const commissioningManager = new ControllerCommissioner(
-      // Use the created secure session to do the commissioning
-      new InteractionClient(new ExchangeProvider(this.exchangeManager, paseSecureMessageChannel), peerNodeId),
-      this.certificateManager,
-      this.fabric,
-      commissioningOptions,
-      peerNodeId,
-      this.adminVendorId,
-      async () => {
-        await paseSecureMessageChannel.close();
-        if (completeCommissioningCallback !== void 0) {
-          if (!await completeCommissioningCallback(peerNodeId, discoveryData)) {
-            throw new RetransmissionLimitReachedError("Device could not be discovered");
-          }
-          throw new CommissioningSuccessfullyFinished();
-        }
-        return await this.connect(peerNodeId, {
-          discoveryType: 2 /* TimedDiscovery */,
-          timeoutSeconds: 120,
-          discoveryData
-        });
-      }
-    );
-    try {
-      await commissioningManager.executeCommissioning();
-    } catch (error) {
-      if (this.commissionedNodes.has(peerNodeId)) {
-        this.commissionedNodes.delete(peerNodeId);
-      }
-      throw error;
-    }
-    await this.fabricStorage?.set("fabric", this.fabric.toStorageObject());
-    return peerNodeId;
+    return this.peers.delete(this.fabric.addressOf(nodeId));
   }
   /**
    * Method to complete the commissioning process to a node which was initialized with a PASE secure channel.
    */
   async completeCommissioning(peerNodeId, discoveryData) {
     const interactionClient = await this.connect(peerNodeId, {
-      discoveryType: 2 /* TimedDiscovery */,
+      discoveryType: NodeDiscoveryType.TimedDiscovery,
       timeoutSeconds: 120,
       discoveryData
     });
@@ -510,315 +286,44 @@ class MatterController {
       useExtendedFailSafeMessageResponseTimeout: true
     });
     if (errorCode !== GeneralCommissioning.CommissioningError.Ok) {
-      if (this.commissionedNodes.has(peerNodeId)) {
-        this.commissionedNodes.delete(peerNodeId);
-      }
+      await this.peers.delete(this.fabric.addressOf(peerNodeId));
       throw new CommissioningError(`Commission error on commissioningComplete: ${errorCode}, ${debugText}`);
     }
     await this.fabricStorage?.set("fabric", this.fabric.toStorageObject());
   }
-  handleResubmissionStarted(peerNodeId) {
-    if (this.#runningNodeDiscoveries.has(peerNodeId)) {
-      return;
-    }
-    this.#runningNodeDiscoveries.set(peerNodeId, { type: 1 /* RetransmissionDiscovery */ });
-    this.mdnsScanner?.findOperationalDevice(this.fabric, peerNodeId, RETRANSMISSION_DISCOVERY_TIMEOUT_MS, true).catch((error) => {
-      logger.error(`Failed to discover device ${peerNodeId} after resubmission started.`, error);
-    }).finally(() => {
-      if (this.#runningNodeDiscoveries.get(peerNodeId)?.type === 1 /* RetransmissionDiscovery */) {
-        this.#runningNodeDiscoveries.delete(peerNodeId);
-      }
-    });
-  }
-  async reconnectKnownAddress(peerNodeId, operationalAddress, discoveryData, expectedProcessingTimeMs) {
-    const { ip, port } = operationalAddress;
-    try {
-      logger.debug(
-        `Resume device connection to configured server at ${ip}:${port}${expectedProcessingTimeMs !== void 0 ? ` with expected processing time of ${expectedProcessingTimeMs}ms` : ""} ...`
-      );
-      const channel = await this.pair(peerNodeId, operationalAddress, discoveryData, expectedProcessingTimeMs);
-      await this.setOperationalDeviceData(peerNodeId, operationalAddress);
-      return channel;
-    } catch (error) {
-      if (error instanceof NoResponseTimeoutError) {
-        logger.debug(
-          `Failed to resume connection to node ${peerNodeId} connection with ${ip}:${port}, discover the device ...`,
-          error
-        );
-        await this.sessionManager.removeAllSessionsForNode(peerNodeId);
-        return void 0;
-      } else {
-        throw error;
-      }
-    }
-  }
-  async connectOrDiscoverNode(peerNodeId, operationalAddress, discoveryOptions = {}) {
-    const {
-      discoveryType: requestedDiscoveryType = 3 /* FullDiscovery */,
-      timeoutSeconds,
-      discoveryData = this.commissionedNodes.get(peerNodeId)?.discoveryData
-    } = discoveryOptions;
-    if (timeoutSeconds !== void 0 && requestedDiscoveryType !== 2 /* TimedDiscovery */) {
-      throw new ImplementationError("Cannot set timeout without timed discovery.");
-    }
-    if (requestedDiscoveryType === 1 /* RetransmissionDiscovery */) {
-      throw new ImplementationError("Cannot set retransmission discovery type.");
-    }
-    if (this.mdnsScanner === void 0) {
-      throw new ImplementationError("Cannot discover device without mDNS scanner.");
-    }
-    const mdnsScanner = this.mdnsScanner;
-    const existingDiscoveryDetails = this.#runningNodeDiscoveries.get(peerNodeId) ?? {
-      type: 0 /* None */
-    };
-    if (existingDiscoveryDetails.type !== 0 /* None */ && existingDiscoveryDetails.type < requestedDiscoveryType) {
-      mdnsScanner.cancelOperationalDeviceDiscovery(this.fabric, peerNodeId);
-      this.#runningNodeDiscoveries.delete(peerNodeId);
-      existingDiscoveryDetails.type = 0 /* None */;
-    }
-    const { type: runningDiscoveryType, promises } = existingDiscoveryDetails;
-    if (operationalAddress !== void 0 && (runningDiscoveryType === 0 /* None */ || requestedDiscoveryType === 0 /* None */)) {
-      const directReconnection = await this.reconnectKnownAddress(peerNodeId, operationalAddress, discoveryData);
-      if (directReconnection !== void 0) {
-        return directReconnection;
-      }
-      if (requestedDiscoveryType === 0 /* None */) {
-        throw new DiscoveryError(`Node ${peerNodeId} is not reachable right now.`);
-      }
-    }
-    if (promises !== void 0) {
-      if (runningDiscoveryType > requestedDiscoveryType) {
-        throw new DiscoveryError(
-          `Node ${peerNodeId} is not reachable right now and discovery already running.`
-        );
-      } else {
-        return await anyPromise(promises);
-      }
-    }
-    const discoveryPromises = new Array();
-    let reconnectionPollingTimer;
-    if (operationalAddress !== void 0) {
-      if (requestedDiscoveryType === 3 /* FullDiscovery */) {
-        const { promise, resolver, rejecter } = createPromise();
-        reconnectionPollingTimer = Time.getPeriodicTimer(
-          "Controller reconnect",
-          RECONNECTION_POLLING_INTERVAL_MS,
-          async () => {
-            try {
-              logger.debug(`Polling for device at ${serverAddressToString(operationalAddress)} ...`);
-              const result = await this.reconnectKnownAddress(
-                peerNodeId,
-                operationalAddress,
-                discoveryData
-              );
-              if (result !== void 0 && reconnectionPollingTimer?.isRunning) {
-                reconnectionPollingTimer?.stop();
-                mdnsScanner.cancelOperationalDeviceDiscovery(this.fabric, peerNodeId);
-                this.#runningNodeDiscoveries.delete(peerNodeId);
-                resolver(result);
-              }
-            } catch (error) {
-              if (reconnectionPollingTimer?.isRunning) {
-                reconnectionPollingTimer?.stop();
-                mdnsScanner.cancelOperationalDeviceDiscovery(this.fabric, peerNodeId);
-                this.#runningNodeDiscoveries.delete(peerNodeId);
-                rejecter(error);
-              }
-            }
-          }
-        ).start();
-        discoveryPromises.push(() => promise);
-      }
-    }
-    discoveryPromises.push(async () => {
-      const scanResult = await ControllerDiscovery.discoverOperationalDevice(
-        this.fabric,
-        peerNodeId,
-        mdnsScanner,
-        timeoutSeconds,
-        timeoutSeconds === void 0
-      );
-      const { timer } = this.#runningNodeDiscoveries.get(peerNodeId) ?? {};
-      timer?.stop();
-      this.#runningNodeDiscoveries.delete(peerNodeId);
-      const { result } = await ControllerDiscovery.iterateServerAddresses(
-        [scanResult],
-        NoResponseTimeoutError,
-        async () => {
-          const device = mdnsScanner.getDiscoveredOperationalDevice(this.fabric, peerNodeId);
-          return device !== void 0 ? [device] : [];
-        },
-        async (address, device) => {
-          const result2 = await this.pair(peerNodeId, address, device);
-          await this.setOperationalDeviceData(peerNodeId, address, {
-            ...discoveryData,
-            ...device
-          });
-          return result2;
-        }
-      );
-      return result;
-    });
-    this.#runningNodeDiscoveries.set(peerNodeId, {
-      type: requestedDiscoveryType,
-      promises: discoveryPromises,
-      timer: reconnectionPollingTimer
-    });
-    return await anyPromise(discoveryPromises).finally(() => this.#runningNodeDiscoveries.delete(peerNodeId));
-  }
-  /**
-   * Resume a device connection and establish a CASE session that was previously paired with the controller. This
-   * method will try to connect to the device using the previously used server address (if set). If that fails, the
-   * device is discovered again using its operational instance details.
-   * It returns the operational MessageChannel on success.
-   */
-  async resume(peerNodeId, discoveryOptions) {
-    const operationalAddress = this.getLastOperationalAddress(peerNodeId);
-    try {
-      return await this.connectOrDiscoverNode(peerNodeId, operationalAddress, discoveryOptions);
-    } catch (error) {
-      if ((error instanceof DiscoveryError || error instanceof NoResponseTimeoutError) && this.commissionedNodes.has(peerNodeId)) {
-        logger.info(`Resume failed, remove all sessions for node ${peerNodeId}`);
-        await this.sessionManager.removeAllSessionsForNode(peerNodeId);
-      }
-      throw error;
-    }
-  }
-  /** Pair with an operational device (already commissioned) and establish a CASE session. */
-  async pair(peerNodeId, operationalServerAddress, discoveryData, expectedProcessingTimeMs) {
-    const { ip, port } = operationalServerAddress;
-    const isIpv6Address = isIPv6(ip);
-    const operationalInterface = isIpv6Address ? this.netInterfaceIpv6 : this.netInterfaceIpv4;
-    if (operationalInterface === void 0) {
-      throw new PairRetransmissionLimitReachedError(
-        `IPv${isIpv6Address ? "6" : "4"} interface not initialized for port ${port}. Cannot use ${ip} for pairing.`
-      );
-    }
-    const operationalChannel = await operationalInterface.openChannel(operationalServerAddress);
-    const { sessionParameters } = this.findResumptionRecordByNodeId(peerNodeId) ?? {};
-    const unsecureSession = this.sessionManager.createUnsecureSession({
-      // Use the session parameters from MDNS announcements when available and rest is assumed to be fallbacks
-      sessionParameters: {
-        idleIntervalMs: discoveryData?.SII ?? sessionParameters?.idleIntervalMs,
-        activeIntervalMs: discoveryData?.SAI ?? sessionParameters?.activeIntervalMs,
-        activeThresholdMs: discoveryData?.SAT ?? sessionParameters?.activeThresholdMs
-      },
-      isInitiator: true
-    });
-    const operationalUnsecureMessageExchange = new MessageChannel(operationalChannel, unsecureSession);
-    let operationalSecureSession;
-    try {
-      const exchange = this.exchangeManager.initiateExchangeWithChannel(
-        operationalUnsecureMessageExchange,
-        SECURE_CHANNEL_PROTOCOL_ID
-      );
-      try {
-        operationalSecureSession = await this.caseClient.pair(
-          this,
-          exchange,
-          this.fabric,
-          peerNodeId,
-          expectedProcessingTimeMs
-        );
-      } catch (e) {
-        await exchange.close();
-        throw e;
-      }
-    } catch (e) {
-      NoResponseTimeoutError.accept(e);
-      throw new PairRetransmissionLimitReachedError(e.message);
-    }
-    await unsecureSession.destroy();
-    const channel = new MessageChannel(operationalChannel, operationalSecureSession);
-    await this.channelManager.setChannel(this.fabric, peerNodeId, channel);
-    return channel;
-  }
   isCommissioned() {
-    return this.commissionedNodes.size > 0;
+    return this.peers.size > 0;
   }
   getCommissionedNodes() {
-    return Array.from(this.commissionedNodes.keys());
+    return this.peers.map((peer) => peer.address.nodeId);
   }
   getCommissionedNodesDetails() {
-    return Array.from(this.commissionedNodes.entries()).map(
-      ([nodeId, { operationalServerAddress, discoveryData, basicInformationData }]) => ({
-        nodeId,
-        operationalAddress: operationalServerAddress ? serverAddressToString(operationalServerAddress) : void 0,
+    return this.peers.map((peer) => {
+      const { address, operationalAddress, discoveryData, basicInformationData } = peer;
+      return {
+        nodeId: address.nodeId,
+        operationalAddress: operationalAddress ? serverAddressToString(operationalAddress) : void 0,
         advertisedName: discoveryData?.DN,
         discoveryData,
         basicInformationData
-      })
-    );
-  }
-  async setOperationalDeviceData(nodeId, operationalServerAddress, discoveryData) {
-    const nodeDetails = this.commissionedNodes.get(nodeId) ?? {};
-    nodeDetails.operationalServerAddress = operationalServerAddress;
-    if (discoveryData !== void 0) {
-      nodeDetails.discoveryData = {
-        ...nodeDetails.discoveryData,
-        ...discoveryData
       };
-    }
-    this.commissionedNodes.set(nodeId, nodeDetails);
-    await this.storeCommissionedNodes();
+    });
   }
   async enhanceCommissionedNodeDetails(nodeId, data) {
-    const nodeDetails = this.commissionedNodes.get(nodeId);
+    const nodeDetails = this.peers.get(this.fabric.addressOf(nodeId));
     if (nodeDetails === void 0) {
       throw new Error(`Node ${nodeId} is not commissioned.`);
     }
     const { basicInformationData } = data;
     nodeDetails.basicInformationData = basicInformationData;
-    this.commissionedNodes.set(nodeId, nodeDetails);
-    await this.storeCommissionedNodes();
-  }
-  getLastOperationalAddress(nodeId) {
-    return this.commissionedNodes.get(nodeId)?.operationalServerAddress;
-  }
-  async storeCommissionedNodes() {
-    await this.nodesStorage.set("commissionedNodes", Array.from(this.commissionedNodes.entries()));
+    await this.nodesStore.save();
   }
   /**
    * Connect to the device by opening a channel and creating a new CASE session if necessary.
    * Returns a InteractionClient on success.
    */
   async connect(peerNodeId, discoveryOptions) {
-    const { discoveryData } = discoveryOptions;
-    let channel;
-    try {
-      channel = this.channelManager.getChannel(this.fabric, peerNodeId);
-    } catch (error) {
-      NoChannelError.accept(error);
-      channel = await this.resume(peerNodeId, discoveryOptions);
-    }
-    return new InteractionClient(
-      new ExchangeProvider(this.exchangeManager, channel, async () => {
-        if (!this.channelManager.hasChannel(this.fabric, peerNodeId)) {
-          throw new RetransmissionLimitReachedError(`Device ${peerNodeId} is currently not reachable.`);
-        }
-        await this.channelManager.removeAllNodeChannels(this.fabric, peerNodeId);
-        const discoveredAddresses = this.mdnsScanner?.getDiscoveredOperationalDevice(this.fabric, peerNodeId);
-        const lastKnownAddress = this.getLastOperationalAddress(peerNodeId);
-        if (lastKnownAddress !== void 0 && discoveredAddresses !== void 0 && discoveredAddresses.addresses.some(
-          ({ ip, port }) => ip === lastKnownAddress.ip && port === lastKnownAddress.port
-        )) {
-          discoveredAddresses.addresses.length = 0;
-        }
-        const operationalAddress = discoveredAddresses?.addresses[0];
-        if (operationalAddress === void 0) {
-          logger.info(
-            `Re-Discovering device failed (no address found), remove all sessions for node ${peerNodeId}`
-          );
-          await this.sessionManager.removeAllSessionsForNode(peerNodeId);
-          throw new RetransmissionLimitReachedError(`No operational address found for node ${peerNodeId}`);
-        }
-        if (await this.reconnectKnownAddress(peerNodeId, operationalAddress, discoveryData, 2e3) === void 0) {
-          throw new RetransmissionLimitReachedError(`Device ${peerNodeId} is not reachable.`);
-        }
-        return this.channelManager.getChannel(this.fabric, peerNodeId);
-      }),
-      peerNodeId
-    );
+    return this.peers.connect(this.fabric.addressOf(peerNodeId), discoveryOptions);
   }
   async getNextAvailableSessionId() {
     return this.sessionManager.getNextAvailableSessionId();
@@ -827,7 +332,7 @@ class MatterController {
     return this.sessionManager.findResumptionRecordById(resumptionId);
   }
   findResumptionRecordByNodeId(nodeId) {
-    return this.sessionManager.findResumptionRecordByNodeId(nodeId);
+    return this.sessionManager.findResumptionRecordByAddress(this.fabric.addressOf(nodeId));
   }
   async saveResumptionRecord(resumptionRecord) {
     return this.sessionManager.saveResumptionRecord(resumptionRecord);
@@ -835,23 +340,61 @@ class MatterController {
   announce() {
   }
   async close() {
-    for (const [nodeId, { timer }] of this.#runningNodeDiscoveries.entries()) {
-      timer?.stop();
-      this.mdnsScanner?.cancelOperationalDeviceDiscovery(this.fabric, nodeId, false);
-    }
+    await this.peers.close();
     await this.exchangeManager.close();
     await this.sessionManager.close();
     await this.channelManager.close();
-    await this.netInterfaceBle?.close();
-    await this.netInterfaceIpv4?.close();
-    await this.netInterfaceIpv6?.close();
+    await this.netInterfaces.close();
   }
   getActiveSessionInformation() {
     return this.sessionManager.getActiveSessionInformation();
   }
 }
+class CommissionedNodeStore extends PeerStore {
+  constructor(nodesStorage, fabric) {
+    super();
+    this.nodesStorage = nodesStorage;
+    this.fabric = fabric;
+  }
+  async loadPeers() {
+    if (!await this.nodesStorage.has("commissionedNodes")) {
+      return [];
+    }
+    const commissionedNodes = await this.nodesStorage.get("commissionedNodes");
+    return commissionedNodes.map(
+      ([nodeId, { operationalServerAddress, discoveryData, basicInformationData }]) => ({
+        address: this.fabric.addressOf(nodeId),
+        operationalAddress: operationalServerAddress,
+        discoveryData,
+        basicInformationData
+      })
+    );
+  }
+  async updatePeer() {
+    return this.save();
+  }
+  async deletePeer() {
+    return this.save();
+  }
+  async save() {
+    await this.nodesStorage.set(
+      "commissionedNodes",
+      this.peers.map((peer) => {
+        const {
+          address,
+          operationalAddress: operationalServerAddress,
+          basicInformationData,
+          discoveryData
+        } = peer;
+        return [
+          address.nodeId,
+          { operationalServerAddress, basicInformationData, discoveryData }
+        ];
+      })
+    );
+  }
+}
 export {
-  MatterController,
-  NodeDiscoveryType
+  MatterController
 };
 //# sourceMappingURL=MatterController.js.map