@project-chip/matter.js 0.11.0-alpha.0-20240928-08865c2ce → 0.11.0-alpha.0-20241002-e7b377c34

package/dist/cjs/MatterController.js

@@ -18,8 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var MatterController_exports = {};
 __export(MatterController_exports, {
-  MatterController: () => MatterController,
-  NodeDiscoveryType: () => NodeDiscoveryType
+  MatterController: () => MatterController
 });
 module.exports = __toCommonJS(MatterController_exports);
 var import_clusters = require("#clusters");
@@ -37,21 +36,12 @@ const TlvCommissioningSuccessFailureResponse = (0, import_types.TlvObject)({
   /** Should help developers in troubleshooting errors. The value MAY go into logs or crash reports, not User UIs. */
   debugText: (0, import_types.TlvField)(1, import_types.TlvString.bound({ maxLength: 128 }))
 });
+const DEFAULT_ADMIN_VENDOR_ID = (0, import_types.VendorId)(65521);
 const DEFAULT_FABRIC_INDEX = (0, import_types.FabricIndex)(1);
 const DEFAULT_FABRIC_ID = (0, import_types.FabricId)(1);
-const DEFAULT_ADMIN_VENDOR_ID = (0, import_types.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 = import_general.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 {
@@ -62,7 +52,7 @@ class MatterController {
       scanners,
       netInterfaces,
       sessionClosedCallback,
-      adminVendorId = (0, import_types.VendorId)(DEFAULT_ADMIN_VENDOR_ID),
+      adminVendorId,
       adminFabricId = (0, import_types.FabricId)(DEFAULT_FABRIC_ID),
       adminFabricIndex = (0, import_types.FabricIndex)(DEFAULT_FABRIC_INDEX),
       caseAuthenticatedTags
@@ -79,13 +69,12 @@ class MatterController {
         netInterfaces,
         certificateManager,
         fabric,
-        adminVendorId: fabric.rootVendorId,
         sessionClosedCallback
       });
     } else {
       const rootNodeId = import_types.NodeId.randomOperationalNodeId();
       const ipkValue = import_general.Crypto.getRandomData(import_general.CRYPTO_SYMMETRIC_KEY_LENGTH);
-      const fabricBuilder = new import_protocol.FabricBuilder().setRootCert(certificateManager.rootCert).setRootNodeId(rootNodeId).setIdentityProtectionKey(ipkValue).setRootVendorId(adminVendorId);
+      const fabricBuilder = new import_protocol.FabricBuilder().setRootCert(certificateManager.rootCert).setRootNodeId(rootNodeId).setIdentityProtectionKey(ipkValue).setRootVendorId(adminVendorId ?? DEFAULT_ADMIN_VENDOR_ID);
       fabricBuilder.setOperationalCert(
         certificateManager.generateNoc(
           fabricBuilder.publicKey,
@@ -103,7 +92,6 @@ class MatterController {
         netInterfaces,
         certificateManager,
         fabric,
-        adminVendorId,
         sessionClosedCallback
       });
     }
@@ -133,7 +121,6 @@ class MatterController {
       netInterfaces,
       certificateManager,
       fabric,
-      adminVendorId: fabric.rootVendorId,
       sessionClosedCallback
     });
     await controller.construction;
@@ -143,19 +130,16 @@ class MatterController {
   netInterfaces = new import_general.NetInterfaceSet();
   channelManager = new import_protocol.ChannelManager(CONTROLLER_CONNECTIONS_PER_FABRIC_AND_NODE);
   exchangeManager;
-  paseClient;
-  caseClient;
-  commissionedNodes = /* @__PURE__ */ new Map();
+  peers;
+  commissioner;
   #construction;
   sessionStorage;
   fabricStorage;
-  nodesStorage;
+  nodesStore;
   scanners;
   certificateManager;
   fabric;
-  adminVendorId;
   sessionClosedCallback;
-  #runningNodeDiscoveries = /* @__PURE__ */ new Map();
   get construction() {
     return this.#construction;
   }
@@ -168,18 +152,15 @@ class MatterController {
       netInterfaces,
       certificateManager,
       fabric,
-      sessionClosedCallback,
-      adminVendorId
+      sessionClosedCallback
     } = options;
     this.sessionStorage = sessionStorage;
     this.fabricStorage = fabricStorage;
-    this.nodesStorage = nodesStorage;
     this.scanners = scanners;
     this.netInterfaces = netInterfaces;
     this.certificateManager = certificateManager;
     this.fabric = fabric;
     this.sessionClosedCallback = sessionClosedCallback;
-    this.adminVendorId = adminVendorId;
     const fabricManager = new import_protocol.FabricManager();
     fabricManager.addFabric(fabric);
     this.sessionManager = new import_protocol.SessionManager({
@@ -189,26 +170,34 @@ class MatterController {
         maxPathsPerInvoke: CONTROLLER_MAX_PATHS_PER_INVOKE
       }
     });
-    this.paseClient = new import_protocol.PaseClient(this.sessionManager);
-    this.caseClient = new import_protocol.CaseClient(this.sessionManager);
     this.sessionManager.sessions.deleted.on(async (session) => {
       this.sessionClosedCallback?.(session.peerNodeId);
     });
-    this.sessionManager.resubmissionStarted.on(this.#handleResubmissionStarted.bind(this));
     this.exchangeManager = new import_protocol.ExchangeManager({
       sessionManager: this.sessionManager,
       channelManager: this.channelManager,
       transportInterfaces: this.netInterfaces
     });
     this.exchangeManager.addProtocolHandler(new import_protocol.StatusReportOnlySecureChannelProtocol());
+    this.nodesStore = new CommissionedNodeStore(nodesStorage, fabric);
+    this.nodesStore.peers = this.peers = new import_protocol.PeerSet({
+      sessions: this.sessionManager,
+      channels: this.channelManager,
+      exchanges: this.exchangeManager,
+      scanners: this.scanners,
+      netInterfaces: this.netInterfaces,
+      store: this.nodesStore
+    });
+    this.commissioner = new import_protocol.ControllerCommissioner({
+      peers: this.peers,
+      scanners: this.scanners,
+      netInterfaces: this.netInterfaces,
+      exchanges: this.exchangeManager,
+      sessions: this.sessionManager,
+      certificates: this.certificateManager
+    });
     this.#construction = (0, import_general.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.peers.construction.ready;
       await this.sessionManager.construction.ready;
     });
   }
@@ -241,191 +230,36 @@ class MatterController {
    * Return true when the commissioning process is completed successfully, false on error.
    */
   async commission(options, completeCommissioningCallback) {
-    const {
-      commissioning: commissioningOptions = {
-        regulatoryLocation: import_clusters.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.scanners.hasScannerFor(import_general.ChannelType.UDP) && this.netInterfaces.hasInterfaceFor(import_general.ChannelType.UDP, "::") !== 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 ${import_general.Logger.toJSON(identifierData)} and ${scannersToUse.length} scanners and knownAddress ${import_general.Logger.toJSON(knownAddress)}`
-    );
-    let paseSecureChannel;
-    let discoveryData;
-    if (knownAddress !== void 0) {
-      try {
-        paseSecureChannel = await this.initializePaseSecureChannel(knownAddress, passcode);
-      } catch (error) {
-        import_general.NoResponseTimeoutError.accept(error);
-      }
-    }
-    if (paseSecureChannel === void 0) {
-      const discoveredDevices = await import_protocol.ControllerDiscovery.discoverDeviceAddressesByIdentifier(
-        scannersToUse,
-        identifierData,
-        timeoutSeconds
-      );
-      const { result } = await import_protocol.ControllerDiscovery.iterateServerAddresses(
-        discoveredDevices,
-        import_general.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 import_protocol.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`, import_protocol.MdnsScanner.discoveryDataDiagnostics(device));
-    }
-    if (address.type === "udp") {
-      const { ip } = address;
-      const isIpv6Address = (0, import_general.isIPv6)(ip);
-      const paseInterface = this.netInterfaces.interfaceFor(import_general.ChannelType.UDP, isIpv6Address ? "::" : "0.0.0.0");
-      if (paseInterface === void 0) {
-        throw new import_protocol.PairRetransmissionLimitReachedError(
-          `IPv${isIpv6Address ? "6" : "4"} interface not initialized. Cannot use ${ip} for commissioning.`
-        );
-      }
-      paseChannel = await paseInterface.openChannel(address);
-    } else {
-      const ble = this.netInterfaces.interfaceFor(import_general.ChannelType.BLE);
-      if (!ble) {
-        throw new import_protocol.PairRetransmissionLimitReachedError(
-          `BLE interface not initialized. Cannot use ${address.peripheralAddress} for commissioning.`
-        );
-      }
-      paseChannel = await ble.openChannel(address);
-    }
-    const unsecureSession = this.sessionManager.createInsecureSession({
-      // 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 import_protocol.MessageChannel(paseChannel, unsecureSession);
-    const paseExchange = this.exchangeManager.initiateExchangeWithChannel(
-      paseUnsecureMessageChannel,
-      import_types.SECURE_CHANNEL_PROTOCOL_ID
-    );
-    let paseSecureSession;
-    try {
-      paseSecureSession = await this.paseClient.pair(
-        this.sessionManager.sessionParameters,
-        paseExchange,
-        passcode
-      );
-    } catch (e) {
-      await paseExchange.close();
-      throw e;
-    }
-    await unsecureSession.destroy();
-    return new import_protocol.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 ?? import_types.NodeId.randomOperationalNodeId();
-    const commissioningManager = new import_protocol.ControllerCommissioner(
-      // Use the created secure session to do the commissioning
-      new import_protocol.InteractionClient(new import_protocol.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 import_protocol.RetransmissionLimitReachedError("Device could not be discovered");
-          }
-          throw new import_protocol.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: import_protocol.NodeDiscoveryType.TimedDiscovery,
       timeoutSeconds: 120,
       discoveryData
     });
@@ -438,318 +272,44 @@ class MatterController {
       useExtendedFailSafeMessageResponseTimeout: true
     });
     if (errorCode !== import_clusters.GeneralCommissioning.CommissioningError.Ok) {
-      if (this.commissionedNodes.has(peerNodeId)) {
-        this.commissionedNodes.delete(peerNodeId);
-      }
+      await this.peers.delete(this.fabric.addressOf(peerNodeId));
       throw new import_protocol.CommissioningError(`Commission error on commissioningComplete: ${errorCode}, ${debugText}`);
     }
     await this.fabricStorage?.set("fabric", this.fabric.toStorageObject());
   }
-  #handleResubmissionStarted(peerNodeId) {
-    if (peerNodeId === void 0) {
-      return;
-    }
-    if (this.#runningNodeDiscoveries.has(peerNodeId)) {
-      return;
-    }
-    this.#runningNodeDiscoveries.set(peerNodeId, { type: 1 /* RetransmissionDiscovery */ });
-    this.scanners.scannerFor(import_general.ChannelType.UDP)?.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 import_general.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 import_general.ImplementationError("Cannot set timeout without timed discovery.");
-    }
-    if (requestedDiscoveryType === 1 /* RetransmissionDiscovery */) {
-      throw new import_general.ImplementationError("Cannot set retransmission discovery type.");
-    }
-    const mdnsScanner = this.scanners.scannerFor(import_general.ChannelType.UDP);
-    if (!mdnsScanner) {
-      throw new import_general.ImplementationError("Cannot discover device without mDNS scanner.");
-    }
-    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 import_protocol.DiscoveryError(`Node ${peerNodeId} is not reachable right now.`);
-      }
-    }
-    if (promises !== void 0) {
-      if (runningDiscoveryType > requestedDiscoveryType) {
-        throw new import_protocol.DiscoveryError(
-          `Node ${peerNodeId} is not reachable right now and discovery already running.`
-        );
-      } else {
-        return await (0, import_general.anyPromise)(promises);
-      }
-    }
-    const discoveryPromises = new Array();
-    let reconnectionPollingTimer;
-    if (operationalAddress !== void 0) {
-      if (requestedDiscoveryType === 3 /* FullDiscovery */) {
-        const { promise, resolver, rejecter } = (0, import_general.createPromise)();
-        reconnectionPollingTimer = import_general.Time.getPeriodicTimer(
-          "Controller reconnect",
-          RECONNECTION_POLLING_INTERVAL_MS,
-          async () => {
-            try {
-              logger.debug(`Polling for device at ${(0, import_general.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 import_protocol.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 import_protocol.ControllerDiscovery.iterateServerAddresses(
-        [scanResult],
-        import_general.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 (0, import_general.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 import_protocol.DiscoveryError || error instanceof import_general.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 = (0, import_general.isIPv6)(ip);
-    const operationalInterface = this.netInterfaces.interfaceFor(import_general.ChannelType.UDP, isIpv6Address ? "::" : "0.0.0.0");
-    if (operationalInterface === void 0) {
-      throw new import_protocol.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.createInsecureSession({
-      // 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 import_protocol.MessageChannel(operationalChannel, unsecureSession);
-    let operationalSecureSession;
-    try {
-      const exchange = this.exchangeManager.initiateExchangeWithChannel(
-        operationalUnsecureMessageExchange,
-        import_types.SECURE_CHANNEL_PROTOCOL_ID
-      );
-      try {
-        operationalSecureSession = await this.caseClient.pair(
-          exchange,
-          this.fabric,
-          peerNodeId,
-          expectedProcessingTimeMs
-        );
-      } catch (e) {
-        await exchange.close();
-        throw e;
-      }
-    } catch (e) {
-      import_general.NoResponseTimeoutError.accept(e);
-      throw new import_protocol.PairRetransmissionLimitReachedError(e.message);
-    }
-    await unsecureSession.destroy();
-    const channel = new import_protocol.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 ? (0, import_general.serverAddressToString)(operationalServerAddress) : void 0,
+    return this.peers.map((peer) => {
+      const { address, operationalAddress, discoveryData, basicInformationData } = peer;
+      return {
+        nodeId: address.nodeId,
+        operationalAddress: operationalAddress ? (0, import_general.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) {
-      import_protocol.NoChannelError.accept(error);
-      channel = await this.resume(peerNodeId, discoveryOptions);
-    }
-    return new import_protocol.InteractionClient(
-      new import_protocol.ExchangeProvider(this.exchangeManager, channel, async () => {
-        if (!this.channelManager.hasChannel(this.fabric, peerNodeId)) {
-          throw new import_protocol.RetransmissionLimitReachedError(`Device ${peerNodeId} is currently not reachable.`);
-        }
-        await this.channelManager.removeAllNodeChannels(this.fabric, peerNodeId);
-        const mdnsScanner = this.scanners.scannerFor(import_general.ChannelType.UDP);
-        const discoveredAddresses = 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 import_protocol.RetransmissionLimitReachedError(`No operational address found for node ${peerNodeId}`);
-        }
-        if (await this.reconnectKnownAddress(peerNodeId, operationalAddress, discoveryData, 2e3) === void 0) {
-          throw new import_protocol.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();
@@ -758,7 +318,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);
@@ -766,11 +326,7 @@ class MatterController {
   announce() {
   }
   async close() {
-    const mdnsScanner = this.scanners.scannerFor(import_general.ChannelType.UDP);
-    for (const [nodeId, { timer }] of this.#runningNodeDiscoveries.entries()) {
-      timer?.stop();
-      mdnsScanner?.cancelOperationalDeviceDiscovery(this.fabric, nodeId, false);
-    }
+    await this.peers.close();
     await this.exchangeManager.close();
     await this.sessionManager.close();
     await this.channelManager.close();
@@ -780,4 +336,48 @@ class MatterController {
     return this.sessionManager.getActiveSessionInformation();
   }
 }
+class CommissionedNodeStore extends import_protocol.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 }
+        ];
+      })
+    );
+  }
+}
 //# sourceMappingURL=MatterController.js.map