[PowerTopology] Add ElectricalCircuit (CIRC) feature and ElectricalCircuitNodes attribute (project-chip#73402)

* [PowerTopology] Add ElectricalCircuit (CIRC) feature + ElectricalCircuitNodes

Add the Matter 1.7 ElectricalCircuit (CIRC) feature to the code-driven
power-topology-server, exposing the ElectricalCircuitNodes attribute
(0x0002): a fabric-scoped, writable, non-volatile List<CircuitNodeStruct>.

- Read is fabric-filtered automatically (fabric-scoped item type).
- Write is fabric-scoped: the accessing fabric is authoritative, ReplaceAll
  replaces only that fabric's slice with full staging/validation before any
  mutation, AppendItem appends one node.
- Non-volatile persistence via an explicit TLV blob (retaining fabricIndex,
  which the generated fabric-scoped write codec omits), restored on Startup.
- Fabric removal purges the removed fabric's nodes via FabricTable::Delegate;
  the FabricTable is an optional nullable field on the cluster Config.

Enable CIRC on the EVSE example app and thread the FabricTable through
PtConfig so fabric-removal cleanup is active. The added FabricTable
parameters are defaulted, so the water-heater app (which shares
ElectricalSensorManager) is unaffected.

Extend TC_PWRTL_2_1 to assert ElectricalCircuitNodes present iff CIRC and to
read, write (round-trip), and verify Non-volatile persistence of the
attribute.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* [PowerTopology] Scope TC_PWRTL_2_1 CIRC change to attribute presence

Keep only the AttributeList presence-iff-CIRC assertion for
ElectricalCircuitNodes in TC_PWRTL_2_1 (the attributes test). Functional
read/write coverage of the attribute belongs to the dedicated TC_PWRTL_2_2,
which this PR's CIRC-enabled DUT unblocks; avoid duplicating it here.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* [PowerTopology] Heap-allocate ElectricalCircuitNodes write staging buffer

WriteElectricalCircuitNodes staged the incoming list in a stack array of
kMaxCircuitNodes StoredCircuitNode entries (~8 KB), which can overflow the
constrained Matter thread stack on embedded platforms. Allocate the staging
buffer on the heap via ScopedMemoryBuffer, sized to the incoming count.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* [PowerTopology] Heap-allocate ElectricalCircuitNodes node storage

The ElectricalCircuitNodes storage was an inline StoredCircuitNode array of
kMaxCircuitNodes entries (~8 KB: char label[128] x 50). As a member this
made every stack-allocated PowerTopologyCluster instance ~8 KB, exceeding
the -Wstack-usage=8192 limit on 32-bit embedded builds (Zephyr/ESP32) in
the unit tests, and inflating the cluster's footprint on constrained
platforms generally.

Store the nodes in a ScopedMemoryBuffer allocated on Startup, only when the
CIRC feature is enabled.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* [PowerTopology] Move ElectricalCircuitNodes storage behind an interface

Review feedback: the cluster should not hard-code how ElectricalCircuitNodes is
stored, and holding the entries in a heap buffer rules out platforms with
stricter memory requirements.

Following thread-network-directory-server, which solves the same problem for a
writable persisted list:

- CircuitNodeStorage is an abstract interface: Capacity(), Count(),
  CountForFabric(), GetNodeAtIndex(), ReplaceNodesForFabric() for the ReplaceAll
  write, AppendNode() for AppendItem, and RemoveNodesForFabric() for fabric
  purge.
- DefaultCircuitNodeStorage implements it against the cluster's attribute
  storage, carrying over the previous TLV format unchanged, so existing
  behaviour (durable nodes, same location) is preserved with no application
  work.
- The cluster holds only a CircuitNodeStorage pointer and allocates nothing for
  this attribute. StoredCircuitNode, the ScopedMemoryBuffer member, and
  SaveCircuitNodes()/LoadCircuitNodes() are gone.

A platform without a heap now supplies a fixed-array implementation and reports
its real limit through Capacity(). The unit tests do exactly that, so the
allocation-free path is exercised rather than merely possible.

CircuitNodeStorage::Init() is a no-op by default and exists so an implementation
that persists through the cluster's attribute storage can obtain it at cluster
Startup, which is the earliest point it exists. Implementations with their own
persistence ignore it.

PowerTopology::Instance gains an overload taking application-provided storage;
the existing constructor keeps using DefaultCircuitNodeStorage, so applications
need no change.

Load() stops at Capacity() rather than erroring, so reducing a platform's
capacity cannot prevent startup on previously persisted data.

Testing: unit tests pass (22 cases, up from 21). The added
DefaultCircuitNodeStoragePersistsAcrossInstances covers the TLV round trip that
previously ran through the cluster, since the cluster-level tests now use the
non-persisting fixed-array storage. all-clusters-app builds and links.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* [PowerTopology] Shrink the fixed-array test storage to fit the Zephyr stack budget

The FixedCircuitNodeStorage test double held Node[50], roughly 8 KB, and the
tests place it on the stack. That tripped -Werror=stack-usage=8192 on the Zephyr
native_posix unit-test build (worst case 12112 bytes), breaking the nRF Connect
SDK and ESP32_QEMU checks.

Make the capacity a template parameter defaulting to 8 (about 1.3 KB), which
brings the worst case to roughly 5.4 KB. No test stores more than four entries,
and the resource-exhaustion test writes far past any capacity so it still
exercises the limit.

Fittingly, the double was failing the very constraint it exists to demonstrate.

Testing: unit tests pass (22 cases).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* [PowerTopology] Require the fabric table for CIRC; bound the ReplaceAll staging write

Two review findings on project-chip#73403, which carries this file until project-chip#73402 merges.

1. The ElectricalCircuit feature needs the fabric table, not "uses it if
   present". ElectricalCircuitNodes is fabric-scoped, so a removed fabric's
   entries must be purged, and that only happens through the OnFabricRemoved
   callback registered via AddFabricDelegate. Startup() previously skipped the
   registration silently when Config::fabricTable was null, and PowerTopology
   Instance defaults that parameter to nullptr, so an application could enable
   CIRC, compile cleanly, and leak a removed fabric's nodes with no diagnostic.

   Startup() now fails with CHIP_ERROR_INCORRECT_STATE and a log line, matching
   the Config::circuitNodeStorage check three lines above it. Returning an error
   is preferred over VerifyOrDie: Startup() already reports this class of
   misconfiguration through its return value, and a crash would be a harsher
   contract than the surrounding code uses. Shutdown() keeps its null check,
   since it can run on a cluster that never started or does not have CIRC.

   The unit tests construct CIRC clusters, so they now supply a fabric table via
   FabricTestFixture, as ElectricalCircuitNodesPurgedOnFabricRemovalTest already
   did. Added ElectricalCircuitWithoutFabricTableTest to pin the new contract.

2. WriteElectricalCircuitNodes staged the decoded ReplaceAll list into a buffer
   sized from list.ComputeSize() and indexed it with a counter driven by the
   iterator, without checking the two agree. Added a bounds check. Beyond
   decoder inconsistency this also covers newCount == 0, where the staging
   buffer is never allocated at all yet staging[0] would be written if the
   iterator yielded an element.

Testing: TestPowerTopologyCluster 23/23 pass (was 22, plus the new one) and
TestPowerTopologyClusterBackwardsCompatibility 1/1 passes, built natively with
chip_build_tests=true. Confirmed the new guard is actually exercised rather than
merely compiled: its error log appears exactly once across the suite, in the new
test. clang-format clean.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* [PowerTopology] Discard a partially decoded ElectricalCircuitNodes value

Load() appends entries as it decodes them, so a failure part way through a
stored blob left the decoded prefix in place. Init() logs that error and
returns CHIP_NO_ERROR, since a bad stored value must not brick startup, so the
cluster went on to serve an arbitrary fraction of a corrupt list as the
attribute value. Reset the count in that path so the list reads as empty
instead.

Also document the persisted blob's worst case size against the per-value
limits some platforms impose, and move the anonymous namespace close below the
final test so every fixture-derived test sits inside it.

* TC-PWRTL-2.1: align the script step list with the test plan

The script and the plan had drifted: the script combined the AttributeList
read and its composition check into one step, wrote to only one of the two
read-only attributes, and split the reboot and the persistence read across
two steps. Step n in the script and step n in the plan stopped describing
the same thing from step 5 onwards.

Both are now 11 steps and match one for one. The reboot step also moves to
request_device_reboot() with an app-ready-pattern directive, matching
TC-PWRTL-2.2, instead of the is_pics_sdk_ci_only and wait_for_user_input
dispatch, so it runs in CI rather than being skipped.

* [TC-PWRTL-2.1] Make the reserved-bits check effective

Step 4 is specified to validate the CIRC bit and reserved bits 5..31, but the
reserved-bits half was inert. PowerTopology.Feature is an IntFlag whose members
cover exactly bits 0..4, so `~KNOWN_BITS_MASK` complements only within the class
mask and evaluates to 0. `reserved_bits` was therefore unconditionally 0 and a
DUT setting any reserved bit passed.

Casting both operands to int restores the full-width complement.

* Drop the step-numbering remark from the TC-PWRTL-2.1 docstring

It describes the file rather than the test, and goes stale the moment the
plan renumbers.

* Drop the unsupported-write step from TC-PWRTL-2.1

Per James Harrow: unsupported-write checks come out, since the IDM and
low-level SDK tests already cover write access. Step 11 becomes step 10; the
Status import goes with the last use.

* Align TC-PWRTL-2.1 with its test plan

Per James Harrow: align the script to the plan, and pre-existing lines are not
exempt. The merged TC-PWRTL-2.1 plan has three steps; the script had eleven.

It is now the plan's three, each carrying the plan's expected outcome as an
expectation. Implementing the plan literally also adds an assertion the script
never had: the plan requires both endpoint lists to hold no more than 20
entries, and nothing checked that.

Removed: FeatureMap O.a conformance, the CIRC and reserved-bit checks, and the
AttributeList composition checks, all covered by TC_IDM_10_2 per cecille, which
is why the plan rework (chip-test-plans#6166) and its script alignment (project-chip#73732)
were closed on 2026-08-28. Also removed the Non-Volatile persistence check,
which the plan does not describe.

* Drop the plan URL from the TC-PWRTL-2.1 docstring

Only 16 of 501 scripts on master embed one, and a hardcoded branch-and-anchor
link goes stale on any renumber.

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: 3 people

examples/energy-management/electrical-sensor/include/ElectricalSensorManager.h

@@ -59,6 +59,9 @@ class ElectricalSensorManager
     struct PtConfig
     {
         BitMask<PowerTopology::Feature> features;
+        // Optional: pass the fabric table when the CIRC feature is enabled so the Power Topology
+        // cluster can purge a removed fabric's ElectricalCircuitNodes entries. Null otherwise.
+        FabricTable * fabricTable = nullptr;
     };
 
     CHIP_ERROR Init(EndpointId endpointId, const EpmConfig & epmConfig, const EemConfig & eemConfig, const PtConfig & ptConfig);

examples/energy-management/electrical-sensor/include/PowerTopologyDelegateImpl.h

@@ -20,6 +20,7 @@
 #include <app/clusters/power-topology-server/power-topology-server.h>
 
 #include <app/util/af-types.h>
+#include <credentials/FabricTable.h>
 #include <lib/core/CHIPError.h>
 
 namespace chip {
@@ -39,8 +40,9 @@ class PowerTopologyDelegate : public Delegate
 class PowerTopologyInstance : public Instance
 {
 public:
-    PowerTopologyInstance(EndpointId aEndpointId, PowerTopologyDelegate & aDelegate, BitMask<Feature> aFeature) :
-        PowerTopology::Instance(aEndpointId, aDelegate, aFeature)
+    PowerTopologyInstance(EndpointId aEndpointId, PowerTopologyDelegate & aDelegate, BitMask<Feature> aFeature,
+                          FabricTable * aFabricTable = nullptr) :
+        PowerTopology::Instance(aEndpointId, aDelegate, aFeature, aFabricTable)
     {
         mDelegate = &aDelegate;
     }
@@ -70,7 +72,8 @@ class PowerTopologyInstance : public Instance
  * @return CHIP_NO_ERROR if the PowerTopology cluster is initialized successfully, otherwise an error code
  */
 CHIP_ERROR PowerTopologyInit(chip::EndpointId endpointId, std::unique_ptr<PowerTopologyDelegate> & aDelegate,
-                             std::unique_ptr<PowerTopologyInstance> & aInstance, BitMask<Feature> aFeature);
+                             std::unique_ptr<PowerTopologyInstance> & aInstance, BitMask<Feature> aFeature,
+                             FabricTable * aFabricTable = nullptr);
 
 CHIP_ERROR PowerTopologyShutdown(std::unique_ptr<PowerTopologyInstance> & aInstance,
                                  std::unique_ptr<PowerTopologyDelegate> & aDelegate);

examples/energy-management/electrical-sensor/src/ElectricalSensorManager.cpp

@@ -49,7 +49,8 @@ CHIP_ERROR ElectricalSensorManager::Init(EndpointId endpointId, const EpmConfig
     SuccessOrShutdown(CodegenDataModelProvider::Instance().Registry().Register(mEEMCluster->Registration()));
 
     // --- Initialize Power Topology ---
-    SuccessOrShutdown(PowerTopology::PowerTopologyInit(endpointId, mPTDelegate, mPTInstance, ptConfig.features));
+    SuccessOrShutdown(
+        PowerTopology::PowerTopologyInit(endpointId, mPTDelegate, mPTInstance, ptConfig.features, ptConfig.fabricTable));
 
     return CHIP_NO_ERROR;
 }

examples/energy-management/electrical-sensor/src/PowerTopologyDelegateImpl.cpp

@@ -51,7 +51,8 @@ void PowerTopologyInstance::Shutdown()
  * Then call the Instance->Init() to register the attribute and command handlers
  */
 CHIP_ERROR PowerTopologyInit(chip::EndpointId endpointId, std::unique_ptr<PowerTopologyDelegate> & aDelegate,
-                             std::unique_ptr<PowerTopologyInstance> & aInstance, BitMask<Feature> aFeature)
+                             std::unique_ptr<PowerTopologyInstance> & aInstance, BitMask<Feature> aFeature,
+                             FabricTable * aFabricTable)
 {
     CHIP_ERROR err;
 
@@ -68,7 +69,7 @@ CHIP_ERROR PowerTopologyInit(chip::EndpointId endpointId, std::unique_ptr<PowerT
         return CHIP_ERROR_NO_MEMORY;
     }
 
-    aInstance = std::make_unique<PowerTopologyInstance>(EndpointId(endpointId), *aDelegate, aFeature);
+    aInstance = std::make_unique<PowerTopologyInstance>(EndpointId(endpointId), *aDelegate, aFeature, aFabricTable);
 
     if (!aInstance)
     {

examples/evse-app/evse-common/src/EnergyEvseMain.cpp

@@ -252,7 +252,9 @@ CHIP_ERROR EnergyManagementCommonClustersInit(chip::EndpointId endpointId)
         };
 
         ElectricalSensorManager::PtConfig ptConfig{
-            .features = BitMask<PowerTopology::Feature, uint32_t>(PowerTopology::Feature::kNodeTopology),
+            .features    = BitMask<PowerTopology::Feature, uint32_t>(PowerTopology::Feature::kNodeTopology,
+                                                                  PowerTopology::Feature::kElectricalCircuit),
+            .fabricTable = &Server::GetInstance().GetFabricTable(),
         };
 
         ReturnErrorOnFailure(gESManager->Init(endpointId, epmConfig, eemConfig, ptConfig));

src/app/clusters/power-topology-server/BUILD.gn

@@ -16,6 +16,9 @@ import("//build_overrides/chip.gni")
 
 source_set("power-topology-server") {
   sources = [
+    "DefaultPowerTopologyCircuitNodeStorage.cpp",
+    "DefaultPowerTopologyCircuitNodeStorage.h",
+    "PowerTopologyCircuitNodeStorage.h",
     "PowerTopologyCluster.cpp",
     "PowerTopologyCluster.h",
     "PowerTopologyDelegate.h",

src/app/clusters/power-topology-server/CodegenIntegration.h

@@ -17,6 +17,7 @@
  */
 #pragma once
 
+#include <app/clusters/power-topology-server/DefaultPowerTopologyCircuitNodeStorage.h>
 #include <app/clusters/power-topology-server/PowerTopologyCluster.h>
 #include <app/clusters/power-topology-server/PowerTopologyDelegate.h>
 
@@ -31,19 +32,42 @@ namespace PowerTopology {
 class Instance
 {
 public:
-    Instance(EndpointId aEndpointId, Delegate & aDelegate, BitMask<Feature> aFeature) :
+    /// Uses DefaultCircuitNodeStorage for the ElectricalCircuitNodes attribute, so an application
+    /// enabling the ElectricalCircuit feature gets persistence with no extra work. An application
+    /// that cannot allocate, or that wants its own persistence, should use the overload below.
+    Instance(EndpointId aEndpointId, Delegate & aDelegate, BitMask<Feature> aFeature, FabricTable * aFabricTable = nullptr) :
         mCluster(PowerTopologyCluster::Config{
-            .endpointId = aEndpointId,
-            .delegate   = aDelegate,
-            .features   = aFeature,
+            .endpointId         = aEndpointId,
+            .delegate           = aDelegate,
+            .features           = aFeature,
+            .fabricTable        = aFabricTable,
+            .circuitNodeStorage = &mDefaultCircuitNodeStorage,
         })
     {}
+
+    /// Uses application-provided storage for ElectricalCircuitNodes. `aCircuitNodeStorage` must
+    /// outlive this Instance.
+    Instance(EndpointId aEndpointId, Delegate & aDelegate, BitMask<Feature> aFeature, CircuitNodeStorage & aCircuitNodeStorage,
+             FabricTable * aFabricTable = nullptr) :
+        mCluster(PowerTopologyCluster::Config{
+            .endpointId         = aEndpointId,
+            .delegate           = aDelegate,
+            .features           = aFeature,
+            .fabricTable        = aFabricTable,
+            .circuitNodeStorage = &aCircuitNodeStorage,
+        })
+    {}
+
     ~Instance() { Shutdown(); }
 
     CHIP_ERROR Init();
     void Shutdown();
 
 private:
+    // Only used by the first constructor; harmless (and unallocated) otherwise, since
+    // DefaultCircuitNodeStorage allocates nothing until Init() and the cluster only calls Init()
+    // when the ElectricalCircuit feature is enabled.
+    DefaultCircuitNodeStorage mDefaultCircuitNodeStorage;
     RegisteredServerCluster<PowerTopologyCluster> mCluster;
 };
 

src/app/clusters/power-topology-server/DefaultPowerTopologyCircuitNodeStorage.cpp

@@ -0,0 +1,249 @@
+/*
+ *
+ *    Copyright (c) 2026 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.
+ */
+
+#include <app/clusters/power-topology-server/DefaultPowerTopologyCircuitNodeStorage.h>
+
+#include <clusters/PowerTopology/AttributeIds.h>
+#include <clusters/PowerTopology/ClusterId.h>
+#include <lib/core/TLV.h>
+#include <lib/support/CodeUtils.h>
+#include <lib/support/logging/CHIPLogging.h>
+
+#include <cstring>
+
+namespace chip {
+namespace app {
+namespace Clusters {
+namespace PowerTopology {
+
+namespace {
+
+// TLV tags for the persisted ElectricalCircuitNodes blob. This is a private storage format, not the
+// wire encoding: the CircuitNodeStruct wire codec is fabric-aware and omits the fabric index on
+// write, so persistence uses an explicit format that retains every field including fabricIndex.
+constexpr TLV::Tag kTagFabricIndex = TLV::ContextTag(0);
+constexpr TLV::Tag kTagNode        = TLV::ContextTag(1);
+constexpr TLV::Tag kTagEndpoint    = TLV::ContextTag(2);
+constexpr TLV::Tag kTagLabel       = TLV::ContextTag(3);
+
+// Worst case ~ kMaxCircuitNodes * (node + endpoint + label + fabricIndex + TLV overhead).
+constexpr size_t kCircuitNodesBlobSize = CircuitNodeStorage::kMaxCircuitNodes * (CircuitNodeStorage::kMaxNodeLabelLength + 32) + 8;
+
+ConcreteAttributePath CircuitNodesPath(EndpointId endpointId)
+{
+    return ConcreteAttributePath(endpointId, PowerTopology::Id, Attributes::ElectricalCircuitNodes::Id);
+}
+
+} // namespace
+
+CHIP_ERROR DefaultCircuitNodeStorage::Init(AttributePersistenceProvider & attributeStorage, EndpointId endpointId)
+{
+    VerifyOrReturnError(mNodes.Alloc(kMaxCircuitNodes), CHIP_ERROR_NO_MEMORY);
+
+    mAttributeStorage = &attributeStorage;
+    mEndpointId       = endpointId;
+    mCount            = 0;
+
+    // A missing value is normal on first boot and must not fail startup.
+    CHIP_ERROR err = Load();
+    if (err != CHIP_NO_ERROR && err != CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND)
+    {
+        ChipLogError(Zcl, "PowerTopology: failed to load ElectricalCircuitNodes: %" CHIP_ERROR_FORMAT, err.Format());
+        // Load() appends as it decodes, so a failure part way through leaves a
+        // truncated prefix of a corrupt blob behind. Startup still proceeds, but
+        // report an empty list rather than an arbitrary fraction of the stored one.
+        mCount = 0;
+    }
+    return CHIP_NO_ERROR;
+}
+
+size_t DefaultCircuitNodeStorage::CountForFabric(FabricIndex fabricIndex) const
+{
+    size_t count = 0;
+    for (size_t i = 0; i < mCount; i++)
+    {
+        if (mNodes[i].fabricIndex == fabricIndex)
+        {
+            count++;
+        }
+    }
+    return count;
+}
+
+CHIP_ERROR DefaultCircuitNodeStorage::GetNodeAtIndex(size_t index, Node & outNode) const
+{
+    VerifyOrReturnError(index < mCount, CHIP_ERROR_INVALID_ARGUMENT);
+    outNode = mNodes[index];
+    return CHIP_NO_ERROR;
+}
+
+size_t DefaultCircuitNodeStorage::EraseFabric(FabricIndex fabricIndex)
+{
+    size_t kept = 0;
+    for (size_t i = 0; i < mCount; i++)
+    {
+        if (mNodes[i].fabricIndex != fabricIndex)
+        {
+            if (kept != i)
+            {
+                mNodes[kept] = mNodes[i];
+            }
+            kept++;
+        }
+    }
+    const size_t removed = mCount - kept;
+    mCount               = kept;
+    return removed;
+}
+
+CHIP_ERROR DefaultCircuitNodeStorage::ReplaceNodesForFabric(FabricIndex fabricIndex, const Node * nodes, size_t count)
+{
+    VerifyOrReturnError(mAttributeStorage != nullptr, CHIP_ERROR_INCORRECT_STATE);
+    VerifyOrReturnError(count == 0 || nodes != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
+
+    // Check capacity before mutating anything: on failure the stored contents must be unchanged.
+    const size_t otherFabricCount = mCount - CountForFabric(fabricIndex);
+    VerifyOrReturnError(otherFabricCount + count <= Capacity(), CHIP_ERROR_NO_MEMORY);
+
+    EraseFabric(fabricIndex);
+    for (size_t i = 0; i < count; i++)
+    {
+        mNodes[mCount++] = nodes[i];
+    }
+    return Save();
+}
+
+CHIP_ERROR DefaultCircuitNodeStorage::AppendNode(const Node & node)
+{
+    VerifyOrReturnError(mAttributeStorage != nullptr, CHIP_ERROR_INCORRECT_STATE);
+    VerifyOrReturnError(mCount < Capacity(), CHIP_ERROR_NO_MEMORY);
+
+    mNodes[mCount++] = node;
+    return Save();
+}
+
+CHIP_ERROR DefaultCircuitNodeStorage::RemoveNodesForFabric(FabricIndex fabricIndex)
+{
+    VerifyOrReturnError(mAttributeStorage != nullptr, CHIP_ERROR_INCORRECT_STATE);
+
+    // Removing a fabric with no entries succeeds without a persist.
+    VerifyOrReturnValue(EraseFabric(fabricIndex) > 0, CHIP_NO_ERROR);
+    return Save();
+}
+
+CHIP_ERROR DefaultCircuitNodeStorage::Save() const
+{
+    VerifyOrReturnError(mAttributeStorage != nullptr, CHIP_ERROR_INCORRECT_STATE);
+
+    Platform::ScopedMemoryBuffer<uint8_t> buffer;
+    VerifyOrReturnError(buffer.Calloc(kCircuitNodesBlobSize), CHIP_ERROR_NO_MEMORY);
+
+    TLV::TLVWriter writer;
+    writer.Init(buffer.Get(), kCircuitNodesBlobSize);
+    TLV::TLVType arrayContainer;
+    ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag(), TLV::kTLVType_Array, arrayContainer));
+    for (size_t i = 0; i < mCount; i++)
+    {
+        const Node & node = mNodes[i];
+        TLV::TLVType nodeContainer;
+        ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag(), TLV::kTLVType_Structure, nodeContainer));
+        ReturnErrorOnFailure(writer.Put(kTagFabricIndex, node.fabricIndex));
+        ReturnErrorOnFailure(writer.Put(kTagNode, node.node));
+        if (node.endpoint.HasValue())
+        {
+            ReturnErrorOnFailure(writer.Put(kTagEndpoint, node.endpoint.Value()));
+        }
+        if (node.hasLabel)
+        {
+            ReturnErrorOnFailure(writer.PutString(kTagLabel, CharSpan(node.label, node.labelLength)));
+        }
+        ReturnErrorOnFailure(writer.EndContainer(nodeContainer));
+    }
+    ReturnErrorOnFailure(writer.EndContainer(arrayContainer));
+    ReturnErrorOnFailure(writer.Finalize());
+
+    return mAttributeStorage->WriteValue(CircuitNodesPath(mEndpointId), ByteSpan(buffer.Get(), writer.GetLengthWritten()));
+}
+
+CHIP_ERROR DefaultCircuitNodeStorage::Load()
+{
+    VerifyOrReturnError(mAttributeStorage != nullptr, CHIP_ERROR_INCORRECT_STATE);
+
+    Platform::ScopedMemoryBuffer<uint8_t> buffer;
+    VerifyOrReturnError(buffer.Calloc(kCircuitNodesBlobSize), CHIP_ERROR_NO_MEMORY);
+
+    MutableByteSpan span(buffer.Get(), kCircuitNodesBlobSize);
+    ReturnErrorOnFailure(mAttributeStorage->ReadValue(CircuitNodesPath(mEndpointId), span));
+
+    TLV::TLVReader reader;
+    reader.Init(span);
+    ReturnErrorOnFailure(reader.Next(TLV::kTLVType_Array, TLV::AnonymousTag()));
+    TLV::TLVType arrayContainer;
+    ReturnErrorOnFailure(reader.EnterContainer(arrayContainer));
+
+    mCount = 0;
+    CHIP_ERROR err;
+    while ((err = reader.Next(TLV::kTLVType_Structure, TLV::AnonymousTag())) == CHIP_NO_ERROR)
+    {
+        // Silently stop at capacity rather than fail: a shrunk Capacity() must not brick startup.
+        VerifyOrReturnError(mCount < Capacity(), CHIP_NO_ERROR);
+
+        TLV::TLVType nodeContainer;
+        ReturnErrorOnFailure(reader.EnterContainer(nodeContainer));
+
+        Node node;
+        CHIP_ERROR fieldErr;
+        while ((fieldErr = reader.Next()) == CHIP_NO_ERROR)
+        {
+            if (reader.GetTag() == kTagFabricIndex)
+            {
+                ReturnErrorOnFailure(reader.Get(node.fabricIndex));
+            }
+            else if (reader.GetTag() == kTagNode)
+            {
+                ReturnErrorOnFailure(reader.Get(node.node));
+            }
+            else if (reader.GetTag() == kTagEndpoint)
+            {
+                EndpointId endpoint;
+                ReturnErrorOnFailure(reader.Get(endpoint));
+                node.endpoint.SetValue(endpoint);
+            }
+            else if (reader.GetTag() == kTagLabel)
+            {
+                CharSpan label;
+                ReturnErrorOnFailure(reader.Get(label));
+                VerifyOrReturnError(label.size() <= kMaxNodeLabelLength, CHIP_ERROR_INVALID_TLV_ELEMENT);
+                memcpy(node.label, label.data(), label.size());
+                node.labelLength = label.size();
+                node.hasLabel    = true;
+            }
+        }
+        VerifyOrReturnError(fieldErr == CHIP_END_OF_TLV, fieldErr);
+        ReturnErrorOnFailure(reader.ExitContainer(nodeContainer));
+
+        mNodes[mCount++] = node;
+    }
+    VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
+    return reader.ExitContainer(arrayContainer);
+}
+
+} // namespace PowerTopology
+} // namespace Clusters
+} // namespace app
+} // namespace chip