diff --git a/examples/all-clusters-app/esp32/main/RendezvousDeviceDelegate.cpp b/examples/all-clusters-app/esp32/main/RendezvousDeviceDelegate.cpp
index 5060b57..683a577 100644
--- a/examples/all-clusters-app/esp32/main/RendezvousDeviceDelegate.cpp
+++ b/examples/all-clusters-app/esp32/main/RendezvousDeviceDelegate.cpp
@@ -70,12 +70,23 @@
         bluetoothLED.Set(true);
         break;
 
+    case RendezvousSessionDelegate::SecurePairingFailed:
+        ESP_LOGI(TAG, "Failed in SPAKE2+ handshake\n");
+        bluetoothLED.Set(false);
+        break;
+
     case RendezvousSessionDelegate::NetworkProvisioningSuccess:
 
         ESP_LOGI(TAG, "Device was assigned an ip address\n");
         bluetoothLED.Set(false);
         break;
 
+    case RendezvousSessionDelegate::NetworkProvisioningFailed:
+
+        ESP_LOGI(TAG, "Failed in network provisioning\n");
+        bluetoothLED.Set(false);
+        break;
+
     default:
         break;
     };
diff --git a/examples/chip-tool/commands/common/Command.h b/examples/chip-tool/commands/common/Command.h
index 8c81731..7ef5727 100644
--- a/examples/chip-tool/commands/common/Command.h
+++ b/examples/chip-tool/commands/common/Command.h
@@ -18,7 +18,7 @@
 
 #pragma once
 
-#include <controller/CHIPDeviceController.h>
+#include <controller/CHIPDeviceController_deprecated.h>
 #include <inet/InetInterface.h>
 #include <support/logging/CHIPLogging.h>
 
diff --git a/examples/chip-tool/commands/common/Commands.h b/examples/chip-tool/commands/common/Commands.h
index 531b557..c331831 100644
--- a/examples/chip-tool/commands/common/Commands.h
+++ b/examples/chip-tool/commands/common/Commands.h
@@ -21,7 +21,7 @@
 #include "Command.h"
 #include <map>
 
-#include <controller/CHIPDeviceController.h>
+#include <controller/CHIPDeviceController_deprecated.h>
 
 class Commands
 {
diff --git a/src/controller/BUILD.gn b/src/controller/BUILD.gn
index 7d843de..aaab1fe 100644
--- a/src/controller/BUILD.gn
+++ b/src/controller/BUILD.gn
@@ -18,8 +18,12 @@
   output_name = "libChipController"
 
   sources = [
+    "CHIPDevice.cpp",
+    "CHIPDevice.h",
     "CHIPDeviceController.cpp",
     "CHIPDeviceController.h",
+    "CHIPDeviceController_deprecated.cpp",
+    "CHIPDeviceController_deprecated.h",
   ]
 
   cflags = [ "-Wconversion" ]
diff --git a/src/controller/CHIPDevice.cpp b/src/controller/CHIPDevice.cpp
new file mode 100644
index 0000000..68048e7
--- /dev/null
+++ b/src/controller/CHIPDevice.cpp
@@ -0,0 +1,216 @@
+/*
+ *
+ *    Copyright (c) 2020 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ *  @file
+ *    This file contains implementation of Device class. The objects of this
+ *    class will be used by Controller applications to interact with CHIP
+ *    devices. The class provides mechanism to construct, send and receive
+ *    messages to and from the corresponding CHIP devices.
+ */
+
+#include <controller/CHIPDevice.h>
+
+#if CONFIG_DEVICE_LAYER
+#include <platform/CHIPDeviceLayer.h>
+#endif
+
+#include <core/CHIPCore.h>
+#include <core/CHIPEncoding.h>
+#include <core/CHIPSafeCasts.h>
+#include <support/Base64.h>
+#include <support/CHIPMem.h>
+#include <support/CodeUtils.h>
+#include <support/ErrorStr.h>
+#include <support/SafeInt.h>
+#include <support/logging/CHIPLogging.h>
+
+using namespace chip::Inet;
+using namespace chip::System;
+
+namespace chip {
+namespace Controller {
+
+CHIP_ERROR Device::SendMessage(System::PacketBuffer * buffer)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+
+    System::PacketBuffer * resend = nullptr;
+
+    VerifyOrExit(mSessionManager != nullptr, err = CHIP_ERROR_INCORRECT_STATE);
+    VerifyOrExit(buffer != nullptr, err = CHIP_ERROR_INVALID_ARGUMENT);
+
+    // If there is no secure connection to the device, try establishing it
+    if (mState != ConnectionState::SecureConnected)
+    {
+        err = LoadSecureSessionParameters();
+        SuccessOrExit(err);
+    }
+    else
+    {
+        // Secure connection already exists
+        // Hold on to the buffer, in case session resumption and resend is needed
+        buffer->AddRef();
+        resend = buffer;
+    }
+
+    err    = mSessionManager->SendMessage(mDeviceId, buffer);
+    buffer = nullptr;
+    ChipLogDetail(Controller, "SendMessage returned %d", err);
+
+    // The send could fail due to network timeouts (e.g. broken pipe)
+    // Try sesion resumption if needed
+    if (err != CHIP_NO_ERROR && resend != nullptr && mState == ConnectionState::SecureConnected)
+    {
+        mState = ConnectionState::NotConnected;
+
+        err = LoadSecureSessionParameters();
+        SuccessOrExit(err);
+
+        err    = mSessionManager->SendMessage(mDeviceId, resend);
+        resend = nullptr;
+        ChipLogDetail(Controller, "Re-SendMessage returned %d", err);
+        SuccessOrExit(err);
+    }
+
+exit:
+
+    if (buffer != nullptr)
+    {
+        PacketBuffer::Free(buffer);
+    }
+
+    if (resend != nullptr)
+    {
+        PacketBuffer::Free(resend);
+    }
+
+    return err;
+}
+
+CHIP_ERROR Device::Serialize(SerializedDevice & output)
+{
+    CHIP_ERROR error       = CHIP_NO_ERROR;
+    uint16_t serializedLen = 0;
+    SerializableDevice serializable;
+
+    nlSTATIC_ASSERT_PRINT(BASE64_ENCODED_LEN(sizeof(serializable)) <= sizeof(output.inner),
+                          "Size of serializable should be <= size of output");
+
+    CHIP_ZERO_AT(serializable);
+
+    memmove(&serializable.mOpsCreds, &mPairing, sizeof(mPairing));
+    serializable.mDeviceId   = Encoding::LittleEndian::HostSwap64(mDeviceId);
+    serializable.mDevicePort = Encoding::LittleEndian::HostSwap16(mDevicePort);
+    nlSTATIC_ASSERT_PRINT(sizeof(serializable.mDeviceAddr) <= INET6_ADDRSTRLEN,
+                          "Size of device address must fit within INET6_ADDRSTRLEN");
+    mDeviceAddr.ToString(Uint8::to_char(serializable.mDeviceAddr), sizeof(serializable.mDeviceAddr));
+
+    serializedLen = chip::Base64Encode(Uint8::to_const_uchar(reinterpret_cast<uint8_t *>(&serializable)),
+                                       static_cast<uint16_t>(sizeof(serializable)), Uint8::to_char(output.inner));
+    VerifyOrExit(serializedLen > 0, error = CHIP_ERROR_INVALID_ARGUMENT);
+    VerifyOrExit(serializedLen < sizeof(output.inner), error = CHIP_ERROR_INVALID_ARGUMENT);
+    output.inner[serializedLen] = '\0';
+
+exit:
+    return error;
+}
+
+CHIP_ERROR Device::Deserialize(const SerializedDevice & input)
+{
+    CHIP_ERROR error = CHIP_NO_ERROR;
+    SerializableDevice serializable;
+    size_t maxlen            = BASE64_ENCODED_LEN(sizeof(serializable));
+    size_t len               = strnlen(Uint8::to_const_char(&input.inner[0]), maxlen);
+    uint16_t deserializedLen = 0;
+
+    VerifyOrExit(len < sizeof(SerializedDevice), error = CHIP_ERROR_INVALID_ARGUMENT);
+    VerifyOrExit(CanCastTo<uint16_t>(len), error = CHIP_ERROR_INVALID_ARGUMENT);
+
+    CHIP_ZERO_AT(serializable);
+    deserializedLen = Base64Decode(Uint8::to_const_char(input.inner), static_cast<uint16_t>(len),
+                                   Uint8::to_uchar(reinterpret_cast<uint8_t *>(&serializable)));
+
+    VerifyOrExit(deserializedLen > 0, error = CHIP_ERROR_INVALID_ARGUMENT);
+    VerifyOrExit(deserializedLen <= sizeof(serializable), error = CHIP_ERROR_INVALID_ARGUMENT);
+
+    // The second parameter to FromString takes the strlen value. We are subtracting 1
+    // from the sizeof(serializable.mDeviceAddr) to account for null termination, since
+    // strlen doesn't include null character in the size.
+    VerifyOrExit(
+        IPAddress::FromString(Uint8::to_const_char(serializable.mDeviceAddr), sizeof(serializable.mDeviceAddr) - 1, mDeviceAddr),
+        error = CHIP_ERROR_INVALID_ADDRESS);
+
+    memmove(&mPairing, &serializable.mOpsCreds, sizeof(mPairing));
+    mDeviceId   = Encoding::LittleEndian::HostSwap64(serializable.mDeviceId);
+    mDevicePort = Encoding::LittleEndian::HostSwap16(serializable.mDevicePort);
+
+exit:
+    return error;
+}
+
+void Device::OnMessageReceived(const PacketHeader & header, const PayloadHeader & payloadHeader,
+                               Transport::PeerConnectionState * state, System::PacketBuffer * msgBuf, SecureSessionMgrBase * mgr)
+{
+    if (mState == ConnectionState::SecureConnected && mStatusDelegate != nullptr)
+    {
+        mStatusDelegate->OnMessage(msgBuf);
+    }
+}
+
+CHIP_ERROR Device::LoadSecureSessionParameters()
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    SecurePairingSession pairingSession;
+
+    if (mSessionManager == nullptr || mState == ConnectionState::SecureConnected)
+    {
+        ExitNow(err = CHIP_ERROR_INCORRECT_STATE);
+    }
+
+    err = pairingSession.FromSerializable(mPairing);
+    SuccessOrExit(err);
+
+    err = mSessionManager->ResetTransport(Transport::UdpListenParameters(mInetLayer).SetAddressType(mDeviceAddr.Type()));
+    SuccessOrExit(err);
+
+    err = mSessionManager->NewPairing(
+        Optional<Transport::PeerAddress>::Value(Transport::PeerAddress::UDP(mDeviceAddr, mDevicePort, mInterface)),
+        &pairingSession);
+    SuccessOrExit(err);
+
+    mState = ConnectionState::SecureConnected;
+
+exit:
+
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogError(Controller, "LoadSecureSessionParameters returning error %d\n", err);
+    }
+    return err;
+}
+
+bool Device::GetIpAddress(Inet::IPAddress & addr) const
+{
+    if (mState == ConnectionState::SecureConnected)
+        addr = mDeviceAddr;
+    return mState == ConnectionState::SecureConnected;
+}
+
+} // namespace Controller
+} // namespace chip
diff --git a/src/controller/CHIPDevice.h b/src/controller/CHIPDevice.h
new file mode 100644
index 0000000..69d7491
--- /dev/null
+++ b/src/controller/CHIPDevice.h
@@ -0,0 +1,260 @@
+/*
+ *
+ *    Copyright (c) 2020 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ *  @file
+ *    This file contains definitions for Device class. The objects of this
+ *    class will be used by Controller applications to interact with CHIP
+ *    devices. The class provides mechanism to construct, send and receive
+ *    messages to and from the corresponding CHIP devices.
+ */
+
+#pragma once
+
+#include <core/CHIPCore.h>
+#include <support/Base64.h>
+#include <support/DLLUtil.h>
+#include <transport/SecurePairingSession.h>
+#include <transport/SecureSessionMgr.h>
+#include <transport/raw/MessageHeader.h>
+#include <transport/raw/UDP.h>
+
+namespace chip {
+namespace Controller {
+
+class DeviceController;
+class DeviceStatusDelegate;
+struct SerializedDevice;
+
+class DLL_EXPORT Device
+{
+public:
+    Device() : mActive(false), mState(ConnectionState::NotConnected) {}
+    ~Device() {}
+
+    /**
+     * @brief
+     *   Set the delegate object which will be called when a message is received.
+     *   The user of this Device object must reset the delegate (by calling
+     *   SetDelegate(nullptr)) before releasing their delegate object.
+     *
+     * @param[in] delegate   The pointer to the delegate object.
+     */
+    void SetDelegate(DeviceStatusDelegate * delegate) { mStatusDelegate = delegate; }
+
+    // ----- Messaging -----
+    /**
+     * @brief
+     *   Send the provided message to the device
+     *
+     * @param[in] message   The message to be sent. The ownership of the message buffer
+     *                      is handed over to Device object. SendMessage() will
+     *                      decrement the reference count of the message buffer before
+     *                      returning.
+     *
+     * @return CHIP_ERROR   CHIP_NO_ERROR on success, or corresponding error
+     */
+    CHIP_ERROR SendMessage(System::PacketBuffer * message);
+
+    /**
+     * @brief
+     *   Get the IP address assigned to the device.
+     *
+     * @param[out] addr   The reference to the IP address.
+     *
+     * @return true, if the IP address was filled in the out parameter, false otherwise
+     */
+    bool GetIpAddress(Inet::IPAddress & addr) const;
+
+    /**
+     * @brief
+     *   Initialize the device object with secure session manager and inet layer object
+     *   references. This variant of function is typically used when the device object
+     *   is created from a serialized device information. The other parameters (address, port,
+     *   interface etc) are part of the serialized device, so those are not required to be
+     *   initialized.
+     *
+     *   Note: The lifetime of session manager and inet layer objects must be longer than
+     *   that of this device object. If these objects are freed, while the device object is
+     *   still using them, it can lead to unknown behavior and crashes.
+     *
+     * @param[in] sessionMgr   Secure session manager object pointer
+     * @param[in] inetLayer    InetLayer object pointer
+     */
+    void Init(SecureSessionMgr<Transport::UDP> * sessionMgr, Inet::InetLayer * inetLayer)
+    {
+        mSessionManager = sessionMgr;
+        mInetLayer      = inetLayer;
+    }
+
+    /**
+     * @brief
+     *   Initialize a new device object with secure session manager, inet layer object,
+     *   and other device specific parameters. This variant of function is typically used when
+     *   a new device is paired, and the corresponding device object needs to updated with
+     *   all device specifc parameters (address, port, interface etc).
+     *
+     *   This is not done as part of constructor so that the controller can have a list of
+     *   uninitialzed/unpaired device objects. The object is initialized only when the device
+     *   is actually paired.
+     *
+     * @param[in] sessionMgr   Secure session manager object pointer
+     * @param[in] inetLayer    InetLayer object pointer
+     * @param[in] deviceId     Node ID of the device
+     * @param[in] devicePort   Port on which device is listening (typically CHIP_PORT)
+     * @param[in] interfaceId  Local Interface ID that should be used to talk to the device
+     */
+    void Init(SecureSessionMgr<Transport::UDP> * sessionMgr, Inet::InetLayer * inetLayer, NodeId deviceId, uint16_t devicePort,
+              Inet::InterfaceId interfaceId)
+    {
+        Init(sessionMgr, inetLayer);
+        mDeviceId   = deviceId;
+        mDevicePort = devicePort;
+        mInterface  = interfaceId;
+        mState      = ConnectionState::Connecting;
+    }
+
+    /** @brief Serialize the Pairing Session to a string. It's guaranteed that the string
+     *         will be null terminated, and there won't be any embedded null characters.
+     *
+     * @return Returns a CHIP_ERROR on error, CHIP_NO_ERROR otherwise
+     **/
+    CHIP_ERROR Serialize(SerializedDevice & output);
+
+    /** @brief Deserialize the Pairing Session from the string. It's expected that the string
+     *         will be null terminated, and there won't be any embedded null characters.
+     *
+     * @return Returns a CHIP_ERROR on error, CHIP_NO_ERROR otherwise
+     **/
+    CHIP_ERROR Deserialize(const SerializedDevice & input);
+
+    /**
+     * @brief
+     *   This function is called when a message is received from the corresponding CHIP
+     *   device. The message ownership is transferred to the function, and it is expected
+     *   to release the message buffer before returning.
+     *
+     * @param[in] header        Reference to common packet header of the received message
+     * @param[in] payloadHeader Reference to payload header in the message
+     * @param[in] state         Pointer to the peer connection state on which message is received
+     * @param[in] msgBuf        The message buffer
+     * @param[in] mgr           Pointer to secure session manager which received the message
+     */
+    void OnMessageReceived(const PacketHeader & header, const PayloadHeader & payloadHeader, Transport::PeerConnectionState * state,
+                           System::PacketBuffer * msgBuf, SecureSessionMgrBase * mgr);
+
+    /**
+     * @brief
+     *   Return whether the current device object is actively associated with a paired CHIP
+     *   device. An active object can be used to communicate with the corresponding device.
+     */
+    bool IsActive() const { return mActive; }
+
+    void SetActive(bool active) { mActive = active; }
+
+    NodeId GetDeviceId() const { return mDeviceId; }
+
+    void SetAddress(const Inet::IPAddress & deviceAddr) { mDeviceAddr = deviceAddr; }
+
+    SecurePairingSessionSerializable & GetPairing() { return mPairing; }
+
+private:
+    enum class ConnectionState
+    {
+        NotConnected,
+        Connecting,
+        SecureConnected,
+    };
+
+    /* Node ID assigned to the CHIP device */
+    NodeId mDeviceId;
+
+    /* IP Address of the CHIP device */
+    Inet::IPAddress mDeviceAddr;
+
+    /* Port on which the CHIP device is receiving messages. Typically it is CHIP_PORT */
+    uint16_t mDevicePort;
+
+    /* Local network interface that should be used to communicate with the device */
+    Inet::InterfaceId mInterface;
+
+    Inet::InetLayer * mInetLayer;
+
+    bool mActive;
+    ConnectionState mState;
+
+    SecurePairingSessionSerializable mPairing;
+
+    DeviceStatusDelegate * mStatusDelegate;
+
+    SecureSessionMgr<Transport::UDP> * mSessionManager;
+
+    /**
+     * @brief
+     *   This function loads the secure session object from the serialized operational
+     *   credentials corresponding to the device. This is typically done when the device
+     *   does not have an active secure channel.
+     */
+    CHIP_ERROR LoadSecureSessionParameters();
+};
+
+/**
+ * This class defines an interface for an object that the user of Device
+ * can register as a delegate. The delegate object will be called by the
+ * Device when a new message or status update is received from the corresponding
+ * CHIP device.
+ */
+class DLL_EXPORT DeviceStatusDelegate
+{
+public:
+    virtual ~DeviceStatusDelegate() {}
+
+    /**
+     * @brief
+     *   Called when a message is received from the device.
+     *
+     * @param[in] msg Received message buffer.
+     */
+    virtual void OnMessage(System::PacketBuffer * msg) = 0;
+
+    /**
+     * @brief
+     *   Called when device status is updated.
+     *
+     */
+    virtual void OnStatusChange(void){};
+};
+
+typedef struct SerializableDevice
+{
+    SecurePairingSessionSerializable mOpsCreds;
+    uint64_t mDeviceId; /* This field is serialized in LittleEndian byte order */
+    uint8_t mDeviceAddr[INET6_ADDRSTRLEN];
+    uint16_t mDevicePort; /* This field is serealized in LittelEndian byte order */
+} SerializableDevice;
+
+typedef struct SerializedDevice
+{
+    // Extra uint64_t to account for padding bytes (NULL termination, and some decoding overheads)
+    // The encoder may not include a NULL character, and there are maximum 2 bytes of padding.
+    // So extra 8 bytes should be sufficient to absorb this overhead.
+    uint8_t inner[BASE64_ENCODED_LEN(sizeof(SerializableDevice) + sizeof(uint64_t))];
+} SerializedDevice;
+
+} // namespace Controller
+} // namespace chip
diff --git a/src/controller/CHIPDeviceController.cpp b/src/controller/CHIPDeviceController.cpp
index ab1471b..7ce20bd 100644
--- a/src/controller/CHIPDeviceController.cpp
+++ b/src/controller/CHIPDeviceController.cpp
@@ -46,6 +46,7 @@
 #include <support/CHIPMem.h>
 #include <support/CodeUtils.h>
 #include <support/ErrorStr.h>
+#include <support/SafeInt.h>
 #include <support/TimeUtils.h>
 #include <support/logging/CHIPLogging.h>
 
@@ -59,12 +60,12 @@
 using namespace chip::System;
 
 namespace chip {
-namespace DeviceController {
+namespace Controller {
 
 using namespace chip::Encoding;
 
-constexpr const char kDeviceCredentialsKeyPrefix[] = "DeviceCredentials";
-constexpr const char kDeviceAddressKeyPrefix[]     = "DeviceAddress";
+constexpr const char kPairedDeviceListKeyPrefix[] = "ListPairedDevices";
+constexpr const char kPairedDeviceKeyPrefix[]     = "PairedDevice";
 
 // This macro generates a key using node ID an key prefix, and performs the given action
 // on that key.
@@ -80,66 +81,41 @@
         action;                                                                                                                    \
     } while (0)
 
-ChipDeviceController::ChipDeviceController()
+DeviceController::DeviceController()
 {
-    mState             = kState_NotInitialized;
-    AppState           = nullptr;
-    mConState          = kConnectionState_NotConnected;
-    mRendezvousSession = nullptr;
-    mSessionManager    = nullptr;
-    mCurReqMsg         = nullptr;
-    mOnError           = nullptr;
-    mOnNewConnection   = nullptr;
-    mPairingDelegate   = nullptr;
-    mStorageDelegate   = nullptr;
-    mListenPort        = CHIP_PORT;
-    mDeviceAddr        = IPAddress::Any;
-    mDevicePort        = CHIP_PORT;
-    mInterface         = INET_NULL_INTERFACEID;
-    mLocalDeviceId     = 0;
-    mNumCachedPackets  = 0;
-    CHIP_ZERO_AT(mOnComplete);
-    CHIP_ZERO_AT(mCachedPackets);
+    mState                    = State::NotInitialized;
+    mSessionManager           = nullptr;
+    mLocalDeviceId            = 0;
+    mStorageDelegate          = nullptr;
+    mPairedDevicesInitialized = false;
 }
 
-ChipDeviceController::~ChipDeviceController()
+CHIP_ERROR DeviceController::Init(NodeId localDeviceId, PersistentStorageDelegate * storageDelegate, System::Layer * systemLayer,
+                                  Inet::InetLayer * inetLayer)
 {
-    if (mTestSecurePairingSecret != nullptr)
+    CHIP_ERROR err = CHIP_NO_ERROR;
+
+    VerifyOrExit(mState == State::NotInitialized, err = CHIP_ERROR_INCORRECT_STATE);
+
+    if (systemLayer != nullptr && inetLayer != nullptr)
     {
-        chip::Platform::Delete(mTestSecurePairingSecret);
+        mSystemLayer = systemLayer;
+        mInetLayer   = inetLayer;
     }
-}
-
-CHIP_ERROR ChipDeviceController::Init(NodeId localNodeId, DevicePairingDelegate * pairingDelegate,
-                                      PersistentStorageDelegate * storageDelegate)
-{
-    CHIP_ERROR err = CHIP_NO_ERROR;
-
-    VerifyOrExit(mState == kState_NotInitialized, err = CHIP_ERROR_INCORRECT_STATE);
-
+    else
+    {
 #if CONFIG_DEVICE_LAYER
-    err = DeviceLayer::PlatformMgr().InitChipStack();
-    SuccessOrExit(err);
+        err = DeviceLayer::PlatformMgr().InitChipStack();
+        SuccessOrExit(err);
 
-    err = Init(localNodeId, &DeviceLayer::SystemLayer, &DeviceLayer::InetLayer, pairingDelegate, storageDelegate);
+        mSystemLayer = &DeviceLayer::SystemLayer;
+        mInetLayer   = &DeviceLayer::InetLayer;
 #endif // CONFIG_DEVICE_LAYER
+    }
 
-exit:
-    return err;
-}
+    VerifyOrExit(mSystemLayer != nullptr, err = CHIP_ERROR_INVALID_ARGUMENT);
+    VerifyOrExit(mInetLayer != nullptr, err = CHIP_ERROR_INVALID_ARGUMENT);
 
-CHIP_ERROR ChipDeviceController::Init(NodeId localNodeId, System::Layer * systemLayer, InetLayer * inetLayer,
-                                      DevicePairingDelegate * pairingDelegate, PersistentStorageDelegate * storageDelegate)
-{
-    CHIP_ERROR err = CHIP_NO_ERROR;
-
-    VerifyOrExit(mState == kState_NotInitialized, err = CHIP_ERROR_INCORRECT_STATE);
-
-    mState           = kState_Initialized;
-    mLocalDeviceId   = localNodeId;
-    mSystemLayer     = systemLayer;
-    mInetLayer       = inetLayer;
-    mPairingDelegate = pairingDelegate;
     mStorageDelegate = storageDelegate;
 
     if (mStorageDelegate != nullptr)
@@ -147,19 +123,30 @@
         mStorageDelegate->SetDelegate(this);
     }
 
+    mSessionManager = chip::Platform::New<SecureSessionMgr<Transport::UDP>>();
+
+    err = mSessionManager->Init(localDeviceId, mSystemLayer,
+                                Transport::UdpListenParameters(mInetLayer).SetAddressType(Inet::kIPAddressType_IPv6));
+    SuccessOrExit(err);
+
+    mSessionManager->SetDelegate(this);
+
+    mState         = State::Initialized;
+    mLocalDeviceId = localDeviceId;
+
 exit:
     return err;
 }
 
-CHIP_ERROR ChipDeviceController::Shutdown()
+CHIP_ERROR DeviceController::Shutdown()
 {
     CHIP_ERROR err = CHIP_NO_ERROR;
 
+    VerifyOrExit(mState == State::Initialized, err = CHIP_ERROR_INCORRECT_STATE);
+
     ChipLogDetail(Controller, "Shutting down the controller");
 
-    VerifyOrExit(mState == kState_Initialized, err = CHIP_ERROR_INCORRECT_STATE);
-
-    mState = kState_NotInitialized;
+    mState = State::NotInitialized;
 
 #if CONFIG_DEVICE_LAYER
     err = DeviceLayer::PlatformMgr().Shutdown();
@@ -174,408 +161,128 @@
     mSystemLayer = nullptr;
     mInetLayer   = nullptr;
 
-    if (mSessionManager != nullptr)
-    {
-        chip::Platform::Delete(mSessionManager);
-        mSessionManager = nullptr;
-    }
-
-    if (mRendezvousSession != nullptr)
-    {
-        chip::Platform::Delete(mRendezvousSession);
-        mRendezvousSession = nullptr;
-    }
-
-    mConState = kConnectionState_NotConnected;
-    CHIP_ZERO_AT(mOnComplete);
-    mOnError         = nullptr;
-    mOnNewConnection = nullptr;
-    mRemoteDeviceId.ClearValue();
-
-exit:
-    return err;
-}
-
-CHIP_ERROR ChipDeviceController::ConnectDevice(NodeId remoteDeviceId, RendezvousParameters & params, void * appReqState,
-                                               NewConnectionHandler onConnected, MessageReceiveHandler onMessageReceived,
-                                               ErrorHandler onError, uint16_t devicePort, Inet::InterfaceId interfaceId)
-{
-    CHIP_ERROR err = CHIP_NO_ERROR;
-
-    VerifyOrExit(mState == kState_Initialized, err = CHIP_ERROR_INCORRECT_STATE);
-    VerifyOrExit(mConState == kConnectionState_NotConnected, err = CHIP_ERROR_INCORRECT_STATE);
-
-#if CONFIG_DEVICE_LAYER && CONFIG_NETWORK_LAYER_BLE
-    if (!params.HasBleLayer())
-    {
-        params.SetBleLayer(DeviceLayer::ConnectivityMgr().GetBleLayer());
-    }
-#endif // CONFIG_DEVICE_LAYER && CONFIG_NETWORK_LAYER_BLE
-
-    mRendezvousSession = chip::Platform::New<RendezvousSession>(this);
-    err                = mRendezvousSession->Init(params.SetLocalNodeId(mLocalDeviceId));
-    SuccessOrExit(err);
-
-    mRemoteDeviceId  = Optional<NodeId>::Value(remoteDeviceId);
-    mDevicePort      = devicePort;
-    mInterface       = interfaceId;
-    mAppReqState     = appReqState;
-    mOnNewConnection = onConnected;
-
-    // connected state before 'OnConnect'
-    mConState = kConnectionState_Connected;
-
-    mOnComplete.Response = onMessageReceived;
-    mOnError             = onError;
-
-exit:
-    if (err != CHIP_NO_ERROR && mRendezvousSession != nullptr)
-    {
-        chip::Platform::Delete(mRendezvousSession);
-        mRendezvousSession = nullptr;
-    }
-
-    return err;
-}
-
-CHIP_ERROR ChipDeviceController::ConnectDeviceWithoutSecurePairing(NodeId remoteDeviceId, const IPAddress & deviceAddr,
-                                                                   void * appReqState, NewConnectionHandler onConnected,
-                                                                   MessageReceiveHandler onMessageReceived, ErrorHandler onError,
-                                                                   uint16_t devicePort, Inet::InterfaceId interfaceId)
-{
-    if (mTestSecurePairingSecret != nullptr)
-    {
-        chip::Platform::Delete(mTestSecurePairingSecret);
-    }
-
-    mTestSecurePairingSecret = chip::Platform::New<SecurePairingUsingTestSecret>(
-        Optional<NodeId>::Value(remoteDeviceId), static_cast<uint16_t>(0), static_cast<uint16_t>(0));
-
-    mSecurePairingSession = mTestSecurePairingSecret;
-
-    mDeviceAddr      = deviceAddr;
-    mRemoteDeviceId  = Optional<NodeId>::Value(remoteDeviceId);
-    mDevicePort      = devicePort;
-    mInterface       = interfaceId;
-    mAppReqState     = appReqState;
-    mOnNewConnection = onConnected;
-
-    mConState = kConnectionState_Connected;
-
-    mOnComplete.Response = onMessageReceived;
-    mOnError             = onError;
-
-    if (mOnNewConnection)
-    {
-        mOnNewConnection(this, nullptr, mAppReqState);
-    }
-
-    return CHIP_NO_ERROR;
-}
-
-CHIP_ERROR ChipDeviceController::SetUdpListenPort(uint16_t listenPort)
-{
-    if (mState != kState_Initialized || mConState != kConnectionState_NotConnected)
-        return CHIP_ERROR_INCORRECT_STATE;
-    mListenPort = listenPort;
-    return CHIP_NO_ERROR;
-}
-
-CHIP_ERROR ChipDeviceController::EstablishSecureSession()
-{
-    CHIP_ERROR err = CHIP_NO_ERROR;
-
-    VerifyOrExit(mSecurePairingSession != nullptr, err = CHIP_ERROR_INCORRECT_STATE);
-
-    mSessionManager = chip::Platform::New<SecureSessionMgr<Transport::UDP>>();
-
-    err = mSessionManager->Init(
-        mLocalDeviceId, mSystemLayer,
-        Transport::UdpListenParameters(mInetLayer).SetAddressType(mDeviceAddr.Type()).SetListenPort(mListenPort));
-    SuccessOrExit(err);
-
-    mSessionManager->SetDelegate(this);
-
-    err = mSessionManager->NewPairing(
-        Optional<Transport::PeerAddress>::Value(Transport::PeerAddress::UDP(mDeviceAddr, mDevicePort, mInterface)),
-        mSecurePairingSession);
-    SuccessOrExit(err);
-
-    mConState = kConnectionState_SecureConnected;
-
-    if (mDeviceAddr != IPAddress::Any)
-    {
-        SendCachedPackets();
-    } // else wait for mdns discovery
-
-exit:
-
-    if (err != CHIP_NO_ERROR)
-    {
-        if (mSessionManager != nullptr)
-        {
-            chip::Platform::Delete(mSessionManager);
-            mSessionManager = nullptr;
-        }
-        mConState = kConnectionState_NotConnected;
-    }
-
-    return err;
-}
-
-void ChipDeviceController::OnValue(const char * key, const char * value)
-{
-    CHIP_ERROR err = CHIP_NO_ERROR;
-    NodeId peer    = mRemoteDeviceId.Value();
-
-    VerifyOrExit(key != nullptr, err = CHIP_ERROR_INVALID_ARGUMENT);
-
-    PERSISTENT_KEY_OP(
-        peer, kDeviceCredentialsKeyPrefix, expectedKey, if (strcmp(key, expectedKey) == 0) {
-            SecurePairingSessionSerialized serialized;
-            size_t length = 0;
-
-            VerifyOrExit(value != nullptr, err = CHIP_ERROR_INVALID_ARGUMENT);
-            length = strlen(value) + 1; // account for the null termination
-            VerifyOrExit(length <= sizeof(serialized.inner), err = CHIP_ERROR_INVALID_ARGUMENT);
-            memmove(serialized.inner, value, length);
-            SuccessOrExit(mPairingSession.Deserialize(serialized));
-
-            mSecurePairingSession = &mPairingSession;
-        });
-
-    PERSISTENT_KEY_OP(
-        peer, kDeviceAddressKeyPrefix, expectedKey, if (strcmp(key, expectedKey) == 0) {
-            VerifyOrExit(value != nullptr, err = CHIP_ERROR_INVALID_ARGUMENT);
-            VerifyOrExit(IPAddress::FromString(value, mDeviceAddr), err = CHIP_ERROR_INVALID_ADDRESS);
-        });
-
-    if (mSecurePairingSession != nullptr && mDeviceAddr != IPAddress::Any)
-    {
-        SuccessOrExit(EstablishSecureSession());
-    }
-
-exit:
-    if (err != CHIP_NO_ERROR)
-    {
-        mConState = kConnectionState_NotConnected;
-        DiscardCachedPackets();
-    }
-}
-
-void ChipDeviceController::OnStatus(const char * key, Operation op, CHIP_ERROR err) {}
-
-CHIP_ERROR ChipDeviceController::TryEstablishingSecureSession(NodeId peer)
-{
-    CHIP_ERROR err = CHIP_NO_ERROR;
-
-    if (mState != kState_Initialized || mSessionManager != nullptr || mConState == kConnectionState_SecureConnected)
-    {
-        ExitNow(err = CHIP_ERROR_INCORRECT_STATE);
-    }
-
     if (mStorageDelegate != nullptr)
     {
-        mSecurePairingSession = nullptr;
-        mDeviceAddr           = IPAddress::Any;
-        PERSISTENT_KEY_OP(peer, kDeviceCredentialsKeyPrefix, key, mStorageDelegate->GetKeyValue(key));
-        PERSISTENT_KEY_OP(peer, kDeviceAddressKeyPrefix, key, mStorageDelegate->GetKeyValue(key));
-        mConState = kConnectionState_SecureConnecting;
-    }
-    else
-    {
-        ExitNow(err = EstablishSecureSession());
-    }
-
-exit:
-
-    if (err != CHIP_NO_ERROR)
-    {
-        DiscardCachedPackets();
-    }
-    return err;
-}
-
-CHIP_ERROR ChipDeviceController::ResumeSecureSession(NodeId peer)
-{
-    if (mConState == kConnectionState_SecureConnected)
-    {
-        mConState = kConnectionState_Connected;
+        mStorageDelegate->SetDelegate(nullptr);
+        mStorageDelegate = nullptr;
     }
 
     if (mSessionManager != nullptr)
     {
+        mSessionManager->SetDelegate(nullptr);
         chip::Platform::Delete(mSessionManager);
         mSessionManager = nullptr;
     }
 
-    CHIP_ERROR err = TryEstablishingSecureSession(peer);
-    SuccessOrExit(err);
-
-exit:
-
-    if (err != CHIP_NO_ERROR)
-    {
-        ChipLogError(Controller, "ResumeSecureSession returning error %d\n", err);
-    }
-    return err;
-}
-
-bool ChipDeviceController::IsConnected() const
-{
-    return mState == kState_Initialized &&
-        (mConState == kConnectionState_Connected || mConState == kConnectionState_SecureConnected);
-}
-
-bool ChipDeviceController::IsSecurelyConnected() const
-{
-    return mState == kState_Initialized && mConState == kConnectionState_SecureConnected;
-}
-
-bool ChipDeviceController::GetIpAddress(Inet::IPAddress & addr) const
-{
-    if (IsConnected())
-        addr = mDeviceAddr;
-    return IsConnected();
-}
-
-CHIP_ERROR ChipDeviceController::DisconnectDevice()
-{
-    CHIP_ERROR err = CHIP_NO_ERROR;
-
-    if (!IsConnected())
-    {
-        return CHIP_ERROR_INCORRECT_STATE;
-    }
-
-    if (mSessionManager != nullptr)
-    {
-        chip::Platform::Delete(mSessionManager);
-        mSessionManager = nullptr;
-    }
-
-    if (mRendezvousSession != nullptr)
-    {
-        chip::Platform::Delete(mRendezvousSession);
-        mRendezvousSession = nullptr;
-    }
-
-    mConState = kConnectionState_NotConnected;
-    return err;
-}
-
-CHIP_ERROR ChipDeviceController::CachePacket(System::PacketBuffer * buffer)
-{
-    CHIP_ERROR err = CHIP_NO_ERROR;
-
-    VerifyOrExit(mNumCachedPackets < kPacketCacheMaxSize, err = CHIP_ERROR_INTERNAL);
-    mCachedPackets[mNumCachedPackets++] = buffer;
-
 exit:
     return err;
 }
 
-CHIP_ERROR ChipDeviceController::SendCachedPackets()
+CHIP_ERROR DeviceController::GetDevice(NodeId deviceId, const SerializedDevice & deviceInfo, Device ** out_device)
 {
-    CHIP_ERROR err = CHIP_NO_ERROR;
+    CHIP_ERROR err  = CHIP_NO_ERROR;
+    Device * device = nullptr;
+    uint16_t index  = 0;
 
-    VerifyOrExit(IsSecurelyConnected(), err = CHIP_ERROR_INCORRECT_STATE);
+    VerifyOrExit(out_device != nullptr, err = CHIP_ERROR_INVALID_ARGUMENT);
+    index = FindDeviceIndex(deviceId);
 
-    for (uint16_t i = 0; i < mNumCachedPackets; i++)
+    if (index < kNumMaxActiveDevices)
     {
-        err = mSessionManager->SendMessage(mRemoteDeviceId.Value(), mCachedPackets[i]);
-        ChipLogDetail(Controller, "SendMessage returned %d", err);
-    }
-
-    mNumCachedPackets = 0;
-    CHIP_ZERO_AT(mCachedPackets);
-
-exit:
-    return err;
-}
-
-void ChipDeviceController::DiscardCachedPackets()
-{
-    for (uint16_t i = 0; i < mNumCachedPackets; i++)
-    {
-        PacketBuffer::Free(mCachedPackets[i]);
-    }
-
-    mNumCachedPackets = 0;
-    CHIP_ZERO_AT(mCachedPackets);
-}
-
-CHIP_ERROR ChipDeviceController::SendMessage(void * appReqState, PacketBuffer * buffer, NodeId peerDevice)
-{
-    CHIP_ERROR err            = CHIP_NO_ERROR;
-    bool trySessionResumption = true;
-
-    VerifyOrExit(buffer != nullptr, err = CHIP_ERROR_INVALID_ARGUMENT);
-    VerifyOrExit(mState == kState_Initialized, err = CHIP_ERROR_INCORRECT_STATE);
-
-    mAppReqState = appReqState;
-
-    if (peerDevice != kUndefinedNodeId)
-    {
-        mRemoteDeviceId = Optional<NodeId>::Value(peerDevice);
-    }
-    VerifyOrExit(mRemoteDeviceId.HasValue(), err = CHIP_ERROR_INCORRECT_STATE);
-
-    // If there is no secure connection to the device, try establishing it
-    if (!IsSecurelyConnected())
-    {
-        err = TryEstablishingSecureSession(mRemoteDeviceId.Value());
-        SuccessOrExit(err);
-
-        trySessionResumption = false;
-
-        if (mDeviceAddr == IPAddress::Any || mConState == kConnectionState_SecureConnecting)
-        {
-            // Cache the packet while connection is being established
-            ExitNow(err = CachePacket(buffer));
-        }
-    }
-
-    // Hold on to the buffer, in case of session resumption and resend is needed
-    buffer->AddRef();
-
-    err = mSessionManager->SendMessage(mRemoteDeviceId.Value(), buffer);
-    ChipLogDetail(Controller, "SendMessage returned %d", err);
-
-    // The send could fail due to network timeouts (e.g. broken pipe)
-    // Try sesion resumption if needed
-    if (err != CHIP_NO_ERROR && trySessionResumption)
-    {
-        err = ResumeSecureSession(mRemoteDeviceId.Value());
-        // If session resumption failed, let's free the extra reference to
-        // the buffer. If not, SendMessage would free it.
-        VerifyOrExit(err == CHIP_NO_ERROR, PacketBuffer::Free(buffer));
-
-        if (mConState == kConnectionState_SecureConnecting)
-        {
-            // Cache the packet while connection is being established
-            ExitNow(err = CachePacket(buffer));
-        }
-
-        err = mSessionManager->SendMessage(mRemoteDeviceId.Value(), buffer);
-        SuccessOrExit(err);
+        device = &mActiveDevices[index];
     }
     else
     {
-        // Free the extra reference to the buffer
-        PacketBuffer::Free(buffer);
+        VerifyOrExit(mPairedDevices.Contains(deviceId), err = CHIP_ERROR_NOT_CONNECTED);
+
+        index = GetInactiveDeviceIndex();
+        VerifyOrExit(index < kNumMaxActiveDevices, err = CHIP_ERROR_NO_MEMORY);
+        device = &mActiveDevices[index];
+
+        err = device->Deserialize(deviceInfo);
+        VerifyOrExit(err == CHIP_NO_ERROR, ReleaseDevice(device));
+
+        device->Init(mSessionManager, mInetLayer);
     }
 
-exit:
+    *out_device = device;
 
+exit:
     return err;
 }
 
-CHIP_ERROR ChipDeviceController::ServiceEvents()
+CHIP_ERROR DeviceController::GetDevice(NodeId deviceId, Device ** out_device)
+{
+    CHIP_ERROR err  = CHIP_NO_ERROR;
+    Device * device = nullptr;
+    uint16_t index  = 0;
+    char * buffer   = nullptr;
+
+    VerifyOrExit(out_device != nullptr, err = CHIP_ERROR_INVALID_ARGUMENT);
+    index = FindDeviceIndex(deviceId);
+
+    if (index < kNumMaxActiveDevices)
+    {
+        device = &mActiveDevices[index];
+    }
+    else
+    {
+        VerifyOrExit(mStorageDelegate != nullptr, err = CHIP_ERROR_INCORRECT_STATE);
+
+        if (!mPairedDevicesInitialized)
+        {
+            constexpr uint16_t max_size = CHIP_MAX_SERIALIZED_SIZE_U64(kNumMaxPairedDevices);
+            buffer                      = static_cast<char *>(chip::Platform::MemoryAlloc(max_size));
+            uint16_t size               = max_size;
+
+            VerifyOrExit(buffer != nullptr, err = CHIP_ERROR_INVALID_ARGUMENT);
+
+            PERSISTENT_KEY_OP(static_cast<uint64_t>(0), kPairedDeviceListKeyPrefix, key,
+                              err = mStorageDelegate->GetKeyValue(key, buffer, size));
+            SuccessOrExit(err);
+            VerifyOrExit(size <= max_size, err = CHIP_ERROR_INVALID_DEVICE_DESCRIPTOR);
+
+            err = SetPairedDeviceList(buffer);
+            SuccessOrExit(err);
+        }
+
+        VerifyOrExit(mPairedDevices.Contains(deviceId), err = CHIP_ERROR_NOT_CONNECTED);
+
+        index = GetInactiveDeviceIndex();
+        VerifyOrExit(index < kNumMaxActiveDevices, err = CHIP_ERROR_NO_MEMORY);
+        device = &mActiveDevices[index];
+
+        {
+            SerializedDevice deviceInfo;
+            uint16_t size = sizeof(deviceInfo.inner);
+
+            PERSISTENT_KEY_OP(deviceId, kPairedDeviceKeyPrefix, key,
+                              err = mStorageDelegate->GetKeyValue(key, Uint8::to_char(deviceInfo.inner), size));
+            SuccessOrExit(err);
+            VerifyOrExit(size <= sizeof(deviceInfo.inner), err = CHIP_ERROR_INVALID_DEVICE_DESCRIPTOR);
+
+            err = device->Deserialize(deviceInfo);
+            VerifyOrExit(err == CHIP_NO_ERROR, ReleaseDevice(device));
+
+            device->Init(mSessionManager, mInetLayer);
+        }
+    }
+
+    *out_device = device;
+
+exit:
+    if (buffer != nullptr)
+    {
+        chip::Platform::MemoryFree(buffer);
+    }
+    return err;
+}
+
+CHIP_ERROR DeviceController::ServiceEvents()
 {
     CHIP_ERROR err = CHIP_NO_ERROR;
 
-    VerifyOrExit(mState == kState_Initialized, err = CHIP_ERROR_INCORRECT_STATE);
+    VerifyOrExit(mState == State::Initialized, err = CHIP_ERROR_INCORRECT_STATE);
 
 #if CONFIG_DEVICE_LAYER
     err = DeviceLayer::PlatformMgr().StartEventLoopTask();
@@ -586,11 +293,11 @@
     return err;
 }
 
-CHIP_ERROR ChipDeviceController::ServiceEventSignal()
+CHIP_ERROR DeviceController::ServiceEventSignal()
 {
     CHIP_ERROR err = CHIP_NO_ERROR;
 
-    VerifyOrExit(mState == kState_Initialized, err = CHIP_ERROR_INCORRECT_STATE);
+    VerifyOrExit(mState == State::Initialized, err = CHIP_ERROR_INCORRECT_STATE);
 
 #if CONFIG_DEVICE_LAYER && (CHIP_SYSTEM_CONFIG_USE_SOCKETS || CHIP_SYSTEM_CONFIG_USE_NETWORK_FRAMEWORK)
     DeviceLayer::SystemLayer.WakeSelect();
@@ -602,54 +309,274 @@
     return err;
 }
 
-CHIP_ERROR ChipDeviceController::SetDevicePairingDelegate(DevicePairingDelegate * pairingDelegate)
+void DeviceController::OnNewConnection(Transport::PeerConnectionState * peerConnection, SecureSessionMgrBase * mgr) {}
+
+void DeviceController::OnMessageReceived(const PacketHeader & header, const PayloadHeader & payloadHeader,
+                                         Transport::PeerConnectionState * state, System::PacketBuffer * msgBuf,
+                                         SecureSessionMgrBase * mgr)
 {
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    uint16_t index = 0;
+    NodeId peer;
+
+    VerifyOrExit(mState == State::Initialized, err = CHIP_ERROR_INCORRECT_STATE);
+    VerifyOrExit(header.GetSourceNodeId().HasValue(), err = CHIP_ERROR_INVALID_ARGUMENT);
+
+    peer  = header.GetSourceNodeId().Value();
+    index = FindDeviceIndex(peer);
+    VerifyOrExit(index < kNumMaxActiveDevices, err = CHIP_ERROR_INVALID_DEVICE_DESCRIPTOR);
+
+    mActiveDevices[index].OnMessageReceived(header, payloadHeader, state, msgBuf, mgr);
+
+exit:
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogError(Controller, "Failed to process received message: err %d", err);
+    }
+    return;
+}
+
+uint16_t DeviceController::GetInactiveDeviceIndex()
+{
+    uint16_t i = 0;
+    while (i < kNumMaxActiveDevices && mActiveDevices[i].IsActive())
+        i++;
+    if (i < kNumMaxActiveDevices)
+    {
+        mActiveDevices[i].SetActive(true);
+    }
+
+    return i;
+}
+
+void DeviceController::ReleaseDevice(Device * device)
+{
+    device->SetActive(false);
+}
+
+void DeviceController::ReleaseDevice(uint16_t index)
+{
+    if (index < kNumMaxActiveDevices)
+    {
+        ReleaseDevice(&mActiveDevices[index]);
+    }
+}
+
+uint16_t DeviceController::FindDeviceIndex(NodeId id)
+{
+    uint16_t i = 0;
+    while (i < kNumMaxActiveDevices)
+    {
+        if (mActiveDevices[i].IsActive() && mActiveDevices[i].GetDeviceId() == id)
+        {
+            return i;
+        }
+        i++;
+    }
+    return i;
+}
+
+CHIP_ERROR DeviceController::SetPairedDeviceList(const char * serialized)
+{
+    CHIP_ERROR err  = CHIP_NO_ERROR;
+    size_t len      = strlen(serialized) + 1;
+    uint16_t lenU16 = static_cast<uint16_t>(len);
+    VerifyOrExit(CanCastTo<uint16_t>(len), err = CHIP_ERROR_INVALID_ARGUMENT);
+    err = mPairedDevices.DeserializeBase64(serialized, lenU16);
+
+exit:
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogError(Controller, "Failed to recreate the device list\n");
+    }
+    else
+    {
+        mPairedDevicesInitialized = true;
+    }
+
+    return err;
+}
+
+void DeviceController::OnValue(const char * key, const char * value) {}
+
+void DeviceController::OnStatus(const char * key, Operation op, CHIP_ERROR err) {}
+
+DeviceCommissioner::DeviceCommissioner()
+{
+    mPairingDelegate      = nullptr;
+    mRendezvousSession    = nullptr;
+    mDeviceBeingPaired    = kNumMaxActiveDevices;
+    mPairedDevicesUpdated = false;
+}
+
+CHIP_ERROR DeviceCommissioner::Init(NodeId localDeviceId, PersistentStorageDelegate * storageDelegate,
+                                    DevicePairingDelegate * pairingDelegate, System::Layer * systemLayer,
+                                    Inet::InetLayer * inetLayer)
+{
+    CHIP_ERROR err = DeviceController::Init(localDeviceId, storageDelegate, systemLayer, inetLayer);
+    SuccessOrExit(err);
+
     mPairingDelegate = pairingDelegate;
+
+exit:
+    return err;
+}
+
+CHIP_ERROR DeviceCommissioner::Shutdown()
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+
+    VerifyOrExit(mState == State::Initialized, err = CHIP_ERROR_INCORRECT_STATE);
+
+    ChipLogDetail(Controller, "Shutting down the commissioner");
+
+    PersistDeviceList();
+
+    if (mRendezvousSession != nullptr)
+    {
+        chip::Platform::Delete(mRendezvousSession);
+        mRendezvousSession = nullptr;
+    }
+
+    DeviceController::Shutdown();
+
+exit:
+    return err;
+}
+
+CHIP_ERROR DeviceCommissioner::PairDevice(NodeId remoteDeviceId, RendezvousParameters & params, uint16_t remotePort,
+                                          Inet::InterfaceId interfaceId)
+{
+    CHIP_ERROR err  = CHIP_NO_ERROR;
+    Device * device = nullptr;
+
+    VerifyOrExit(mState == State::Initialized, err = CHIP_ERROR_INCORRECT_STATE);
+    VerifyOrExit(mDeviceBeingPaired == kNumMaxActiveDevices, err = CHIP_ERROR_INCORRECT_STATE);
+    VerifyOrExit(mStorageDelegate != nullptr, err = CHIP_ERROR_INCORRECT_STATE);
+
+#if CONFIG_DEVICE_LAYER && CONFIG_NETWORK_LAYER_BLE
+    if (!params.HasBleLayer())
+    {
+        params.SetBleLayer(DeviceLayer::ConnectivityMgr().GetBleLayer());
+    }
+#endif // CONFIG_DEVICE_LAYER && CONFIG_NETWORK_LAYER_BLE
+
+    mDeviceBeingPaired = GetInactiveDeviceIndex();
+    VerifyOrExit(mDeviceBeingPaired < kNumMaxActiveDevices, err = CHIP_ERROR_NO_MEMORY);
+    device = &mActiveDevices[mDeviceBeingPaired];
+
+    mRendezvousSession = chip::Platform::New<RendezvousSession>(this);
+    VerifyOrExit(mRendezvousSession != nullptr, err = CHIP_ERROR_NO_MEMORY);
+    err = mRendezvousSession->Init(params.SetLocalNodeId(mLocalDeviceId));
+    SuccessOrExit(err);
+
+    device->Init(mSessionManager, mInetLayer, remoteDeviceId, remotePort, interfaceId);
+
+exit:
+    if (err != CHIP_NO_ERROR)
+    {
+        if (mRendezvousSession != nullptr)
+        {
+            chip::Platform::Delete(mRendezvousSession);
+            mRendezvousSession = nullptr;
+        }
+
+        if (device != nullptr)
+        {
+            ReleaseDevice(device);
+            mDeviceBeingPaired = kNumMaxActiveDevices;
+        }
+    }
+
+    return err;
+}
+
+CHIP_ERROR DeviceCommissioner::PairTestDeviceWithoutSecurity(NodeId remoteDeviceId, const Inet::IPAddress & deviceAddr,
+                                                             SerializedDevice & serialized, uint16_t remotePort,
+                                                             Inet::InterfaceId interfaceId)
+{
+    CHIP_ERROR err  = CHIP_NO_ERROR;
+    Device * device = nullptr;
+
+    SecurePairingUsingTestSecret * testSecurePairingSecret = nullptr;
+
+    VerifyOrExit(mState == State::Initialized, err = CHIP_ERROR_INCORRECT_STATE);
+    VerifyOrExit(mDeviceBeingPaired == kNumMaxActiveDevices, err = CHIP_ERROR_INCORRECT_STATE);
+
+    testSecurePairingSecret = chip::Platform::New<SecurePairingUsingTestSecret>(Optional<NodeId>::Value(remoteDeviceId),
+                                                                                static_cast<uint16_t>(0), static_cast<uint16_t>(0));
+    VerifyOrExit(testSecurePairingSecret != nullptr, err = CHIP_ERROR_NO_MEMORY);
+
+    mDeviceBeingPaired = GetInactiveDeviceIndex();
+    VerifyOrExit(mDeviceBeingPaired < kNumMaxActiveDevices, err = CHIP_ERROR_NO_MEMORY);
+    device = &mActiveDevices[mDeviceBeingPaired];
+
+    testSecurePairingSecret->ToSerializable(device->GetPairing());
+
+    device->Init(mSessionManager, mInetLayer, remoteDeviceId, remotePort, interfaceId);
+
+    device->SetAddress(deviceAddr);
+
+    device->Serialize(serialized);
+
+    OnRendezvousComplete();
+
+exit:
+    if (testSecurePairingSecret != nullptr)
+    {
+        chip::Platform::Delete(testSecurePairingSecret);
+    }
+
+    if (err != CHIP_NO_ERROR)
+    {
+        if (device != nullptr)
+        {
+            ReleaseDevice(device);
+            mDeviceBeingPaired = kNumMaxActiveDevices;
+        }
+    }
+
+    return err;
+}
+CHIP_ERROR DeviceCommissioner::StopPairing(NodeId remoteDeviceId)
+{
+    CHIP_ERROR err  = CHIP_NO_ERROR;
+    Device * device = nullptr;
+
+    VerifyOrExit(mState == State::Initialized, err = CHIP_ERROR_INCORRECT_STATE);
+    VerifyOrExit(mDeviceBeingPaired < kNumMaxActiveDevices, err = CHIP_ERROR_INCORRECT_STATE);
+
+    device = &mActiveDevices[mDeviceBeingPaired];
+    VerifyOrExit(device->GetDeviceId() == remoteDeviceId, err = CHIP_ERROR_INVALID_DEVICE_DESCRIPTOR);
+
+    if (mRendezvousSession != nullptr)
+    {
+        chip::Platform::Delete(mRendezvousSession);
+        mRendezvousSession = nullptr;
+    }
+
+    ReleaseDevice(device);
+    mDeviceBeingPaired = kNumMaxActiveDevices;
+
+exit:
+    return err;
+}
+
+CHIP_ERROR DeviceCommissioner::UnpairDevice(NodeId remoteDeviceId)
+{
+    // TODO: Send unpairing message to the remote device.
+
+    if (mStorageDelegate != nullptr)
+    {
+        PERSISTENT_KEY_OP(remoteDeviceId, kPairedDeviceKeyPrefix, key, mStorageDelegate->DeleteKeyValue(key));
+        mPairedDevices.Remove(remoteDeviceId);
+        mPairedDevicesUpdated = true;
+    }
+
     return CHIP_NO_ERROR;
 }
 
-void ChipDeviceController::ClearRequestState()
-{
-    if (mCurReqMsg != nullptr)
-    {
-        PacketBuffer::Free(mCurReqMsg);
-        mCurReqMsg = nullptr;
-    }
-}
-
-void ChipDeviceController::OnNewConnection(Transport::PeerConnectionState * state, SecureSessionMgrBase * mgr) {}
-
-void ChipDeviceController::OnAddressResolved(CHIP_ERROR error, NodeId nodeId, SecureSessionMgrBase * mgr)
-{
-    if (error == CHIP_NO_ERROR && nodeId == mSecurePairingSession->GetPeerNodeId() && mDeviceAddr == IPAddress::Any)
-    {
-        SendCachedPackets();
-    }
-}
-
-void ChipDeviceController::OnMessageReceived(const PacketHeader & header, const PayloadHeader & payloadHeader,
-                                             Transport::PeerConnectionState * state, System::PacketBuffer * msgBuf,
-                                             SecureSessionMgrBase * mgr)
-{
-    if (header.GetSourceNodeId().HasValue())
-    {
-        if (!mRemoteDeviceId.HasValue())
-        {
-            ChipLogDetail(Controller, "Learned remote device id");
-            mRemoteDeviceId = header.GetSourceNodeId();
-        }
-        else if (mRemoteDeviceId != header.GetSourceNodeId())
-        {
-            ChipLogError(Controller, "Received message from an unexpected source node id.");
-        }
-    }
-    if (IsSecurelyConnected() && mOnComplete.Response != nullptr)
-    {
-        mOnComplete.Response(this, mAppReqState, msgBuf);
-    }
-}
-
-void ChipDeviceController::OnRendezvousError(CHIP_ERROR err)
+void DeviceCommissioner::RendezvousCleanup(CHIP_ERROR status)
 {
     if (mRendezvousSession != nullptr)
     {
@@ -659,74 +586,130 @@
 
     if (mPairingDelegate != nullptr)
     {
-        mPairingDelegate->OnPairingComplete(err);
+        mPairingDelegate->OnPairingComplete(status);
     }
-}
 
-void ChipDeviceController::OnRendezvousComplete()
-{
-    OnRendezvousError(CHIP_NO_ERROR);
-}
-
-void ChipDeviceController::OnRendezvousStatusUpdate(RendezvousSessionDelegate::Status status, CHIP_ERROR err)
-{
-    if (mOnError != nullptr && err != CHIP_NO_ERROR)
+    if (mDeviceBeingPaired != kNumMaxActiveDevices)
     {
-        mOnError(this, mAppReqState, err, nullptr);
+        // Let's release the device that's being paired.
+        // If pairing was successful, its information is
+        // already persisted. The application will use GetDevice()
+        // method to get access to the device, which will fetch
+        // the device information from the persistent storage.
+        DeviceController::ReleaseDevice(mDeviceBeingPaired);
+        mDeviceBeingPaired = kNumMaxActiveDevices;
+    }
+}
+
+void DeviceCommissioner::OnRendezvousError(CHIP_ERROR err)
+{
+    RendezvousCleanup(err);
+}
+
+void DeviceCommissioner::OnRendezvousComplete()
+{
+    CHIP_ERROR err  = CHIP_NO_ERROR;
+    Device * device = nullptr;
+
+    VerifyOrExit(mDeviceBeingPaired < kNumMaxActiveDevices, err = CHIP_ERROR_INVALID_DEVICE_DESCRIPTOR);
+    device = &mActiveDevices[mDeviceBeingPaired];
+    mPairedDevices.Insert(device->GetDeviceId());
+    mPairedDevicesUpdated = true;
+
+    // mStorageDelegate would not be null for a typical pairing scenario, as Pair()
+    // requires a valid storage delegate. However, test pairing usecase, that's used
+    // mainly by test applications, do not require a storage delegate. This is to
+    // reduce overheads on these tests.
+    // Let's make sure the delegate object is available before calling into it.
+    if (mStorageDelegate != nullptr)
+    {
+        SerializedDevice serialized;
+        device->Serialize(serialized);
+        PERSISTENT_KEY_OP(device->GetDeviceId(), kPairedDeviceKeyPrefix, key,
+                          mStorageDelegate->SetKeyValue(key, Uint8::to_const_char(serialized.inner)));
     }
 
+exit:
+    if (err == CHIP_NO_ERROR)
+    {
+        RendezvousCleanup(CHIP_NO_ERROR);
+    }
+    else
+    {
+        OnRendezvousError(err);
+    }
+}
+
+void DeviceCommissioner::OnRendezvousStatusUpdate(RendezvousSessionDelegate::Status status, CHIP_ERROR err)
+{
+    Device * device = nullptr;
+    if (mDeviceBeingPaired >= kNumMaxActiveDevices)
+    {
+        ExitNow();
+    }
+
+    device = &mActiveDevices[mDeviceBeingPaired];
     switch (status)
     {
     case RendezvousSessionDelegate::SecurePairingSuccess:
-        ChipLogProgress(Controller, "Remote device completed SPAKE2+ handshake\n");
-        mPairingSession       = mRendezvousSession->GetPairingSession();
-        mSecurePairingSession = &mPairingSession;
-
-        if (mOnNewConnection)
-        {
-            ChipLogProgress(Controller, "Will Call on mOnNewConnection(%p)\n", mOnNewConnection);
-            mOnNewConnection(this, nullptr, mAppReqState);
-        }
+        ChipLogDetail(Controller, "Remote device completed SPAKE2+ handshake\n");
+        mRendezvousSession->GetPairingSession().ToSerializable(device->GetPairing());
 
         if (mPairingDelegate != nullptr)
         {
             mPairingDelegate->OnNetworkCredentialsRequested(mRendezvousSession);
         }
+        break;
 
-        if (mStorageDelegate != nullptr)
-        {
-            SecurePairingSessionSerialized serialized;
-            CHIP_ERROR err = mSecurePairingSession->Serialize(serialized);
-            if (err == CHIP_NO_ERROR)
-            {
-                PERSISTENT_KEY_OP(mSecurePairingSession->GetPeerNodeId(), kDeviceCredentialsKeyPrefix, key,
-                                  mStorageDelegate->SetKeyValue(key, Uint8::to_const_char(serialized.inner)));
-            }
-        }
+    case RendezvousSessionDelegate::SecurePairingFailed:
+        ChipLogDetail(Controller, "Remote device failed in SPAKE2+ handshake\n");
         break;
 
     case RendezvousSessionDelegate::NetworkProvisioningSuccess:
-
         ChipLogDetail(Controller, "Remote device was assigned an ip address\n");
-        mDeviceAddr = mRendezvousSession->GetIPAddress();
-        if (mStorageDelegate != nullptr)
-        {
-            char addrStr[INET6_ADDRSTRLEN];
-            mDeviceAddr.ToString(addrStr, INET6_ADDRSTRLEN);
-            PERSISTENT_KEY_OP(mRendezvousSession->GetPairingSession().GetPeerNodeId(), kDeviceAddressKeyPrefix, key,
-                              mStorageDelegate->SetKeyValue(key, addrStr));
-        }
+        device->SetAddress(mRendezvousSession->GetIPAddress());
+        break;
+
+    case RendezvousSessionDelegate::NetworkProvisioningFailed:
+        ChipLogDetail(Controller, "Remote device failed in network provisioning\n");
         break;
 
     default:
         break;
     };
-
+exit:
     if (mPairingDelegate != nullptr)
     {
         mPairingDelegate->OnStatusUpdate(status);
     }
 }
 
-} // namespace DeviceController
+void DeviceCommissioner::PersistDeviceList()
+{
+    if (mStorageDelegate != nullptr && mPairedDevicesUpdated)
+    {
+        constexpr uint16_t size = CHIP_MAX_SERIALIZED_SIZE_U64(kNumMaxPairedDevices);
+        char * serialized       = static_cast<char *>(chip::Platform::MemoryAlloc(size));
+        uint16_t requiredSize   = size;
+        if (serialized != nullptr)
+        {
+            const char * value = mPairedDevices.SerializeBase64(serialized, requiredSize);
+            if (value != nullptr && requiredSize <= size)
+            {
+                PERSISTENT_KEY_OP(static_cast<uint64_t>(0), kPairedDeviceListKeyPrefix, key,
+                                  mStorageDelegate->SetKeyValue(key, value));
+                mPairedDevicesUpdated = false;
+            }
+            chip::Platform::MemoryFree(serialized);
+        }
+    }
+}
+
+void DeviceCommissioner::ReleaseDevice(Device * device)
+{
+    PersistDeviceList();
+    DeviceController::ReleaseDevice(device);
+}
+
+} // namespace Controller
 } // namespace chip
diff --git a/src/controller/CHIPDeviceController.h b/src/controller/CHIPDeviceController.h
index a115288..1e7ec69 100644
--- a/src/controller/CHIPDeviceController.h
+++ b/src/controller/CHIPDeviceController.h
@@ -28,28 +28,23 @@
 
 #pragma once
 
+#include <controller/CHIPDevice.h>
 #include <controller/CHIPPersistentStorageDelegate.h>
 #include <core/CHIPCore.h>
 #include <core/CHIPTLV.h>
 #include <support/DLLUtil.h>
+#include <support/SerializableIntegerSet.h>
 #include <transport/RendezvousSession.h>
 #include <transport/RendezvousSessionDelegate.h>
 #include <transport/SecureSessionMgr.h>
 #include <transport/raw/UDP.h>
 
 namespace chip {
-namespace DeviceController {
 
-constexpr uint16_t kPacketCacheMaxSize = 16;
+namespace Controller {
 
-class ChipDeviceController;
-
-typedef void (*NewConnectionHandler)(ChipDeviceController * deviceController, Transport::PeerConnectionState * state,
-                                     void * appReqState);
-typedef void (*CompleteHandler)(ChipDeviceController * deviceController, void * appReqState);
-typedef void (*ErrorHandler)(ChipDeviceController * deviceController, void * appReqState, CHIP_ERROR err,
-                             const Inet::IPPacketInfo * pktInfo);
-typedef void (*MessageReceiveHandler)(ChipDeviceController * deviceController, void * appReqState, System::PacketBuffer * payload);
+constexpr uint16_t kNumMaxActiveDevices = 64;
+constexpr uint16_t kNumMaxPairedDevices = 128;
 
 class DLL_EXPORT DevicePairingDelegate
 {
@@ -100,117 +95,57 @@
     virtual void OnPairingDeleted(CHIP_ERROR error) {}
 };
 
-class DLL_EXPORT ChipDeviceController : public SecureSessionMgrDelegate,
-                                        public RendezvousSessionDelegate,
-                                        public PersistentStorageResultDelegate
+/**
+ * @brief
+ *   Controller applications can use this class to communicate with already paired CHIP devices. The
+ *   application is required to provide access to the persistent storage, where the paired device information
+ *   is stored. This object of this class can be initialized with the data from the storage (List of devices,
+ *   and device pairing information for individual devices). Alternatively, this class can retrieve the
+ *   relevant information when the application tries to communicate with the device
+ */
+class DLL_EXPORT DeviceController : public SecureSessionMgrDelegate, public PersistentStorageResultDelegate
 {
-    friend class ChipDeviceControllerCallback;
-
 public:
-    ChipDeviceController();
-    ~ChipDeviceController();
-
-    void * AppState;
+    DeviceController();
+    virtual ~DeviceController() {}
 
     /**
      * Init function to be used when there exists a device layer that takes care of initializing
      * System::Layer and InetLayer.
      */
-    CHIP_ERROR Init(NodeId localDeviceId, DevicePairingDelegate * pairingDelegate = nullptr,
-                    PersistentStorageDelegate * storageDelegate = nullptr);
-    /**
-     * Init function to be used when already-initialized System::Layer and InetLayer are available.
-     */
-    CHIP_ERROR Init(NodeId localDeviceId, System::Layer * systemLayer, Inet::InetLayer * inetLayer,
-                    DevicePairingDelegate * pairingDelegate = nullptr, PersistentStorageDelegate * storageDelegate = nullptr);
-    CHIP_ERROR Shutdown();
+    CHIP_ERROR Init(NodeId localDeviceId, PersistentStorageDelegate * storageDelegate = nullptr,
+                    System::Layer * systemLayer = nullptr, Inet::InetLayer * inetLayer = nullptr);
 
-    CHIP_ERROR SetUdpListenPort(uint16_t listenPort);
-
-    // ----- Connection Management -----
-    /**
-     * @brief
-     *   Connect to a CHIP device with the provided Rendezvous connection parameters
-     *
-     * @param[in] remoteDeviceId        The remote device Id.
-     * @param[in] params                The Rendezvous connection parameters
-     * @param[in] appReqState           Application specific context to be passed back when a message is received or on error
-     * @param[in] onConnected           Callback for when the connection is established
-     * @param[in] onMessageReceived     Callback for when a message is received
-     * @param[in] onError               Callback for when an error occurs
-     * @param[in] devicePort            [Optional] The CHIP Device's port, defaults to CHIP_PORT
-     * @param[in] interfaceId           [Optional] The interface indicator to use
-     *
-     * @return CHIP_ERROR               The connection status
-     */
-    CHIP_ERROR ConnectDevice(NodeId remoteDeviceId, RendezvousParameters & params, void * appReqState,
-                             NewConnectionHandler onConnected, MessageReceiveHandler onMessageReceived, ErrorHandler onError,
-                             uint16_t devicePort = CHIP_PORT, Inet::InterfaceId interfaceId = INET_NULL_INTERFACEID);
+    virtual CHIP_ERROR Shutdown();
 
     /**
      * @brief
-     *   Connect to a CHIP device at a given address and an optional port. This is a test only API
-     *   that bypasses Rendezvous and Secure Pairing process.
+     *   This function deserializes the provided deviceInfo object, and initializes and outputs the
+     *   corresponding Device object. The lifetime of the output object is tied to that of the DeviceController
+     *   object. The caller must not use the Device object If they free the DeviceController object, or
+     *   after they call ReleaseDevice() on the returned device object.
      *
-     * @param[in] remoteDeviceId        The remote device Id.
-     * @param[in] deviceAddr            The IPAddress of the requested Device
-     * @param[in] appReqState           Application specific context to be passed back when a message is received or on error
-     * @param[in] onConnected           Callback for when the connection is established
-     * @param[in] onMessageReceived     Callback for when a message is received
-     * @param[in] onError               Callback for when an error occurs
-     * @param[in] devicePort            [Optional] The CHIP Device's port, defaults to CHIP_PORT
-     * @param[in] interfaceId           [Optional] The interface indicator to use
-     * @return CHIP_ERROR           The connection status
+     * @param[in] deviceId   Node ID for the CHIP device
+     * @param[in] deviceInfo Serialized device info for the device
+     * @param[out] device    The output device object
+     *
+     * @return CHIP_ERROR CHIP_NO_ERROR on success, or corresponding error code.
      */
-    [[deprecated("Available until Rendezvous is implemented")]] CHIP_ERROR
-    ConnectDeviceWithoutSecurePairing(NodeId remoteDeviceId, const Inet::IPAddress & deviceAddr, void * appReqState,
-                                      NewConnectionHandler onConnected, MessageReceiveHandler onMessageReceived,
-                                      ErrorHandler onError, uint16_t devicePort = CHIP_PORT,
-                                      Inet::InterfaceId interfaceId = INET_NULL_INTERFACEID);
+    CHIP_ERROR GetDevice(NodeId deviceId, const SerializedDevice & deviceInfo, Device ** device);
 
     /**
      * @brief
-     *   Disconnect from a connected device
+     *   This function is similar to the other GetDevice object, except it reads the serialized object from
+     *   the persistent storage.
      *
-     * @return CHIP_ERROR   If the device was disconnected successfully
+     * @param[in] deviceId   Node ID for the CHIP device
+     * @param[out] device    The output device object
+     *
+     * @return CHIP_ERROR CHIP_NO_ERROR on success, or corresponding error code.
      */
-    CHIP_ERROR DisconnectDevice();
+    CHIP_ERROR GetDevice(NodeId deviceId, Device ** device);
 
-    /**
-     * @brief
-     *   Check if there's an active connection
-     *
-     * @return bool   If there is an active connection
-     */
-    bool IsConnected() const;
-
-    /**
-     * @brief
-     *   Check if the connection is active and security context is established
-     *
-     * @return bool   If the connection is active and security context is established
-     */
-    bool IsSecurelyConnected() const;
-
-    /**
-     * @brief
-     *   Get IP Address of the peer if the connection is active
-     *
-     * @return bool   If IP Address was returned
-     */
-    bool GetIpAddress(Inet::IPAddress & addr) const;
-
-    // ----- Messaging -----
-    /**
-     * @brief
-     *   Send a message to a connected CHIP device
-     *
-     * @param[in] appReqState   Application specific context to be passed back when a message is received or on error
-     * @param[in] buffer        The Data Buffer to trasmit to the device
-     * @param[in] peerDevice    Device ID of the peer device
-     * @return CHIP_ERROR   The return status
-     */
-    CHIP_ERROR SendMessage(void * appReqState, System::PacketBuffer * buffer, NodeId peerDevice = kUndefinedNodeId);
+    virtual void ReleaseDevice(Device * device);
 
     // ----- IO -----
     /**
@@ -220,14 +155,6 @@
      */
     CHIP_ERROR ServiceEvents();
 
-    // ----- Pairing -----
-    /**
-     * @brief
-     * Set device pairing delegate after init, pass nullptr remove device delegate.
-     * @return CHIP_ERROR   The return status
-     */
-    CHIP_ERROR SetDevicePairingDelegate(DevicePairingDelegate * pairingDelegate);
-
     /**
      * @brief
      *   Allow the CHIP Stack to process any pending events
@@ -236,86 +163,142 @@
      */
     CHIP_ERROR ServiceEventSignal();
 
+protected:
+    enum class State
+    {
+        NotInitialized,
+        Initialized
+    };
+
+    State mState;
+
+    /* A list of device objects that can be used for communicating with corresponding
+       CHIP devices. The list does not contain all the paired devices, but only the ones
+       which the controller application is currently accessing.
+    */
+    Device mActiveDevices[kNumMaxActiveDevices];
+
+    SerializableU64Set<kNumMaxPairedDevices> mPairedDevices;
+    bool mPairedDevicesInitialized;
+
+    NodeId mLocalDeviceId;
+    SecureSessionMgr<Transport::UDP> * mSessionManager;
+    PersistentStorageDelegate * mStorageDelegate;
+    Inet::InetLayer * mInetLayer;
+
+    uint16_t GetInactiveDeviceIndex();
+    uint16_t FindDeviceIndex(NodeId id);
+    void ReleaseDevice(uint16_t index);
+    CHIP_ERROR SetPairedDeviceList(const char * pairedDeviceSerializedSet);
+
+private:
+    //////////// SecureSessionMgrDelegate Implementation ///////////////
     void OnMessageReceived(const PacketHeader & header, const PayloadHeader & payloadHeader, Transport::PeerConnectionState * state,
                            System::PacketBuffer * msgBuf, SecureSessionMgrBase * mgr) override;
 
     void OnNewConnection(Transport::PeerConnectionState * state, SecureSessionMgrBase * mgr) override;
 
-    void OnAddressResolved(CHIP_ERROR error, NodeId nodeId, SecureSessionMgrBase * mgr) override;
+    //////////// PersistentStorageResultDelegate Implementation ///////////////
+    void OnValue(const char * key, const char * value) override;
+    void OnStatus(const char * key, Operation op, CHIP_ERROR err) override;
+
+    System::Layer * mSystemLayer;
+};
+
+/**
+ * @brief
+ *   The commissioner applications can use this class to pair new/unpaired CHIP devices. The application is
+ *   required to provide write access to the persistent storage, where the paired device information
+ *   will be stored.
+ */
+class DLL_EXPORT DeviceCommissioner : public DeviceController, public RendezvousSessionDelegate
+{
+public:
+    DeviceCommissioner();
+    ~DeviceCommissioner() {}
+
+    /**
+     * Init function to be used when there exists a device layer that takes care of initializing
+     * System::Layer and InetLayer.
+     */
+    CHIP_ERROR Init(NodeId localDeviceId, PersistentStorageDelegate * storageDelegate = nullptr,
+                    DevicePairingDelegate * pairingDelegate = nullptr, System::Layer * systemLayer = nullptr,
+                    Inet::InetLayer * inetLayer = nullptr);
+
+    void SetDevicePairingDelegate(DevicePairingDelegate * pairingDelegate) { mPairingDelegate = pairingDelegate; }
+
+    CHIP_ERROR Shutdown() override;
+
+    // ----- Connection Management -----
+    /**
+     * @brief
+     *   Pair a CHIP device with the provided Rendezvous connection parameters.
+     *   Use registered DevicePairingDelegate object to receive notifications on
+     *   pairing status updates.
+     *
+     *   Note: Pairing process requires that the caller has registered PersistentStorageDelegate
+     *         in the Init() call.
+     *
+     * @param[in] remoteDeviceId        The remote device Id.
+     * @param[in] params                The Rendezvous connection parameters
+     * @param[in] devicePort            [Optional] The CHIP Device's port, defaults to CHIP_PORT
+     * @param[in] interfaceId           [Optional] The local inet interface to use to communicate with the device.
+     *
+     * @return CHIP_ERROR               The connection status
+     */
+    CHIP_ERROR PairDevice(NodeId remoteDeviceId, RendezvousParameters & params, uint16_t devicePort = CHIP_PORT,
+                          Inet::InterfaceId interfaceId = INET_NULL_INTERFACEID);
+
+    [[deprecated("Available until Rendezvous is implemented")]] CHIP_ERROR
+    PairTestDeviceWithoutSecurity(NodeId remoteDeviceId, const Inet::IPAddress & deviceAddr, SerializedDevice & serialized,
+                                  uint16_t devicePort = CHIP_PORT, Inet::InterfaceId interfaceId = INET_NULL_INTERFACEID);
+
+    /**
+     * @brief
+     *   This function stops a pairing process that's in progress. It does not delete the pairing of a previously
+     *   paired device.
+     *
+     * @param[in] remoteDeviceId        The remote device Id.
+     *
+     * @return CHIP_ERROR               CHIP_NO_ERROR on success, or corresponding error
+     */
+    CHIP_ERROR StopPairing(NodeId remoteDeviceId);
+
+    /**
+     * @brief
+     *   Remove pairing for a paired device. If the device is currently being paired, it'll stop the pairing process.
+     *
+     * @param[in] remoteDeviceId        The remote device Id.
+     *
+     * @return CHIP_ERROR               CHIP_NO_ERROR on success, or corresponding error
+     */
+    CHIP_ERROR UnpairDevice(NodeId remoteDeviceId);
 
     //////////// RendezvousSessionDelegate Implementation ///////////////
     void OnRendezvousError(CHIP_ERROR err) override;
     void OnRendezvousComplete() override;
     void OnRendezvousStatusUpdate(RendezvousSessionDelegate::Status status, CHIP_ERROR err) override;
 
-    //////////// PersistentStorageResultDelegate Implementation ///////////////
-    void OnValue(const char * key, const char * value) override;
-    void OnStatus(const char * key, Operation op, CHIP_ERROR err) override;
+    void RendezvousCleanup(CHIP_ERROR status);
+
+    void ReleaseDevice(Device * device) override;
 
 private:
-    enum
-    {
-        kState_NotInitialized = 0,
-        kState_Initialized    = 1
-    } mState;
-
-    enum ConnectionState
-    {
-        kConnectionState_NotConnected     = 0,
-        kConnectionState_Connected        = 1,
-        kConnectionState_SecureConnecting = 2,
-        kConnectionState_SecureConnected  = 3,
-    };
-
-    System::Layer * mSystemLayer;
-    Inet::InetLayer * mInetLayer;
-
-    SecureSessionMgr<Transport::UDP> * mSessionManager;
+    DevicePairingDelegate * mPairingDelegate;
     RendezvousSession * mRendezvousSession;
 
-    ConnectionState mConState;
-    void * mAppReqState;
+    /* This field is an index in mActiveDevices list. The object at this index in the list
+       contains the device object that's tracking the state of the device that's being paired.
+       If no device is currently being paired, this value will be kNumMaxPairedDevices.  */
+    uint16_t mDeviceBeingPaired;
 
-    union
-    {
-        CompleteHandler General;
-        MessageReceiveHandler Response;
-    } mOnComplete;
+    /* This field is true when device pairing information changes, e.g. a new device is paired, or
+       the pairing for a device is removed. The DeviceCommissioner uses this to decide when to
+       persist the device list */
+    bool mPairedDevicesUpdated;
 
-    ErrorHandler mOnError;
-    NewConnectionHandler mOnNewConnection;
-    System::PacketBuffer * mCurReqMsg;
-
-    NodeId mLocalDeviceId;
-    uint16_t mListenPort;
-    Inet::IPAddress mDeviceAddr;
-    uint16_t mDevicePort;
-    Inet::InterfaceId mInterface;
-    Optional<NodeId> mRemoteDeviceId;
-
-    SecurePairingSession mPairingSession;
-    SecurePairingUsingTestSecret * mTestSecurePairingSecret = nullptr;
-
-    SecurePairingSession * mSecurePairingSession = nullptr;
-
-    DevicePairingDelegate * mPairingDelegate = nullptr;
-
-    PersistentStorageDelegate * mStorageDelegate;
-
-    System::PacketBuffer * mCachedPackets[kPacketCacheMaxSize];
-    uint16_t mNumCachedPackets;
-
-    void ClearRequestState();
-    void ClearOpState();
-
-    CHIP_ERROR EstablishSecureSession();
-    CHIP_ERROR TryEstablishingSecureSession(NodeId peer);
-    CHIP_ERROR ResumeSecureSession(NodeId peer);
-
-    CHIP_ERROR CachePacket(System::PacketBuffer * buffer);
-    CHIP_ERROR SendCachedPackets();
-    void DiscardCachedPackets();
+    void PersistDeviceList();
 };
 
-} // namespace DeviceController
+} // namespace Controller
 } // namespace chip
diff --git a/src/controller/CHIPDeviceController_deprecated.cpp b/src/controller/CHIPDeviceController_deprecated.cpp
new file mode 100644
index 0000000..eaaa237
--- /dev/null
+++ b/src/controller/CHIPDeviceController_deprecated.cpp
@@ -0,0 +1,239 @@
+/*
+ *
+ *    Copyright (c) 2020 Project CHIP Authors
+ *    Copyright (c) 2013-2017 Nest Labs, Inc.
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ *    @file
+ *      Implementation of CHIP Device Controller, a common class
+ *      that implements discovery, pairing and provisioning of CHIP
+ *      devices.
+ *
+ */
+
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS
+#endif
+#ifndef __STDC_FORMAT_MACROS
+#define __STDC_FORMAT_MACROS
+#endif
+
+// module header, comes first
+#include <controller/CHIPDeviceController_deprecated.h>
+
+#if CONFIG_DEVICE_LAYER
+#include <platform/CHIPDeviceLayer.h>
+#endif
+
+#include <core/CHIPCore.h>
+#include <core/CHIPEncoding.h>
+#include <core/CHIPSafeCasts.h>
+#include <support/Base64.h>
+#include <support/CHIPMem.h>
+#include <support/CodeUtils.h>
+#include <support/ErrorStr.h>
+#include <support/TimeUtils.h>
+#include <support/logging/CHIPLogging.h>
+
+#include <errno.h>
+#include <inttypes.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <time.h>
+
+using namespace chip::Inet;
+using namespace chip::System;
+using namespace chip::Controller;
+
+namespace chip {
+namespace DeviceController {
+
+using namespace chip::Encoding;
+
+ChipDeviceController::ChipDeviceController()
+{
+    mState                  = kState_NotInitialized;
+    AppState                = nullptr;
+    mCurReqMsg              = nullptr;
+    mOnError                = nullptr;
+    mOnNewConnection        = nullptr;
+    mListenPort             = CHIP_PORT;
+    mLocalDeviceId          = kUndefinedNodeId;
+    mRemoteDeviceId         = kUndefinedNodeId;
+    mDevice                 = nullptr;
+    mPairingWithoutSecurity = false;
+    CHIP_ZERO_AT(mOnComplete);
+}
+
+ChipDeviceController::~ChipDeviceController() {}
+
+CHIP_ERROR ChipDeviceController::Init(NodeId localNodeId, DevicePairingDelegate * pairingDelegate,
+                                      PersistentStorageDelegate * storageDelegate)
+{
+    return mCommissioner.Init(localNodeId, storageDelegate, pairingDelegate);
+}
+
+CHIP_ERROR ChipDeviceController::Init(NodeId localNodeId, System::Layer * systemLayer, InetLayer * inetLayer,
+                                      DevicePairingDelegate * pairingDelegate, PersistentStorageDelegate * storageDelegate)
+{
+    return mCommissioner.Init(localNodeId, storageDelegate, pairingDelegate, systemLayer, inetLayer);
+}
+
+CHIP_ERROR ChipDeviceController::Shutdown()
+{
+    return mCommissioner.Shutdown();
+}
+
+CHIP_ERROR ChipDeviceController::ConnectDevice(NodeId remoteDeviceId, RendezvousParameters & params, void * appReqState,
+                                               NewConnectionHandler onConnected, MessageReceiveHandler onMessageReceived,
+                                               ErrorHandler onError, uint16_t devicePort, Inet::InterfaceId interfaceId)
+{
+    CHIP_ERROR err = mCommissioner.PairDevice(remoteDeviceId, params, devicePort, interfaceId);
+    SuccessOrExit(err);
+
+    mRemoteDeviceId  = remoteDeviceId;
+    mAppReqState     = appReqState;
+    mOnNewConnection = onConnected;
+
+    mOnComplete.Response = onMessageReceived;
+    mOnError             = onError;
+
+exit:
+    return err;
+}
+
+CHIP_ERROR ChipDeviceController::ConnectDeviceWithoutSecurePairing(NodeId remoteDeviceId, const IPAddress & deviceAddr,
+                                                                   void * appReqState, NewConnectionHandler onConnected,
+                                                                   MessageReceiveHandler onMessageReceived, ErrorHandler onError,
+                                                                   uint16_t devicePort, Inet::InterfaceId interfaceId)
+{
+    CHIP_ERROR err =
+        mCommissioner.PairTestDeviceWithoutSecurity(remoteDeviceId, deviceAddr, mSerializedTestDevice, devicePort, interfaceId);
+    SuccessOrExit(err);
+
+    mPairingWithoutSecurity = true;
+
+    mRemoteDeviceId  = remoteDeviceId;
+    mAppReqState     = appReqState;
+    mOnNewConnection = onConnected;
+
+    mOnComplete.Response = onMessageReceived;
+    mOnError             = onError;
+
+    if (mOnNewConnection)
+    {
+        mOnNewConnection(this, nullptr, mAppReqState);
+    }
+
+exit:
+    return err;
+}
+
+CHIP_ERROR ChipDeviceController::SetUdpListenPort(uint16_t listenPort)
+{
+    if (mState != kState_Initialized)
+        return CHIP_ERROR_INCORRECT_STATE;
+    mListenPort = listenPort;
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ChipDeviceController::ServiceEvents()
+{
+    return mCommissioner.ServiceEvents();
+}
+
+CHIP_ERROR ChipDeviceController::ServiceEventSignal()
+{
+    return mCommissioner.ServiceEventSignal();
+}
+
+bool ChipDeviceController::IsConnected() const
+{
+    return mState == kState_Initialized;
+}
+
+bool ChipDeviceController::GetIpAddress(Inet::IPAddress & addr) const
+{
+    if (IsConnected() && mDevice != nullptr)
+        return mDevice->GetIpAddress(addr);
+
+    return false;
+}
+
+CHIP_ERROR ChipDeviceController::DisconnectDevice()
+{
+    if (mDevice != nullptr)
+    {
+        mCommissioner.ReleaseDevice(mDevice);
+    }
+
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ChipDeviceController::SendMessage(void * appReqState, PacketBuffer * buffer, NodeId peerDevice)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+
+    VerifyOrExit(buffer != nullptr, err = CHIP_ERROR_INVALID_ARGUMENT);
+
+    mAppReqState = appReqState;
+
+    if (peerDevice != kUndefinedNodeId)
+    {
+        mRemoteDeviceId = peerDevice;
+    }
+    VerifyOrExit(mRemoteDeviceId != kUndefinedNodeId, err = CHIP_ERROR_INCORRECT_STATE);
+
+    if (mDevice == nullptr)
+    {
+        if (mPairingWithoutSecurity)
+        {
+            err = mCommissioner.GetDevice(mRemoteDeviceId, mSerializedTestDevice, &mDevice);
+        }
+        else
+        {
+            err = mCommissioner.GetDevice(mRemoteDeviceId, &mDevice);
+        }
+        SuccessOrExit(err);
+    }
+
+    VerifyOrExit(mDevice != nullptr, err = CHIP_ERROR_INVALID_ARGUMENT);
+    mDevice->SetDelegate(this);
+
+    err = mDevice->SendMessage(buffer);
+
+exit:
+
+    return err;
+}
+
+CHIP_ERROR ChipDeviceController::SetDevicePairingDelegate(DevicePairingDelegate * pairingDelegate)
+{
+    mCommissioner.SetDevicePairingDelegate(pairingDelegate);
+    return CHIP_NO_ERROR;
+}
+
+void ChipDeviceController::OnMessage(System::PacketBuffer * msgBuf)
+{
+    if (mOnComplete.Response != nullptr)
+    {
+        mOnComplete.Response(this, mAppReqState, msgBuf);
+    }
+}
+
+} // namespace DeviceController
+} // namespace chip
diff --git a/src/controller/CHIPDeviceController_deprecated.h b/src/controller/CHIPDeviceController_deprecated.h
new file mode 100644
index 0000000..d1bf836
--- /dev/null
+++ b/src/controller/CHIPDeviceController_deprecated.h
@@ -0,0 +1,220 @@
+/*
+ *
+ *    Copyright (c) 2020 Project CHIP Authors
+ *    Copyright (c) 2013-2017 Nest Labs, Inc.
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ *    @file
+ *      Declaration of CHIP Device Controller, a common class
+ *      that implements connecting and messaging and will later
+ *      be expanded to support discovery, pairing and
+ *      provisioning of CHIP  devices.
+ *
+ */
+
+#pragma once
+
+#include <controller/CHIPDeviceController.h>
+#include <controller/CHIPPersistentStorageDelegate.h>
+#include <core/CHIPCore.h>
+#include <core/CHIPTLV.h>
+#include <support/DLLUtil.h>
+#include <transport/RendezvousSession.h>
+#include <transport/RendezvousSessionDelegate.h>
+#include <transport/SecureSessionMgr.h>
+#include <transport/raw/UDP.h>
+
+namespace chip {
+namespace DeviceController {
+
+constexpr uint16_t kPacketCacheMaxSize = 16;
+
+class ChipDeviceController;
+
+typedef void (*NewConnectionHandler)(ChipDeviceController * deviceController, Transport::PeerConnectionState * state,
+                                     void * appReqState);
+typedef void (*CompleteHandler)(ChipDeviceController * deviceController, void * appReqState);
+typedef void (*ErrorHandler)(ChipDeviceController * deviceController, void * appReqState, CHIP_ERROR err,
+                             const Inet::IPPacketInfo * pktInfo);
+typedef void (*MessageReceiveHandler)(ChipDeviceController * deviceController, void * appReqState, System::PacketBuffer * payload);
+
+class DLL_EXPORT ChipDeviceController : public Controller::DeviceStatusDelegate
+{
+    friend class ChipDeviceControllerCallback;
+
+public:
+    ChipDeviceController();
+    ~ChipDeviceController();
+
+    void * AppState;
+
+    /**
+     * Init function to be used when there exists a device layer that takes care of initializing
+     * System::Layer and InetLayer.
+     */
+    CHIP_ERROR Init(NodeId localDeviceId, Controller::DevicePairingDelegate * pairingDelegate = nullptr,
+                    Controller::PersistentStorageDelegate * storageDelegate = nullptr);
+    /**
+     * Init function to be used when already-initialized System::Layer and InetLayer are available.
+     */
+    CHIP_ERROR Init(NodeId localDeviceId, System::Layer * systemLayer, Inet::InetLayer * inetLayer,
+                    Controller::DevicePairingDelegate * pairingDelegate     = nullptr,
+                    Controller::PersistentStorageDelegate * storageDelegate = nullptr);
+    CHIP_ERROR Shutdown();
+
+    CHIP_ERROR SetUdpListenPort(uint16_t listenPort);
+
+    // ----- Connection Management -----
+    /**
+     * @brief
+     *   Connect to a CHIP device with the provided Rendezvous connection parameters
+     *
+     * @param[in] remoteDeviceId        The remote device Id.
+     * @param[in] params                The Rendezvous connection parameters
+     * @param[in] appReqState           Application specific context to be passed back when a message is received or on error
+     * @param[in] onConnected           Callback for when the connection is established
+     * @param[in] onMessageReceived     Callback for when a message is received
+     * @param[in] onError               Callback for when an error occurs
+     * @param[in] devicePort            [Optional] The CHIP Device's port, defaults to CHIP_PORT
+     * @param[in] interfaceId           [Optional] The interface indicator to use
+     *
+     * @return CHIP_ERROR               The connection status
+     */
+    [[deprecated("Available until controller apps move to DeviceController/DeviceCommissioner API")]] CHIP_ERROR
+    ConnectDevice(NodeId remoteDeviceId, RendezvousParameters & params, void * appReqState, NewConnectionHandler onConnected,
+                  MessageReceiveHandler onMessageReceived, ErrorHandler onError, uint16_t devicePort = CHIP_PORT,
+                  Inet::InterfaceId interfaceId = INET_NULL_INTERFACEID);
+
+    /**
+     * @brief
+     *   Connect to a CHIP device at a given address and an optional port. This is a test only API
+     *   that bypasses Rendezvous and Secure Pairing process.
+     *
+     * @param[in] remoteDeviceId        The remote device Id.
+     * @param[in] deviceAddr            The IPAddress of the requested Device
+     * @param[in] appReqState           Application specific context to be passed back when a message is received or on error
+     * @param[in] onConnected           Callback for when the connection is established
+     * @param[in] onMessageReceived     Callback for when a message is received
+     * @param[in] onError               Callback for when an error occurs
+     * @param[in] devicePort            [Optional] The CHIP Device's port, defaults to CHIP_PORT
+     * @param[in] interfaceId           [Optional] The interface indicator to use
+     * @return CHIP_ERROR           The connection status
+     */
+    [[deprecated("Available until Rendezvous is implemented")]] CHIP_ERROR
+    ConnectDeviceWithoutSecurePairing(NodeId remoteDeviceId, const Inet::IPAddress & deviceAddr, void * appReqState,
+                                      NewConnectionHandler onConnected, MessageReceiveHandler onMessageReceived,
+                                      ErrorHandler onError, uint16_t devicePort = CHIP_PORT,
+                                      Inet::InterfaceId interfaceId = INET_NULL_INTERFACEID);
+
+    /**
+     * @brief
+     *   Disconnect from a connected device
+     *
+     * @return CHIP_ERROR   If the device was disconnected successfully
+     */
+    CHIP_ERROR DisconnectDevice();
+
+    /**
+     * @brief
+     *   Check if there's an active connection
+     *
+     * @return bool   If there is an active connection
+     */
+    bool IsConnected() const;
+
+    /**
+     * @brief
+     *   Get IP Address of the peer if the connection is active
+     *
+     * @return bool   If IP Address was returned
+     */
+    bool GetIpAddress(Inet::IPAddress & addr) const;
+
+    // ----- Messaging -----
+    /**
+     * @brief
+     *   Send a message to a connected CHIP device
+     *
+     * @param[in] appReqState   Application specific context to be passed back when a message is received or on error
+     * @param[in] buffer        The Data Buffer to trasmit to the device
+     * @param[in] peerDevice    Device ID of the peer device
+     * @return CHIP_ERROR   The return status
+     */
+    CHIP_ERROR SendMessage(void * appReqState, System::PacketBuffer * buffer, NodeId peerDevice = kUndefinedNodeId);
+
+    // ----- IO -----
+    /**
+     * @brief
+     * Start the event loop task within the CHIP stack
+     * @return CHIP_ERROR   The return status
+     */
+    CHIP_ERROR ServiceEvents();
+
+    /**
+     * @brief
+     *   Allow the CHIP Stack to process any pending events
+     *   This can be called in an event handler loop to tigger callbacks within the CHIP stack
+     * @return CHIP_ERROR   The return status
+     */
+    CHIP_ERROR ServiceEventSignal();
+
+    // ----- Pairing -----
+    /**
+     * @brief
+     * Set device pairing delegate after init, pass nullptr remove device delegate.
+     * @return CHIP_ERROR   The return status
+     */
+    CHIP_ERROR SetDevicePairingDelegate(Controller::DevicePairingDelegate * pairingDelegate);
+
+    //////////// DeviceStatusDelegate Implementation ///////////////
+    void OnMessage(System::PacketBuffer * msg) override;
+
+private:
+    enum
+    {
+        kState_NotInitialized = 0,
+        kState_Initialized    = 1
+    } mState;
+
+    Controller::DeviceCommissioner mCommissioner;
+    Controller::Device * mDevice;
+
+    void * mAppReqState;
+
+    union
+    {
+        CompleteHandler General;
+        MessageReceiveHandler Response;
+    } mOnComplete;
+
+    ErrorHandler mOnError;
+    NewConnectionHandler mOnNewConnection;
+    System::PacketBuffer * mCurReqMsg;
+
+    NodeId mLocalDeviceId;
+    NodeId mRemoteDeviceId;
+    uint16_t mListenPort;
+
+    Controller::SerializedDevice mSerializedTestDevice;
+    bool mPairingWithoutSecurity;
+
+    void ClearRequestState();
+    void ClearOpState();
+};
+
+} // namespace DeviceController
+} // namespace chip
diff --git a/src/controller/CHIPPersistentStorageDelegate.h b/src/controller/CHIPPersistentStorageDelegate.h
index 1414477..a2176f2 100644
--- a/src/controller/CHIPPersistentStorageDelegate.h
+++ b/src/controller/CHIPPersistentStorageDelegate.h
@@ -22,7 +22,7 @@
 #include <support/DLLUtil.h>
 
 namespace chip {
-namespace DeviceController {
+namespace Controller {
 
 class DLL_EXPORT PersistentStorageResultDelegate
 {
@@ -81,6 +81,21 @@
 
     /**
      * @brief
+     *   This is a synchronous Get API, where the value is returned via the output
+     *   buffer. This API should be used sparingly, since it may block for
+     *   some duration.
+     *
+     * @param[in]      key Key to lookup
+     * @param[out]     value Value for the key
+     * @param[in, out] size Input value buffer size, output length of value.
+     *                 The output length could be larger than input value. In
+     *                 such cases, the user should allocate the buffer large
+     *                 enough (>= output length), and call the API again.
+     */
+    virtual CHIP_ERROR GetKeyValue(const char * key, char * value, uint16_t & size) { return CHIP_ERROR_NOT_IMPLEMENTED; }
+
+    /**
+     * @brief
      *   Set the value for the key
      *
      * @param[in] key Key to be set
@@ -97,5 +112,5 @@
     virtual void DeleteKeyValue(const char * key) = 0;
 };
 
-} // namespace DeviceController
+} // namespace Controller
 } // namespace chip
diff --git a/src/controller/java/AndroidDeviceControllerWrapper.h b/src/controller/java/AndroidDeviceControllerWrapper.h
index a2715f8..59eb1fe 100644
--- a/src/controller/java/AndroidDeviceControllerWrapper.h
+++ b/src/controller/java/AndroidDeviceControllerWrapper.h
@@ -21,7 +21,7 @@
 
 #include <jni.h>
 
-#include <controller/CHIPDeviceController.h>
+#include <controller/CHIPDeviceController_deprecated.h>
 
 /**
  * This class contains all relevant information for the JNI view of CHIPDeviceController
@@ -29,7 +29,7 @@
  *
  * Generally it contains the DeviceController class itself, plus any related delegates/callbacks.
  */
-class AndroidDeviceControllerWrapper : public chip::DeviceController::DevicePairingDelegate
+class AndroidDeviceControllerWrapper : public chip::Controller::DevicePairingDelegate
 {
 public:
     ~AndroidDeviceControllerWrapper();
diff --git a/src/controller/java/CHIPDeviceController-JNI.cpp b/src/controller/java/CHIPDeviceController-JNI.cpp
index 007e53e..721d8a7 100644
--- a/src/controller/java/CHIPDeviceController-JNI.cpp
+++ b/src/controller/java/CHIPDeviceController-JNI.cpp
@@ -28,7 +28,7 @@
 #include "AndroidDeviceControllerWrapper.h"
 
 #include <ble/BleUUID.h>
-#include <controller/CHIPDeviceController.h>
+#include <controller/CHIPDeviceController_deprecated.h>
 #include <jni.h>
 #include <pthread.h>
 #include <support/CHIPMem.h>
diff --git a/src/controller/python/BUILD.gn b/src/controller/python/BUILD.gn
index dd9407a..84b22a1 100644
--- a/src/controller/python/BUILD.gn
+++ b/src/controller/python/BUILD.gn
@@ -23,7 +23,8 @@
 }
 
 config("includes") {
-  include_dirs = [ "${chip_root}/src/controller/CHIPDeviceController.h" ]
+  include_dirs =
+      [ "${chip_root}/src/controller/CHIPDeviceController_deprecated.h" ]
 }
 
 shared_library("ChipDeviceCtrl") {
diff --git a/src/controller/python/ChipDeviceController-ScriptBinding.cpp b/src/controller/python/ChipDeviceController-ScriptBinding.cpp
index 18f6c02..8e9e927 100644
--- a/src/controller/python/ChipDeviceController-ScriptBinding.cpp
+++ b/src/controller/python/ChipDeviceController-ScriptBinding.cpp
@@ -45,7 +45,7 @@
 
 #include "ChipDeviceController-ScriptDevicePairingDelegate.h"
 
-#include <controller/CHIPDeviceController.h>
+#include <controller/CHIPDeviceController_deprecated.h>
 #include <support/CHIPMem.h>
 #include <support/CodeUtils.h>
 #include <support/DLLUtil.h>
@@ -178,7 +178,7 @@
 nl_Chip_ScriptDevicePairingDelegate_SetWifiCredential(chip::DeviceController::ScriptDevicePairingDelegate * pairingDelegate,
                                                       const char * ssid, const char * password);
 CHIP_ERROR nl_Chip_DeviceController_SetDevicePairingDelegate(chip::DeviceController::ChipDeviceController * devCtrl,
-                                                             chip::DeviceController::DevicePairingDelegate * pairingDelegate);
+                                                             chip::Controller::DevicePairingDelegate * pairingDelegate);
 
 #if CONFIG_NETWORK_LAYER_BLE
 CHIP_ERROR nl_Chip_DeviceController_ValidateBTP(chip::DeviceController::ChipDeviceController * devCtrl,
@@ -583,7 +583,7 @@
     return err;
 }
 CHIP_ERROR nl_Chip_DeviceController_SetDevicePairingDelegate(chip::DeviceController::ChipDeviceController * devCtrl,
-                                                             chip::DeviceController::DevicePairingDelegate * pairingDelegate)
+                                                             chip::Controller::DevicePairingDelegate * pairingDelegate)
 {
     CHIP_ERROR err = CHIP_NO_ERROR;
 
diff --git a/src/controller/python/ChipDeviceController-ScriptDevicePairingDelegate.h b/src/controller/python/ChipDeviceController-ScriptDevicePairingDelegate.h
index 17b51a6..3a821bf 100644
--- a/src/controller/python/ChipDeviceController-ScriptDevicePairingDelegate.h
+++ b/src/controller/python/ChipDeviceController-ScriptDevicePairingDelegate.h
@@ -25,7 +25,7 @@
 
 #pragma once
 
-#include <controller/CHIPDeviceController.h>
+#include <controller/CHIPDeviceController_deprecated.h>
 
 #include <platform/internal/DeviceNetworkInfo.h>
 #include <transport/RendezvousSessionDelegate.h>
@@ -33,7 +33,7 @@
 namespace chip {
 namespace DeviceController {
 
-class ScriptDevicePairingDelegate final : public DevicePairingDelegate
+class ScriptDevicePairingDelegate final : public Controller::DevicePairingDelegate
 {
 public:
     ~ScriptDevicePairingDelegate() = default;
diff --git a/src/darwin/CHIPTool/CHIPTool/Framework Helpers/DefaultsUtils.m b/src/darwin/CHIPTool/CHIPTool/Framework Helpers/DefaultsUtils.m
index be0c0fc..fcc9d05 100644
--- a/src/darwin/CHIPTool/CHIPTool/Framework Helpers/DefaultsUtils.m
+++ b/src/darwin/CHIPTool/CHIPTool/Framework Helpers/DefaultsUtils.m
@@ -48,9 +48,17 @@
 - (void)GetKeyValue:(NSString *)key handler:(SendKeyValue)completionHandler
 {
     NSString * value = CHIPGetDomainValueForKey(kCHIPToolDefaultsDomain, key);
+    NSLog(@"CHIPPersistentStorageDelegate Get Value for Key: %@, value %@", key, value);
     completionHandler(key, value);
 }
 
+- (NSString *)GetKeyValue:(NSString *)key
+{
+    NSString * value = CHIPGetDomainValueForKey(kCHIPToolDefaultsDomain, key);
+    NSLog(@"CHIPPersistentStorageDelegate Get Value for Key: %@, value %@", key, value);
+    return value;
+}
+
 - (void)SetKeyValue:(NSString *)key value:(NSString *)value handler:(SendStatus)completionHandler
 {
     CHIPSetDomainValueForKey(kCHIPToolDefaultsDomain, key, value);
diff --git a/src/darwin/Framework/CHIP/CHIPDeviceController.mm b/src/darwin/Framework/CHIP/CHIPDeviceController.mm
index 3d57db3..faa2d56 100644
--- a/src/darwin/Framework/CHIP/CHIPDeviceController.mm
+++ b/src/darwin/Framework/CHIP/CHIPDeviceController.mm
@@ -25,7 +25,7 @@
 #import "CHIPLogging.h"
 #import "CHIPPersistentStorageDelegateBridge.h"
 
-#include <controller/CHIPDeviceController.h>
+#include <controller/CHIPDeviceController_deprecated.h>
 #include <inet/IPAddress.h>
 #include <support/CHIPMem.h>
 #include <system/SystemPacketBuffer.h>
@@ -95,6 +95,11 @@
             return nil;
         }
 
+        if (CHIP_NO_ERROR != chip::Platform::MemoryInit()) {
+            CHIP_LOG_ERROR("Error: Failed in memory init");
+            return nil;
+        }
+
         _cppController = new chip::DeviceController::ChipDeviceController();
         if (!_cppController) {
             CHIP_LOG_ERROR("Error: couldn't create c++ controller");
@@ -129,17 +134,6 @@
             _persistentStorageDelegateBridge = NULL;
             return nil;
         }
-
-        if (CHIP_NO_ERROR != chip::Platform::MemoryInit()) {
-            CHIP_LOG_ERROR("Error: couldn't initialize c++ controller");
-            delete _cppController;
-            _cppController = NULL;
-            delete _pairingDelegateBridge;
-            _pairingDelegateBridge = NULL;
-            delete _persistentStorageDelegateBridge;
-            _persistentStorageDelegateBridge = NULL;
-            return nil;
-        }
     }
     return self;
 }
diff --git a/src/darwin/Framework/CHIP/CHIPDevicePairingDelegateBridge.h b/src/darwin/Framework/CHIP/CHIPDevicePairingDelegateBridge.h
index b448c06..884c17b 100644
--- a/src/darwin/Framework/CHIP/CHIPDevicePairingDelegateBridge.h
+++ b/src/darwin/Framework/CHIP/CHIPDevicePairingDelegateBridge.h
@@ -22,7 +22,7 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-class CHIPDevicePairingDelegateBridge : public chip::DeviceController::DevicePairingDelegate
+class CHIPDevicePairingDelegateBridge : public chip::Controller::DevicePairingDelegate
 {
 public:
     CHIPDevicePairingDelegateBridge();
diff --git a/src/darwin/Framework/CHIP/CHIPPersistentStorageDelegate.h b/src/darwin/Framework/CHIP/CHIPPersistentStorageDelegate.h
index 916b1f4..b59cce2 100644
--- a/src/darwin/Framework/CHIP/CHIPPersistentStorageDelegate.h
+++ b/src/darwin/Framework/CHIP/CHIPPersistentStorageDelegate.h
@@ -44,6 +44,12 @@
 - (void)GetKeyValue:(NSString *)key handler:(SendKeyValue)completionHandler;
 
 /**
+ * Get the value for the given key
+ *
+ */
+- (NSString *)GetKeyValue:(NSString *)key;
+
+/**
  * Set the value of the key to the given value
  *
  */
diff --git a/src/darwin/Framework/CHIP/CHIPPersistentStorageDelegateBridge.h b/src/darwin/Framework/CHIP/CHIPPersistentStorageDelegateBridge.h
index fe9645b..bb689a0 100644
--- a/src/darwin/Framework/CHIP/CHIPPersistentStorageDelegateBridge.h
+++ b/src/darwin/Framework/CHIP/CHIPPersistentStorageDelegateBridge.h
@@ -22,7 +22,7 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-class CHIPPersistentStorageDelegateBridge : public chip::DeviceController::PersistentStorageDelegate
+class CHIPPersistentStorageDelegateBridge : public chip::Controller::PersistentStorageDelegate
 {
 public:
     CHIPPersistentStorageDelegateBridge();
@@ -30,10 +30,12 @@
 
     void setFrameworkDelegate(id<CHIPPersistentStorageDelegate> delegate, dispatch_queue_t queue);
 
-    void SetDelegate(chip::DeviceController::PersistentStorageResultDelegate * delegate);
+    void SetDelegate(chip::Controller::PersistentStorageResultDelegate * delegate);
 
     void GetKeyValue(const char * key) override;
 
+    CHIP_ERROR GetKeyValue(const char * key, char * value, uint16_t & size) override;
+
     void SetKeyValue(const char * key, const char * value) override;
 
     void DeleteKeyValue(const char * key) override;
@@ -42,7 +44,7 @@
     id<CHIPPersistentStorageDelegate> mDelegate;
     dispatch_queue_t mQueue;
 
-    chip::DeviceController::PersistentStorageResultDelegate * mCallback;
+    chip::Controller::PersistentStorageResultDelegate * mCallback;
     SendKeyValue mCompletionHandler;
     SendStatus mStatusHandler;
     NSUserDefaults * mDefaultPersistentStorage;
diff --git a/src/darwin/Framework/CHIP/CHIPPersistentStorageDelegateBridge.mm b/src/darwin/Framework/CHIP/CHIPPersistentStorageDelegateBridge.mm
index 51a7444..92f3862 100644
--- a/src/darwin/Framework/CHIP/CHIPPersistentStorageDelegateBridge.mm
+++ b/src/darwin/Framework/CHIP/CHIPPersistentStorageDelegateBridge.mm
@@ -39,7 +39,7 @@
     }
 }
 
-void CHIPPersistentStorageDelegateBridge::SetDelegate(chip::DeviceController::PersistentStorageResultDelegate * delegate)
+void CHIPPersistentStorageDelegateBridge::SetDelegate(chip::Controller::PersistentStorageResultDelegate * delegate)
 {
     if (delegate) {
         mCallback = delegate;
@@ -49,17 +49,17 @@
         };
 
         mStatusHandler = ^(NSString * key, Operation operation, NSError * status) {
-            chip::DeviceController::PersistentStorageResultDelegate::Operation op
-                = chip::DeviceController::PersistentStorageResultDelegate::Operation::kGET;
+            chip::Controller::PersistentStorageResultDelegate::Operation op
+                = chip::Controller::PersistentStorageResultDelegate::Operation::kGET;
             switch (operation) {
             case kGet:
-                op = chip::DeviceController::PersistentStorageResultDelegate::Operation::kGET;
+                op = chip::Controller::PersistentStorageResultDelegate::Operation::kGET;
                 break;
             case kSet:
-                op = chip::DeviceController::PersistentStorageResultDelegate::Operation::kSET;
+                op = chip::Controller::PersistentStorageResultDelegate::Operation::kSET;
                 break;
             case kDelete:
-                op = chip::DeviceController::PersistentStorageResultDelegate::Operation::kDELETE;
+                op = chip::Controller::PersistentStorageResultDelegate::Operation::kDELETE;
                 break;
             }
             mCallback->OnStatus([key UTF8String], op, [CHIPError errorToCHIPErrorCode:status]);
@@ -84,16 +84,41 @@
     } else {
         dispatch_async(mDefaultCallbackQueue, ^{
             NSString * value = [mDefaultPersistentStorage objectForKey:keyString];
+            NSLog(@"PersistentStorageDelegate Get Value for Key: %@, value %@", keyString, value);
             mCompletionHandler(keyString, value);
         });
     }
 }
 
+CHIP_ERROR CHIPPersistentStorageDelegateBridge::GetKeyValue(const char * key, char * value, uint16_t & size)
+{
+    NSString * keyString = [NSString stringWithUTF8String:key];
+    NSLog(@"PersistentStorageDelegate Sync Get Value for Key: %@", keyString);
+
+    NSString * valueString = nil;
+
+    id<CHIPPersistentStorageDelegate> strongDelegate = mDelegate;
+    if (strongDelegate) {
+        valueString = [strongDelegate GetKeyValue:keyString];
+    } else {
+        valueString = [mDefaultPersistentStorage objectForKey:keyString];
+    }
+
+    if (value != nullptr) {
+        size = strlcpy(value, [valueString UTF8String], size);
+    } else {
+        size = [valueString length];
+    }
+    // Increment size to account for null termination
+    size += 1;
+    return CHIP_NO_ERROR;
+}
+
 void CHIPPersistentStorageDelegateBridge::SetKeyValue(const char * key, const char * value)
 {
     NSString * keyString = [NSString stringWithUTF8String:key];
     NSString * valueString = [NSString stringWithUTF8String:value];
-    NSLog(@"PersistentStorageDelegate Set Key %@", keyString);
+    NSLog(@"PersistentStorageDelegate Set Key %@, Value %@", keyString, valueString);
 
     id<CHIPPersistentStorageDelegate> strongDelegate = mDelegate;
     if (strongDelegate && mQueue) {
diff --git a/src/lib/support/SerializableIntegerSet.h b/src/lib/support/SerializableIntegerSet.h
index 0fe6e0d..6e59f77 100644
--- a/src/lib/support/SerializableIntegerSet.h
+++ b/src/lib/support/SerializableIntegerSet.h
@@ -34,6 +34,8 @@
 #include <support/Base64.h>
 #include <support/CodeUtils.h>
 
+#define CHIP_MAX_SERIALIZED_SIZE_U64(count) static_cast<uint16_t>(BASE64_ENCODED_LEN(sizeof(uint64_t) * (count)))
+
 namespace chip {
 
 class SerializableU64SetBase
@@ -78,13 +80,13 @@
      * @brief
      *   Get the length of string if the array is serialized.
      */
-    uint16_t SerializedSize() { return static_cast<uint16_t>(BASE64_ENCODED_LEN(sizeof(uint64_t) * mNextAvailable)); }
+    uint16_t SerializedSize() { return CHIP_MAX_SERIALIZED_SIZE_U64(mNextAvailable); }
 
     /**
      * @brief
      *   Get the maximum length of string if the array were full and serialized.
      */
-    uint16_t MaxSerializedSize() { return static_cast<uint16_t>(BASE64_ENCODED_LEN(sizeof(uint64_t) * mCapacity)); }
+    uint16_t MaxSerializedSize() { return CHIP_MAX_SERIALIZED_SIZE_U64(mCapacity); }
 
     /**
      * @brief
diff --git a/src/transport/RendezvousSession.cpp b/src/transport/RendezvousSession.cpp
index 838d4d0..8e66d74 100644
--- a/src/transport/RendezvousSession.cpp
+++ b/src/transport/RendezvousSession.cpp
@@ -213,19 +213,33 @@
         break;
     };
     mDelegate->OnRendezvousError(err);
-    UpdateState(State::kInit);
+    UpdateState(State::kInit, err);
 }
 
-void RendezvousSession::UpdateState(RendezvousSession::State newState)
+void RendezvousSession::UpdateState(RendezvousSession::State newState, CHIP_ERROR err)
 {
     switch (mCurrentState)
     {
     case State::kSecurePairing:
-        mDelegate->OnRendezvousStatusUpdate(RendezvousSessionDelegate::SecurePairingSuccess, CHIP_NO_ERROR);
+        if (newState != State::kInit)
+        {
+            mDelegate->OnRendezvousStatusUpdate(RendezvousSessionDelegate::SecurePairingSuccess, err);
+        }
+        else
+        {
+            mDelegate->OnRendezvousStatusUpdate(RendezvousSessionDelegate::SecurePairingFailed, err);
+        }
         break;
 
     case State::kNetworkProvisioning:
-        mDelegate->OnRendezvousStatusUpdate(RendezvousSessionDelegate::NetworkProvisioningSuccess, CHIP_NO_ERROR);
+        if (newState != State::kInit)
+        {
+            mDelegate->OnRendezvousStatusUpdate(RendezvousSessionDelegate::NetworkProvisioningSuccess, err);
+        }
+        else
+        {
+            mDelegate->OnRendezvousStatusUpdate(RendezvousSessionDelegate::NetworkProvisioningFailed, err);
+        }
         break;
 
     default:
diff --git a/src/transport/RendezvousSession.h b/src/transport/RendezvousSession.h
index 3a0b718..ed0415f 100644
--- a/src/transport/RendezvousSession.h
+++ b/src/transport/RendezvousSession.h
@@ -138,7 +138,7 @@
     uint16_t mNextKeyId          = 0;
 
     RendezvousSession::State mCurrentState = State::kInit;
-    void UpdateState(RendezvousSession::State newState);
+    void UpdateState(RendezvousSession::State newState, CHIP_ERROR err = CHIP_NO_ERROR);
 };
 
 } // namespace chip
diff --git a/src/transport/SecurePairingSession.cpp b/src/transport/SecurePairingSession.cpp
index 61335c1..780654b 100644
--- a/src/transport/SecurePairingSession.cpp
+++ b/src/transport/SecurePairingSession.cpp
@@ -57,37 +57,20 @@
 
 CHIP_ERROR SecurePairingSession::Serialize(SecurePairingSessionSerialized & output)
 {
-    CHIP_ERROR error = CHIP_NO_ERROR;
+    CHIP_ERROR error       = CHIP_NO_ERROR;
+    uint16_t serializedLen = 0;
+    SecurePairingSessionSerializable serializable;
 
-    const NodeId localNodeId = (mLocalNodeId.HasValue()) ? mLocalNodeId.Value() : kUndefinedNodeId;
-    const NodeId peerNodeId  = (mPeerNodeId.HasValue()) ? mPeerNodeId.Value() : kUndefinedNodeId;
-    VerifyOrExit(CanCastTo<uint16_t>(mKeLen), error = CHIP_ERROR_INTERNAL);
-    VerifyOrExit(CanCastTo<uint64_t>(localNodeId), error = CHIP_ERROR_INTERNAL);
-    VerifyOrExit(CanCastTo<uint64_t>(peerNodeId), error = CHIP_ERROR_INTERNAL);
-    VerifyOrExit(CanCastTo<uint16_t>(sizeof(SecurePairingSessionSerializable)), error = CHIP_ERROR_INTERNAL);
+    VerifyOrExit(BASE64_ENCODED_LEN(sizeof(serializable)) <= sizeof(output.inner), error = CHIP_ERROR_INVALID_ARGUMENT);
 
-    {
-        SecurePairingSessionSerializable serializable;
-        memset(&serializable, 0, sizeof(serializable));
-        serializable.mKeLen           = static_cast<uint16_t>(mKeLen);
-        serializable.mPairingComplete = (mPairingComplete) ? 1 : 0;
-        serializable.mLocalNodeId     = localNodeId;
-        serializable.mPeerNodeId      = peerNodeId;
-        serializable.mLocalKeyId      = mLocalKeyId;
-        serializable.mPeerKeyId       = mPeerKeyId;
+    error = ToSerializable(serializable);
+    SuccessOrExit(error);
 
-        memcpy(serializable.mKe, mKe, mKeLen);
-
-        uint16_t serializedLen = 0;
-
-        VerifyOrExit(BASE64_ENCODED_LEN(sizeof(serializable)) <= sizeof(output.inner), error = CHIP_ERROR_INVALID_ARGUMENT);
-
-        serializedLen = chip::Base64Encode(Uint8::to_const_uchar(reinterpret_cast<uint8_t *>(&serializable)),
-                                           static_cast<uint16_t>(sizeof(serializable)), Uint8::to_char(output.inner));
-        VerifyOrExit(serializedLen > 0, error = CHIP_ERROR_INVALID_ARGUMENT);
-        VerifyOrExit(serializedLen < sizeof(output.inner), error = CHIP_ERROR_INVALID_ARGUMENT);
-        output.inner[serializedLen] = '\0';
-    }
+    serializedLen = chip::Base64Encode(Uint8::to_const_uchar(reinterpret_cast<uint8_t *>(&serializable)),
+                                       static_cast<uint16_t>(sizeof(serializable)), Uint8::to_char(output.inner));
+    VerifyOrExit(serializedLen > 0, error = CHIP_ERROR_INVALID_ARGUMENT);
+    VerifyOrExit(serializedLen < sizeof(output.inner), error = CHIP_ERROR_INVALID_ARGUMENT);
+    output.inner[serializedLen] = '\0';
 
 exit:
     return error;
@@ -107,9 +90,44 @@
     memset(&serializable, 0, sizeof(serializable));
     deserializedLen =
         Base64Decode(Uint8::to_const_char(input.inner), static_cast<uint16_t>(len), Uint8::to_uchar((uint8_t *) &serializable));
+
     VerifyOrExit(deserializedLen > 0, error = CHIP_ERROR_INVALID_ARGUMENT);
     VerifyOrExit(deserializedLen <= sizeof(serializable), error = CHIP_ERROR_INVALID_ARGUMENT);
 
+    error = FromSerializable(serializable);
+
+exit:
+    return error;
+}
+
+CHIP_ERROR SecurePairingSession::ToSerializable(SecurePairingSessionSerializable & serializable)
+{
+    CHIP_ERROR error = CHIP_NO_ERROR;
+
+    const NodeId localNodeId = (mLocalNodeId.HasValue()) ? mLocalNodeId.Value() : kUndefinedNodeId;
+    const NodeId peerNodeId  = (mPeerNodeId.HasValue()) ? mPeerNodeId.Value() : kUndefinedNodeId;
+    VerifyOrExit(CanCastTo<uint16_t>(mKeLen), error = CHIP_ERROR_INTERNAL);
+    VerifyOrExit(CanCastTo<uint64_t>(localNodeId), error = CHIP_ERROR_INTERNAL);
+    VerifyOrExit(CanCastTo<uint64_t>(peerNodeId), error = CHIP_ERROR_INTERNAL);
+
+    memset(&serializable, 0, sizeof(serializable));
+    serializable.mKeLen           = static_cast<uint16_t>(mKeLen);
+    serializable.mPairingComplete = (mPairingComplete) ? 1 : 0;
+    serializable.mLocalNodeId     = localNodeId;
+    serializable.mPeerNodeId      = peerNodeId;
+    serializable.mLocalKeyId      = mLocalKeyId;
+    serializable.mPeerKeyId       = mPeerKeyId;
+
+    memcpy(serializable.mKe, mKe, mKeLen);
+
+exit:
+    return error;
+}
+
+CHIP_ERROR SecurePairingSession::FromSerializable(const SecurePairingSessionSerializable & serializable)
+{
+    CHIP_ERROR error = CHIP_NO_ERROR;
+
     mPairingComplete = (serializable.mPairingComplete == 1);
     mKeLen           = static_cast<size_t>(serializable.mKeLen);
 
diff --git a/src/transport/SecurePairingSession.h b/src/transport/SecurePairingSession.h
index dfe3857..d811c2e 100644
--- a/src/transport/SecurePairingSession.h
+++ b/src/transport/SecurePairingSession.h
@@ -74,6 +74,17 @@
 
 struct SecurePairingSessionSerialized;
 
+struct SecurePairingSessionSerializable
+{
+    uint16_t mKeLen;
+    uint8_t mKe[kMAX_Hash_Length];
+    uint8_t mPairingComplete;
+    uint64_t mLocalNodeId;
+    uint64_t mPeerNodeId;
+    uint16_t mLocalKeyId;
+    uint16_t mPeerKeyId;
+};
+
 class DLL_EXPORT SecurePairingSession
 {
 public:
@@ -178,6 +189,18 @@
      **/
     CHIP_ERROR Deserialize(SecurePairingSessionSerialized & input);
 
+    /** @brief Serialize the SecurePairingSession to the given serializable data structure for secure pairing
+     *
+     * @return Returns a CHIP_ERROR on error, CHIP_NO_ERROR otherwise
+     **/
+    CHIP_ERROR ToSerializable(SecurePairingSessionSerializable & output);
+
+    /** @brief Reconstruct secure pairing class from the serializable data structure.
+     *
+     * @return Returns a CHIP_ERROR on error, CHIP_NO_ERROR otherwise
+     **/
+    CHIP_ERROR FromSerializable(const SecurePairingSessionSerializable & output);
+
 private:
     CHIP_ERROR Init(uint32_t setupCode, uint32_t pbkdf2IterCount, const uint8_t * salt, size_t saltLen, Optional<NodeId> myNodeId,
                     uint16_t myKeyId, SecurePairingSessionDelegate * delegate);
@@ -209,12 +232,6 @@
     /* w0s and w1s */
     uint8_t mWS[2][kSpake2p_WS_Length];
 
-    uint8_t mKe[kMAX_Hash_Length];
-
-    size_t mKeLen = sizeof(mKe);
-
-    bool mPairingComplete = false;
-
 protected:
     Optional<NodeId> mLocalNodeId = Optional<NodeId>::Value(kUndefinedNodeId);
 
@@ -223,6 +240,12 @@
     uint16_t mLocalKeyId;
 
     uint16_t mPeerKeyId;
+
+    uint8_t mKe[kMAX_Hash_Length];
+
+    size_t mKeLen = sizeof(mKe);
+
+    bool mPairingComplete = false;
 };
 
 /*
@@ -234,12 +257,25 @@
 class SecurePairingUsingTestSecret : public SecurePairingSession
 {
 public:
-    SecurePairingUsingTestSecret() {}
+    SecurePairingUsingTestSecret()
+    {
+        const char * secret = "Test secret for key derivation";
+        size_t secretLen    = strlen(secret);
+        mKeLen              = secretLen;
+        memmove(mKe, secret, mKeLen);
+        mPairingComplete = true;
+    }
+
     SecurePairingUsingTestSecret(Optional<NodeId> peerNodeId, uint16_t peerKeyId, uint16_t localKeyId)
     {
-        mPeerNodeId = peerNodeId;
-        mPeerKeyId  = peerKeyId;
-        mLocalKeyId = localKeyId;
+        const char * secret = "Test secret for key derivation";
+        size_t secretLen    = strlen(secret);
+        mPeerNodeId         = peerNodeId;
+        mPeerKeyId          = peerKeyId;
+        mLocalKeyId         = localKeyId;
+        mKeLen              = secretLen;
+        memmove(mKe, secret, mKeLen);
+        mPairingComplete = true;
     }
 
     ~SecurePairingUsingTestSecret() override {}
@@ -256,28 +292,9 @@
         return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR DeriveSecureSession(const uint8_t * info, size_t info_len, SecureSession & session) override
-    {
-        const char * secret = "Test secret for key derivation";
-        size_t secretLen    = strlen(secret);
-        return session.InitFromSecret(reinterpret_cast<const uint8_t *>(secret), secretLen, reinterpret_cast<const uint8_t *>(""),
-                                      0, reinterpret_cast<const uint8_t *>(secret), secretLen);
-    }
-
     CHIP_ERROR HandlePeerMessage(const PacketHeader & packetHeader, System::PacketBuffer * msg) override { return CHIP_NO_ERROR; }
 };
 
-typedef struct SecurePairingSessionSerializable
-{
-    uint16_t mKeLen;
-    uint8_t mKe[kMAX_Hash_Length];
-    uint8_t mPairingComplete;
-    uint64_t mLocalNodeId;
-    uint64_t mPeerNodeId;
-    uint16_t mLocalKeyId;
-    uint16_t mPeerKeyId;
-} SecurePairingSessionSerializable;
-
 typedef struct SecurePairingSessionSerialized
 {
     // Extra uint64_t to account for padding bytes (NULL termination, and some decoding overheads)
diff --git a/src/transport/SecureSessionMgr.cpp b/src/transport/SecureSessionMgr.cpp
index 4e41dc4..a8dea8e 100644
--- a/src/transport/SecureSessionMgr.cpp
+++ b/src/transport/SecureSessionMgr.cpp
@@ -65,6 +65,8 @@
     mSystemLayer = systemLayer;
     mTransport   = transport;
 
+    ChipLogProgress(Inet, "local node id is %llu\n", mLocalNodeId);
+
     mTransport->SetMessageReceiveHandler(HandleDataReceived, this);
     mPeerConnections.SetConnectionExpiredHandler(HandleConnectionExpired, this);
 
@@ -124,6 +126,8 @@
             .SetEncryptionKeyID(state->GetLocalKeyID()) //
             .SetPayloadLength(static_cast<uint16_t>(payloadLength));
 
+        ChipLogProgress(Inet, "Sending msg from %llu to %llu\n", mLocalNodeId, peerNodeId);
+
         VerifyOrExit(msgBuf->EnsureReservedSize(headerSize), err = CHIP_ERROR_NO_MEMORY);
 
         msgBuf->SetStart(msgBuf->Start() - headerSize);
diff --git a/src/transport/SecureSessionMgr.h b/src/transport/SecureSessionMgr.h
index ac66baf..5536715 100644
--- a/src/transport/SecureSessionMgr.h
+++ b/src/transport/SecureSessionMgr.h
@@ -224,6 +224,12 @@
         return err;
     }
 
+    template <typename... Args>
+    CHIP_ERROR ResetTransport(Args &&... transportInitArgs)
+    {
+        return mTransport.Init(std::forward<Args>(transportInitArgs)...);
+    }
+
 private:
     Transport::Tuple<TransportTypes...> mTransport;
 };
diff --git a/src/transport/raw/Base.h b/src/transport/raw/Base.h
index fe1dc4f..f374bff 100644
--- a/src/transport/raw/Base.h
+++ b/src/transport/raw/Base.h
@@ -82,6 +82,11 @@
      */
     virtual void Disconnect(const PeerAddress & address) {}
 
+    /**
+     * Close the open endpoint without destroying the object
+     */
+    virtual void Close(){};
+
 protected:
     /**
      * Method used by subclasses to notify that a packet has been received after
diff --git a/src/transport/raw/UDP.cpp b/src/transport/raw/UDP.cpp
index ce065b6..aa5621a 100644
--- a/src/transport/raw/UDP.cpp
+++ b/src/transport/raw/UDP.cpp
@@ -34,20 +34,17 @@
 
 UDP::~UDP()
 {
-    if (mUDPEndPoint)
-    {
-        // Udp endpoint is only non null if udp endpoint is initialized and listening
-        mUDPEndPoint->Close();
-        mUDPEndPoint->Free();
-        mUDPEndPoint = nullptr;
-    }
+    Close();
 }
 
 CHIP_ERROR UDP::Init(UdpListenParameters & params)
 {
     CHIP_ERROR err = CHIP_NO_ERROR;
 
-    VerifyOrExit(mState == State::kNotReady, err = CHIP_ERROR_INCORRECT_STATE);
+    if (mState != State::kNotReady)
+    {
+        Close();
+    }
 
     err = params.GetInetLayer()->NewUDPEndPoint(&mUDPEndPoint);
     SuccessOrExit(err);
@@ -78,6 +75,18 @@
     return err;
 }
 
+void UDP::Close()
+{
+    if (mUDPEndPoint)
+    {
+        // Udp endpoint is only non null if udp endpoint is initialized and listening
+        mUDPEndPoint->Close();
+        mUDPEndPoint->Free();
+        mUDPEndPoint = nullptr;
+    }
+    mState = State::kNotReady;
+}
+
 CHIP_ERROR UDP::SendMessage(const PacketHeader & header, Header::Flags payloadFlags, const Transport::PeerAddress & address,
                             System::PacketBuffer * msgBuf)
 {
diff --git a/src/transport/raw/UDP.h b/src/transport/raw/UDP.h
index d2dfcc3..2cfbf76 100644
--- a/src/transport/raw/UDP.h
+++ b/src/transport/raw/UDP.h
@@ -105,6 +105,11 @@
      */
     CHIP_ERROR Init(UdpListenParameters & params);
 
+    /**
+     * Close the open endpoint without destroying the object
+     */
+    void Close() override;
+
     CHIP_ERROR SendMessage(const PacketHeader & header, Header::Flags payloadFlags, const Transport::PeerAddress & address,
                            System::PacketBuffer * msgBuf) override;