diff --git a/src/darwin/Framework/CHIP/MTRDeviceControllerOverXPC.m b/src/darwin/Framework/CHIP/MTRDeviceControllerOverXPC.m
index 52cfb22..fe4804f 100644
--- a/src/darwin/Framework/CHIP/MTRDeviceControllerOverXPC.m
+++ b/src/darwin/Framework/CHIP/MTRDeviceControllerOverXPC.m
@@ -88,6 +88,9 @@
 
 - (void)fetchControllerIdWithQueue:(dispatch_queue_t)queue completion:(MTRFetchControllerIDCompletion)completion
 {
+    // Capture the proxy handle so that it won't be released prior to block call.
+    __block MTRDeviceControllerXPCProxyHandle * handleRetainer = nil;
+
     dispatch_async(_workQueue, ^{
         dispatch_group_t group = dispatch_group_create();
         if (!self.controllerID) {
@@ -100,10 +103,9 @@
                             MTR_LOG_ERROR("Failed to fetch any shared remote controller");
                         } else {
                             self.controllerID = controller;
+                            handleRetainer = handle;
                         }
                         dispatch_group_leave(group);
-                        __auto_type handleRetainer = handle;
-                        (void) handleRetainer;
                     }];
                 } else {
                     MTR_LOG_ERROR("XPC disconnected while retrieving any shared remote controller");
@@ -113,9 +115,9 @@
         }
         dispatch_group_notify(group, queue, ^{
             if (self.controllerID) {
-                completion(self.controllerID, nil);
+                completion(self.controllerID, handleRetainer, nil);
             } else {
-                completion(nil, [NSError errorWithDomain:MTRErrorDomain code:MTRErrorCodeGeneralError userInfo:nil]);
+                completion(nil, nil, [NSError errorWithDomain:MTRErrorDomain code:MTRErrorCodeGeneralError userInfo:nil]);
             }
         });
     });
diff --git a/src/darwin/Framework/CHIP/MTRDeviceControllerOverXPC_Internal.h b/src/darwin/Framework/CHIP/MTRDeviceControllerOverXPC_Internal.h
index d772dab..ccbc2f2 100644
--- a/src/darwin/Framework/CHIP/MTRDeviceControllerOverXPC_Internal.h
+++ b/src/darwin/Framework/CHIP/MTRDeviceControllerOverXPC_Internal.h
@@ -20,7 +20,8 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-typedef void (^MTRFetchControllerIDCompletion)(id _Nullable controllerID, NSError * _Nullable error);
+typedef void (^MTRFetchControllerIDCompletion)(
+    id _Nullable controllerID, MTRDeviceControllerXPCProxyHandle * _Nullable handle, NSError * _Nullable error);
 
 @interface MTRDeviceControllerOverXPC ()
 
diff --git a/src/darwin/Framework/CHIP/MTRDeviceOverXPC.m b/src/darwin/Framework/CHIP/MTRDeviceOverXPC.m
index 4d16e9e..a978272 100644
--- a/src/darwin/Framework/CHIP/MTRDeviceOverXPC.m
+++ b/src/darwin/Framework/CHIP/MTRDeviceOverXPC.m
@@ -27,6 +27,8 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
+typedef void (^MTRFetchProxyHandleCompletion)(MTRDeviceControllerXPCProxyHandle * _Nullable handle, NSError * _Nullable error);
+
 @interface MTRDeviceOverXPC ()
 
 @property (nonatomic, strong, readonly, nullable) id<NSCopying> controllerID;
@@ -34,6 +36,8 @@
 @property (nonatomic, readonly) NSNumber * nodeID;
 @property (nonatomic, strong, readonly) MTRDeviceControllerXPCConnection * xpcConnection;
 
+- (void)fetchProxyHandleWithQueue:(dispatch_queue_t)queue completion:(MTRFetchProxyHandleCompletion)completion;
+
 @end
 
 @implementation MTRDeviceOverXPC
@@ -60,52 +64,35 @@
 {
     MTR_LOG_DEBUG("Subscribing all attributes... Note that attributeReportHandler, eventReportHandler, and resubscriptionScheduled "
                   "are not supported.");
-    __auto_type workBlock = ^{
+
+    __auto_type workBlock = ^(MTRDeviceControllerXPCProxyHandle * _Nullable handle, NSError * _Nullable error) {
+        if (error != nil) {
+            errorHandler(error);
+            return;
+        }
+
         if (clusterStateCacheContainer) {
             [clusterStateCacheContainer setXPCConnection:self->_xpcConnection controllerID:self.controllerID deviceID:self.nodeID];
         }
-        [self->_xpcConnection getProxyHandleWithCompletion:^(
-            dispatch_queue_t _Nonnull proxyQueue, MTRDeviceControllerXPCProxyHandle * _Nullable handle) {
-            if (handle) {
-                [handle.proxy subscribeWithController:self.controllerID
-                                               nodeID:self.nodeID
-                                               params:[MTRDeviceController encodeXPCSubscribeParams:params]
-                                          shouldCache:(clusterStateCacheContainer != nil)
-                                           completion:^(NSError * _Nullable error) {
-                                               dispatch_async(queue, ^{
-                                                   if (error) {
-                                                       errorHandler(error);
-                                                   } else {
-                                                       subscriptionEstablishedHandler();
-                                                   }
-                                               });
-                                               __auto_type handleRetainer = handle;
-                                               (void) handleRetainer;
-                                           }];
-            } else {
-                MTR_LOG_ERROR("Failed to obtain XPC connection to write attribute");
-                dispatch_async(queue, ^{
-                    errorHandler([NSError errorWithDomain:MTRErrorDomain code:MTRErrorCodeGeneralError userInfo:nil]);
-                });
-            }
-        }];
+
+        [handle.proxy subscribeWithController:self.controllerID
+                                       nodeID:self.nodeID
+                                       params:[MTRDeviceController encodeXPCSubscribeParams:params]
+                                  shouldCache:(clusterStateCacheContainer != nil)
+                                   completion:^(NSError * _Nullable error) {
+                                       dispatch_async(queue, ^{
+                                           if (error) {
+                                               errorHandler(error);
+                                           } else {
+                                               subscriptionEstablishedHandler();
+                                           }
+                                       });
+                                       __auto_type handleRetainer = handle;
+                                       (void) handleRetainer;
+                                   }];
     };
 
-    if (self.controllerID != nil) {
-        workBlock();
-    } else {
-        [self.controller fetchControllerIdWithQueue:queue
-                                         completion:^(id _Nullable controllerID, NSError * _Nullable error) {
-                                             if (error != nil) {
-                                                 // We're already running on the right queue.
-                                                 errorHandler(error);
-                                                 return;
-                                             }
-
-                                             self->_controllerID = controllerID;
-                                             workBlock();
-                                         }];
-    }
+    [self fetchProxyHandleWithQueue:queue completion:workBlock];
 }
 
 - (void)readAttributePathWithEndpointID:(NSNumber * _Nullable)endpointID
@@ -116,50 +103,32 @@
                              completion:(MTRDeviceResponseHandler)completion
 {
     MTR_LOG_DEBUG("Reading attribute ...");
-    __auto_type workBlock = ^{
-        [self->_xpcConnection getProxyHandleWithCompletion:^(
-            dispatch_queue_t _Nonnull proxyQueue, MTRDeviceControllerXPCProxyHandle * _Nullable handle) {
-            if (handle) {
-                [handle.proxy readAttributeWithController:self.controllerID
-                                                   nodeID:self.nodeID
-                                               endpointID:endpointID
-                                                clusterID:clusterID
-                                              attributeID:attributeID
-                                                   params:[MTRDeviceController encodeXPCReadParams:params]
-                                               completion:^(id _Nullable values, NSError * _Nullable error) {
-                                                   dispatch_async(queue, ^{
-                                                       MTR_LOG_DEBUG("Attribute read");
-                                                       completion([MTRDeviceController decodeXPCResponseValues:values], error);
-                                                       // The following captures the proxy handle in the closure so that the
-                                                       // handle won't be released prior to block call.
-                                                       __auto_type handleRetainer = handle;
-                                                       (void) handleRetainer;
-                                                   });
-                                               }];
-            } else {
-                dispatch_async(queue, ^{
-                    MTR_LOG_ERROR("Failed to obtain XPC connection to read attribute");
-                    completion(nil, [NSError errorWithDomain:MTRErrorDomain code:MTRErrorCodeGeneralError userInfo:nil]);
-                });
-            }
-        }];
+
+    __auto_type workBlock = ^(MTRDeviceControllerXPCProxyHandle * _Nullable handle, NSError * _Nullable error) {
+        if (error != nil) {
+            completion(nil, error);
+            return;
+        }
+
+        [handle.proxy readAttributeWithController:self.controllerID
+                                           nodeID:self.nodeID
+                                       endpointID:endpointID
+                                        clusterID:clusterID
+                                      attributeID:attributeID
+                                           params:[MTRDeviceController encodeXPCReadParams:params]
+                                       completion:^(id _Nullable values, NSError * _Nullable error) {
+                                           dispatch_async(queue, ^{
+                                               MTR_LOG_DEBUG("Attribute read");
+                                               completion([MTRDeviceController decodeXPCResponseValues:values], error);
+                                               // The following captures the proxy handle in the closure so that the
+                                               // handle won't be released prior to block call.
+                                               __auto_type handleRetainer = handle;
+                                               (void) handleRetainer;
+                                           });
+                                       }];
     };
 
-    if (self.controllerID != nil) {
-        workBlock();
-    } else {
-        [self.controller fetchControllerIdWithQueue:queue
-                                         completion:^(id _Nullable controllerID, NSError * _Nullable error) {
-                                             if (error != nil) {
-                                                 // We're already running on the right queue.
-                                                 completion(nil, error);
-                                                 return;
-                                             }
-
-                                             self->_controllerID = controllerID;
-                                             workBlock();
-                                         }];
-    }
+    [self fetchProxyHandleWithQueue:queue completion:workBlock];
 }
 
 - (void)writeAttributeWithEndpointID:(NSNumber *)endpointID
@@ -171,51 +140,33 @@
                           completion:(MTRDeviceResponseHandler)completion
 {
     MTR_LOG_DEBUG("Writing attribute ...");
-    __auto_type workBlock = ^{
-        [self->_xpcConnection getProxyHandleWithCompletion:^(
-            dispatch_queue_t _Nonnull proxyQueue, MTRDeviceControllerXPCProxyHandle * _Nullable handle) {
-            if (handle) {
-                [handle.proxy writeAttributeWithController:self.controllerID
-                                                    nodeID:self.nodeID
-                                                endpointID:endpointID
-                                                 clusterID:clusterID
-                                               attributeID:attributeID
-                                                     value:value
-                                         timedWriteTimeout:timeoutMs
-                                                completion:^(id _Nullable values, NSError * _Nullable error) {
-                                                    dispatch_async(queue, ^{
-                                                        MTR_LOG_DEBUG("Attribute written");
-                                                        completion([MTRDeviceController decodeXPCResponseValues:values], error);
-                                                        // The following captures the proxy handle in the closure so that the
-                                                        // handle won't be released prior to block call.
-                                                        __auto_type handleRetainer = handle;
-                                                        (void) handleRetainer;
-                                                    });
-                                                }];
-            } else {
-                dispatch_async(queue, ^{
-                    MTR_LOG_ERROR("Failed to obtain XPC connection to write attribute");
-                    completion(nil, [NSError errorWithDomain:MTRErrorDomain code:MTRErrorCodeGeneralError userInfo:nil]);
-                });
-            }
-        }];
+
+    __auto_type workBlock = ^(MTRDeviceControllerXPCProxyHandle * _Nullable handle, NSError * _Nullable error) {
+        if (error != nil) {
+            completion(nil, error);
+            return;
+        }
+
+        [handle.proxy writeAttributeWithController:self.controllerID
+                                            nodeID:self.nodeID
+                                        endpointID:endpointID
+                                         clusterID:clusterID
+                                       attributeID:attributeID
+                                             value:value
+                                 timedWriteTimeout:timeoutMs
+                                        completion:^(id _Nullable values, NSError * _Nullable error) {
+                                            dispatch_async(queue, ^{
+                                                MTR_LOG_DEBUG("Attribute written");
+                                                completion([MTRDeviceController decodeXPCResponseValues:values], error);
+                                                // The following captures the proxy handle in the closure so that the
+                                                // handle won't be released prior to block call.
+                                                __auto_type handleRetainer = handle;
+                                                (void) handleRetainer;
+                                            });
+                                        }];
     };
 
-    if (self.controllerID != nil) {
-        workBlock();
-    } else {
-        [self.controller fetchControllerIdWithQueue:queue
-                                         completion:^(id _Nullable controllerID, NSError * _Nullable error) {
-                                             if (error != nil) {
-                                                 // We're already running on the right queue.
-                                                 completion(nil, error);
-                                                 return;
-                                             }
-
-                                             self->_controllerID = controllerID;
-                                             workBlock();
-                                         }];
-    }
+    [self fetchProxyHandleWithQueue:queue completion:workBlock];
 }
 
 - (void)invokeCommandWithEndpointID:(NSNumber *)endpointID
@@ -227,51 +178,33 @@
                          completion:(MTRDeviceResponseHandler)completion
 {
     MTR_LOG_DEBUG("Invoking command ...");
-    __auto_type workBlock = ^{
-        [self->_xpcConnection getProxyHandleWithCompletion:^(
-            dispatch_queue_t _Nonnull proxyQueue, MTRDeviceControllerXPCProxyHandle * _Nullable handle) {
-            if (handle) {
-                [handle.proxy invokeCommandWithController:self.controllerID
-                                                   nodeID:self.nodeID
-                                               endpointID:endpointID
-                                                clusterID:clusterID
-                                                commandID:commandID
-                                                   fields:commandFields
-                                       timedInvokeTimeout:timeoutMs
-                                               completion:^(id _Nullable values, NSError * _Nullable error) {
-                                                   dispatch_async(queue, ^{
-                                                       MTR_LOG_DEBUG("Command invoked");
-                                                       completion([MTRDeviceController decodeXPCResponseValues:values], error);
-                                                       // The following captures the proxy handle in the closure so that the
-                                                       // handle won't be released prior to block call.
-                                                       __auto_type handleRetainer = handle;
-                                                       (void) handleRetainer;
-                                                   });
-                                               }];
-            } else {
-                dispatch_async(queue, ^{
-                    MTR_LOG_ERROR("Failed to obtain XPC connection to invoke command");
-                    completion(nil, [NSError errorWithDomain:MTRErrorDomain code:MTRErrorCodeGeneralError userInfo:nil]);
-                });
-            }
-        }];
+
+    __auto_type workBlock = ^(MTRDeviceControllerXPCProxyHandle * _Nullable handle, NSError * _Nullable error) {
+        if (error != nil) {
+            completion(nil, error);
+            return;
+        }
+
+        [handle.proxy invokeCommandWithController:self.controllerID
+                                           nodeID:self.nodeID
+                                       endpointID:endpointID
+                                        clusterID:clusterID
+                                        commandID:commandID
+                                           fields:commandFields
+                               timedInvokeTimeout:timeoutMs
+                                       completion:^(id _Nullable values, NSError * _Nullable error) {
+                                           dispatch_async(queue, ^{
+                                               MTR_LOG_DEBUG("Command invoked");
+                                               completion([MTRDeviceController decodeXPCResponseValues:values], error);
+                                               // The following captures the proxy handle in the closure so that the
+                                               // handle won't be released prior to block call.
+                                               __auto_type handleRetainer = handle;
+                                               (void) handleRetainer;
+                                           });
+                                       }];
     };
 
-    if (self.controllerID != nil) {
-        workBlock();
-    } else {
-        [self.controller fetchControllerIdWithQueue:queue
-                                         completion:^(id _Nullable controllerID, NSError * _Nullable error) {
-                                             if (error != nil) {
-                                                 // We're already running on the right queue.
-                                                 completion(nil, error);
-                                                 return;
-                                             }
-
-                                             self->_controllerID = controllerID;
-                                             workBlock();
-                                         }];
-    }
+    [self fetchProxyHandleWithQueue:queue completion:workBlock];
 }
 
 - (void)subscribeAttributePathWithEndpointID:(NSNumber * _Nullable)endpointID
@@ -283,90 +216,70 @@
                      subscriptionEstablished:(void (^_Nullable)(void))subscriptionEstablishedHandler
 {
     MTR_LOG_DEBUG("Subscribing attribute ...");
-    __auto_type workBlock = ^{
-        [self->_xpcConnection getProxyHandleWithCompletion:^(
-            dispatch_queue_t _Nonnull proxyQueue, MTRDeviceControllerXPCProxyHandle * _Nullable handle) {
-            if (handle) {
-                MTR_LOG_DEBUG("Setup report handler");
-                [self.xpcConnection
-                    registerReportHandlerWithController:self.controllerID
-                                                 nodeID:self.nodeID
-                                                handler:^(id _Nullable values, NSError * _Nullable error) {
-                                                    if (values && ![values isKindOfClass:[NSArray class]]) {
-                                                        MTR_LOG_ERROR("Unsupported report format");
-                                                        return;
-                                                    }
-                                                    if (!values) {
-                                                        MTR_LOG_DEBUG("Error report received");
-                                                        dispatch_async(queue, ^{
-                                                            reportHandler(values, error);
-                                                        });
-                                                        return;
-                                                    }
-                                                    __auto_type decodedValues =
-                                                        [MTRDeviceController decodeXPCResponseValues:values];
-                                                    NSMutableArray<NSDictionary<NSString *, id> *> * filteredValues =
-                                                        [NSMutableArray arrayWithCapacity:[decodedValues count]];
-                                                    for (NSDictionary<NSString *, id> * decodedValue in decodedValues) {
-                                                        MTRAttributePath * attributePath = decodedValue[MTRAttributePathKey];
-                                                        if ((endpointID == nil ||
-                                                                [attributePath.endpoint isEqualToNumber:endpointID])
-                                                            && (clusterID == nil ||
-                                                                [attributePath.cluster isEqualToNumber:clusterID])
-                                                            && (attributeID == nil ||
-                                                                [attributePath.attribute isEqualToNumber:attributeID])) {
-                                                            [filteredValues addObject:decodedValue];
-                                                        }
-                                                    }
-                                                    if ([filteredValues count] > 0) {
-                                                        MTR_LOG_DEBUG("Report received");
-                                                        dispatch_async(queue, ^{
-                                                            reportHandler(filteredValues, error);
-                                                        });
-                                                    }
-                                                }];
 
-                [handle.proxy subscribeAttributeWithController:self.controllerID
-                                                        nodeID:self.nodeID
-                                                    endpointID:endpointID
-                                                     clusterID:clusterID
-                                                   attributeID:attributeID
-                                                        params:[MTRDeviceController encodeXPCSubscribeParams:params]
-                                            establishedHandler:^{
+    __auto_type workBlock = ^(MTRDeviceControllerXPCProxyHandle * _Nullable handle, NSError * _Nullable error) {
+        MTR_LOG_DEBUG("Setup report handler");
+
+        if (error != nil) {
+            subscriptionEstablishedHandler();
+            reportHandler(nil, error);
+            return;
+        }
+
+        [self.xpcConnection
+            registerReportHandlerWithController:self.controllerID
+                                         nodeID:self.nodeID
+                                        handler:^(id _Nullable values, NSError * _Nullable error) {
+                                            if (values && ![values isKindOfClass:[NSArray class]]) {
+                                                MTR_LOG_ERROR("Unsupported report format");
+                                                return;
+                                            }
+                                            if (!values) {
+                                                MTR_LOG_DEBUG("Error report received");
                                                 dispatch_async(queue, ^{
-                                                    MTR_LOG_DEBUG("Subscription established");
-                                                    subscriptionEstablishedHandler();
-                                                    // The following captures the proxy handle in the closure so that the handle
-                                                    // won't be released prior to block call.
-                                                    __auto_type handleRetainer = handle;
-                                                    (void) handleRetainer;
+                                                    reportHandler(values, error);
                                                 });
-                                            }];
-            } else {
-                dispatch_async(queue, ^{
-                    MTR_LOG_ERROR("Failed to obtain XPC connection to subscribe to attribute");
-                    subscriptionEstablishedHandler();
-                    reportHandler(nil, [NSError errorWithDomain:MTRErrorDomain code:MTRErrorCodeGeneralError userInfo:nil]);
-                });
-            }
-        }];
+                                                return;
+                                            }
+                                            __auto_type decodedValues = [MTRDeviceController decodeXPCResponseValues:values];
+                                            NSMutableArray<NSDictionary<NSString *, id> *> * filteredValues =
+                                                [NSMutableArray arrayWithCapacity:[decodedValues count]];
+                                            for (NSDictionary<NSString *, id> * decodedValue in decodedValues) {
+                                                MTRAttributePath * attributePath = decodedValue[MTRAttributePathKey];
+                                                if ((endpointID == nil || [attributePath.endpoint isEqualToNumber:endpointID])
+                                                    && (clusterID == nil || [attributePath.cluster isEqualToNumber:clusterID])
+                                                    && (attributeID == nil ||
+                                                        [attributePath.attribute isEqualToNumber:attributeID])) {
+                                                    [filteredValues addObject:decodedValue];
+                                                }
+                                            }
+                                            if ([filteredValues count] > 0) {
+                                                MTR_LOG_DEBUG("Report received");
+                                                dispatch_async(queue, ^{
+                                                    reportHandler(filteredValues, error);
+                                                });
+                                            }
+                                        }];
+
+        [handle.proxy subscribeAttributeWithController:self.controllerID
+                                                nodeID:self.nodeID
+                                            endpointID:endpointID
+                                             clusterID:clusterID
+                                           attributeID:attributeID
+                                                params:[MTRDeviceController encodeXPCSubscribeParams:params]
+                                    establishedHandler:^{
+                                        dispatch_async(queue, ^{
+                                            MTR_LOG_DEBUG("Subscription established");
+                                            subscriptionEstablishedHandler();
+                                            // The following captures the proxy handle in the closure so that the handle
+                                            // won't be released prior to block call.
+                                            __auto_type handleRetainer = handle;
+                                            (void) handleRetainer;
+                                        });
+                                    }];
     };
 
-    if (self.controllerID != nil) {
-        workBlock();
-    } else {
-        [self.controller fetchControllerIdWithQueue:queue
-                                         completion:^(id _Nullable controllerID, NSError * _Nullable error) {
-                                             if (error != nil) {
-                                                 // We're already running on the right queue.
-                                                 reportHandler(nil, error);
-                                                 return;
-                                             }
-
-                                             self->_controllerID = controllerID;
-                                             workBlock();
-                                         }];
-    }
+    [self fetchProxyHandleWithQueue:queue completion:workBlock];
 }
 
 - (void)deregisterReportHandlersWithQueue:(dispatch_queue_t)queue completion:(void (^)(void))completion
@@ -384,7 +297,8 @@
         workBlock();
     } else {
         [self.controller fetchControllerIdWithQueue:queue
-                                         completion:^(id _Nullable controllerID, NSError * _Nullable error) {
+                                         completion:^(id _Nullable controllerID,
+                                             MTRDeviceControllerXPCProxyHandle * _Nullable handle, NSError * _Nullable error) {
                                              if (error != nil) {
                                                  // We're already running on the right queue.
                                                  completion();
@@ -409,6 +323,35 @@
     });
 }
 
+- (void)fetchProxyHandleWithQueue:(dispatch_queue_t)queue completion:(MTRFetchProxyHandleCompletion)completion
+{
+    if (self.controllerID != nil) {
+        [self->_xpcConnection getProxyHandleWithCompletion:^(
+            dispatch_queue_t _Nonnull proxyQueue, MTRDeviceControllerXPCProxyHandle * _Nullable handle) {
+            dispatch_async(queue, ^{
+                if (handle == nil) {
+                    MTR_LOG_ERROR("Failed to obtain XPC connection");
+                    completion(nil, [NSError errorWithDomain:MTRErrorDomain code:MTRErrorCodeGeneralError userInfo:nil]);
+                } else {
+                    completion(handle, nil);
+                }
+            });
+        }];
+    } else {
+        [self.controller fetchControllerIdWithQueue:queue
+                                         completion:^(id _Nullable controllerID,
+                                             MTRDeviceControllerXPCProxyHandle * _Nullable handle, NSError * _Nullable error) {
+                                             // We're already running on the right queue.
+                                             if (error != nil) {
+                                                 completion(nil, error);
+                                             } else {
+                                                 self->_controllerID = controllerID;
+                                                 completion(handle, nil);
+                                             }
+                                         }];
+    }
+}
+
 @end
 
 NS_ASSUME_NONNULL_END
diff --git a/src/darwin/Framework/CHIPTests/MTRXPCProtocolTests.m b/src/darwin/Framework/CHIPTests/MTRXPCProtocolTests.m
index 6e8e5d1..91c4e21 100644
--- a/src/darwin/Framework/CHIPTests/MTRXPCProtocolTests.m
+++ b/src/darwin/Framework/CHIPTests/MTRXPCProtocolTests.m
@@ -2331,6 +2331,7 @@
               completion(nil, myError);
           };
 
+    _xpcDisconnectExpectation = [self expectationWithDescription:@"XPC Disconnected"];
     [clusterStateCacheContainer subscribeWithDeviceController:_remoteDeviceController
                                                      deviceID:@(myNodeId)
                                                        params:nil
@@ -2340,7 +2341,7 @@
                                                        XCTAssertNil(error);
                                                        [subscribeExpectation fulfill];
                                                    }];
-    [self waitForExpectations:@[ subscribeExpectation ] timeout:kTimeoutInSeconds];
+    [self waitForExpectations:@[ subscribeExpectation, _xpcDisconnectExpectation ] timeout:kTimeoutInSeconds];
 
     _xpcDisconnectExpectation = [self expectationWithDescription:@"XPC Disconnected"];
     [clusterStateCacheContainer