Renames to distinguish Tx and Store flag enums (#7098)

eddyashton · web-flow · commit 7efffaa011a9 · 2025-07-04T10:20:46.000Z
diff --git a/src/consensus/aft/test/logging_stub.h b/src/consensus/aft/test/logging_stub.h
@@ -461,12 +461,12 @@ namespace aft
         data, expected_txid, std::move(hooks));
     }
 
-    bool flag_enabled(ccf::kv::AbstractStore::Flag)
+    bool flag_enabled(ccf::kv::AbstractStore::StoreFlag)
     {
       return false;
     }
 
-    void unset_flag(ccf::kv::AbstractStore::Flag) {}
+    void unset_flag(ccf::kv::AbstractStore::StoreFlag) {}
   };
 
   class LoggingStubStoreConfig : public LoggingStubStore
diff --git a/src/kv/committable_tx.h b/src/kv/committable_tx.h
@@ -19,7 +19,7 @@ namespace ccf::kv
   public:
     using TxFlags = uint8_t;
 
-    enum class Flag : TxFlags
+    enum class TxFlag : TxFlags
     {
       LEDGER_CHUNK_AT_NEXT_SIGNATURE = 0x01,
       SNAPSHOT_AT_NEXT_SIGNATURE = 0x02,
@@ -80,7 +80,7 @@ namespace ccf::kv
       commit_evidence_digest = tx_commit_evidence_digest;
       auto entry_type = EntryType::WriteSetWithCommitEvidenceAndClaims;
 
-      if (flag_enabled(Flag::LEDGER_CHUNK_BEFORE_THIS_TX))
+      if (tx_flag_enabled(TxFlag::LEDGER_CHUNK_BEFORE_THIS_TX))
       {
         entry_flags |= EntryFlags::FORCE_LEDGER_CHUNK_BEFORE;
       }
@@ -190,21 +190,21 @@ namespace ccf::kv
         committed = true;
         version = c.value();
 
-        if (flag_enabled(Flag::LEDGER_CHUNK_AT_NEXT_SIGNATURE))
+        if (tx_flag_enabled(TxFlag::LEDGER_CHUNK_AT_NEXT_SIGNATURE))
         {
           pimpl->store->set_flag(
-            AbstractStore::Flag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);
+            AbstractStore::StoreFlag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);
           // This transaction indicates to the store that the next signature
           // should trigger a new ledger chunk, but *this* transaction does not
           // create a new ledger chunk
-          unset_flag(CommittableTx::Flag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);
+          unset_tx_flag(TxFlag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);
         }
 
-        if (flag_enabled(Flag::SNAPSHOT_AT_NEXT_SIGNATURE))
+        if (tx_flag_enabled(TxFlag::SNAPSHOT_AT_NEXT_SIGNATURE))
         {
           pimpl->store->set_flag(
-            AbstractStore::Flag::SNAPSHOT_AT_NEXT_SIGNATURE);
-          unset_flag(CommittableTx::Flag::SNAPSHOT_AT_NEXT_SIGNATURE);
+            AbstractStore::StoreFlag::SNAPSHOT_AT_NEXT_SIGNATURE);
+          unset_tx_flag(TxFlag::SNAPSHOT_AT_NEXT_SIGNATURE);
         }
 
         if (version == NoVersion)
@@ -368,19 +368,19 @@ namespace ccf::kv
       root_at_read_version = r;
     }
 
-    virtual void set_flag(Flag flag)
+    virtual void set_tx_flag(TxFlag flag)
     {
-      flags |= static_cast<uint8_t>(flag);
+      flags |= static_cast<TxFlags>(flag);
     }
 
-    virtual void unset_flag(Flag flag)
+    virtual void unset_tx_flag(TxFlag flag)
     {
-      flags &= ~static_cast<uint8_t>(flag);
+      flags &= ~static_cast<TxFlags>(flag);
     }
 
-    virtual bool flag_enabled(Flag f) const
+    virtual bool tx_flag_enabled(TxFlag f) const
     {
-      return (flags & static_cast<uint8_t>(f)) != 0;
+      return (flags & static_cast<TxFlags>(f)) != 0;
     }
   };
 
@@ -455,7 +455,7 @@ namespace ccf::kv
 
       // Reset ledger chunk flag in the store
       pimpl->store->unset_flag_unsafe(
-        AbstractStore::Flag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);
+        AbstractStore::StoreFlag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);
 
       return {
         CommitResult::SUCCESS,
diff --git a/src/kv/kv_types.h b/src/kv/kv_types.h
@@ -743,18 +743,18 @@ namespace ccf::kv
 
     virtual size_t committable_gap() = 0;
 
-    enum class Flag : uint8_t
+    enum class StoreFlag : uint8_t
     {
       LEDGER_CHUNK_AT_NEXT_SIGNATURE = 0x01,
       SNAPSHOT_AT_NEXT_SIGNATURE = 0x02
     };
 
-    virtual void set_flag(Flag f) = 0;
-    virtual void unset_flag(Flag f) = 0;
-    virtual bool flag_enabled(Flag f) = 0;
-    virtual void set_flag_unsafe(Flag f) = 0;
-    virtual void unset_flag_unsafe(Flag f) = 0;
-    virtual bool flag_enabled_unsafe(Flag f) const = 0;
+    virtual void set_flag(StoreFlag f) = 0;
+    virtual void unset_flag(StoreFlag f) = 0;
+    virtual bool flag_enabled(StoreFlag f) = 0;
+    virtual void set_flag_unsafe(StoreFlag f) = 0;
+    virtual void unset_flag_unsafe(StoreFlag f) = 0;
+    virtual bool flag_enabled_unsafe(StoreFlag f) const = 0;
   };
 
   template <class StorePointer>
diff --git a/src/kv/store.h b/src/kv/store.h
@@ -623,8 +623,8 @@ namespace ccf::kv
 
         version = tx_id.version;
         last_replicated = tx_id.version;
-        unset_flag_unsafe(Flag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);
-        unset_flag_unsafe(Flag::SNAPSHOT_AT_NEXT_SIGNATURE);
+        unset_flag_unsafe(StoreFlag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);
+        unset_flag_unsafe(StoreFlag::SNAPSHOT_AT_NEXT_SIGNATURE);
         rollback_count++;
         pending_txs.clear();
         auto e = get_encryptor();
@@ -1025,9 +1025,8 @@ namespace ccf::kv
       // Note that snapshotter->record_committable, and therefore this function,
       // assumes that `version` is a committable entry/signature.
 
-      bool r = flag_enabled_unsafe(
-                 AbstractStore::Flag::LEDGER_CHUNK_AT_NEXT_SIGNATURE) ||
-        flag_enabled_unsafe(AbstractStore::Flag::SNAPSHOT_AT_NEXT_SIGNATURE);
+      bool r = flag_enabled_unsafe(StoreFlag::LEDGER_CHUNK_AT_NEXT_SIGNATURE) ||
+        flag_enabled_unsafe(StoreFlag::SNAPSHOT_AT_NEXT_SIGNATURE);
 
       if (snapshotter)
       {
@@ -1258,35 +1257,35 @@ namespace ccf::kv
       return ReservedTx(this, term_of_last_version, tx_id, rollback_count);
     }
 
-    virtual void set_flag(Flag f) override
+    virtual void set_flag(StoreFlag f) override
     {
       std::lock_guard<ccf::pal::Mutex> vguard(version_lock);
       set_flag_unsafe(f);
     }
 
-    virtual void unset_flag(Flag f) override
+    virtual void unset_flag(StoreFlag f) override
     {
       std::lock_guard<ccf::pal::Mutex> vguard(version_lock);
       unset_flag_unsafe(f);
     }
 
-    virtual bool flag_enabled(Flag f) override
+    virtual bool flag_enabled(StoreFlag f) override
     {
       std::lock_guard<ccf::pal::Mutex> vguard(version_lock);
       return flag_enabled_unsafe(f);
     }
 
-    virtual void set_flag_unsafe(Flag f) override
+    virtual void set_flag_unsafe(StoreFlag f) override
     {
       this->flags |= static_cast<uint8_t>(f);
     }
 
-    virtual void unset_flag_unsafe(Flag f) override
+    virtual void unset_flag_unsafe(StoreFlag f) override
     {
       this->flags &= ~static_cast<uint8_t>(f);
     }
 
-    virtual bool flag_enabled_unsafe(Flag f) const override
+    virtual bool flag_enabled_unsafe(StoreFlag f) const override
     {
       return (flags & static_cast<uint8_t>(f)) != 0;
     }
diff --git a/src/kv/test/kv_test.cpp b/src/kv/test/kv_test.cpp
@@ -3155,15 +3155,16 @@ TEST_CASE("Ledger entry chunk request")
   {
     // Ledger chunk flag is not set in the store
     REQUIRE(!store.flag_enabled(
-      ccf::kv::AbstractStore::Flag::LEDGER_CHUNK_AT_NEXT_SIGNATURE));
+      ccf::kv::AbstractStore::StoreFlag::LEDGER_CHUNK_AT_NEXT_SIGNATURE));
 
     INFO("Add a transaction with the chunking flag enabled");
     {
       MapTypes::StringString map("public:map");
       auto tx = store.create_tx();
 
       // Request a ledger chunk at the next signature
-      tx.set_flag(ccf::kv::CommittableTx::Flag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);
+      tx.set_tx_flag(
+        ccf::kv::CommittableTx::TxFlag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);
 
       auto h1 = tx.rw(map);
       h1->put("key", "value");
@@ -3172,7 +3173,7 @@ TEST_CASE("Ledger entry chunk request")
 
     // Flag is now set in the store
     REQUIRE(store.flag_enabled(
-      ccf::kv::AbstractStore::Flag::LEDGER_CHUNK_AT_NEXT_SIGNATURE));
+      ccf::kv::AbstractStore::StoreFlag::LEDGER_CHUNK_AT_NEXT_SIGNATURE));
 
     INFO("Roll back the last transaction");
     {
@@ -3182,7 +3183,7 @@ TEST_CASE("Ledger entry chunk request")
 
       // Ledger chunk flag is still set in the store
       REQUIRE(store.flag_enabled(
-        ccf::kv::AbstractStore::Flag::LEDGER_CHUNK_AT_NEXT_SIGNATURE));
+        ccf::kv::AbstractStore::StoreFlag::LEDGER_CHUNK_AT_NEXT_SIGNATURE));
 
       // Roll the last transaction back to clear the flag in the store
       store.rollback(
@@ -3191,7 +3192,7 @@ TEST_CASE("Ledger entry chunk request")
 
       // Ledger chunk flag is not set in the store anymore
       REQUIRE(!store.flag_enabled(
-        ccf::kv::AbstractStore::Flag::LEDGER_CHUNK_AT_NEXT_SIGNATURE));
+        ccf::kv::AbstractStore::StoreFlag::LEDGER_CHUNK_AT_NEXT_SIGNATURE));
     }
 
     INFO("Add another transaction with the chunking flag enabled");
@@ -3200,7 +3201,8 @@ TEST_CASE("Ledger entry chunk request")
       auto tx = store.create_tx();
 
       // Request a ledger chunk at the next signature again
-      tx.set_flag(ccf::kv::CommittableTx::Flag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);
+      tx.set_tx_flag(
+        ccf::kv::CommittableTx::TxFlag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);
 
       auto h1 = tx.rw(map);
       h1->put("key", "value");
@@ -3209,7 +3211,7 @@ TEST_CASE("Ledger entry chunk request")
 
     // Ledger chunk flag is now set in the store
     REQUIRE(store.flag_enabled(
-      ccf::kv::AbstractStore::Flag::LEDGER_CHUNK_AT_NEXT_SIGNATURE));
+      ccf::kv::AbstractStore::StoreFlag::LEDGER_CHUNK_AT_NEXT_SIGNATURE));
 
     INFO(
       "Add a signature transaction which triggers chunk via entry header flag");
@@ -3242,7 +3244,7 @@ TEST_CASE("Ledger entry chunk request")
 
     // Ledger chunk flag is not set in the store anymore
     REQUIRE(!store.flag_enabled(
-      ccf::kv::AbstractStore::Flag::LEDGER_CHUNK_AT_NEXT_SIGNATURE));
+      ccf::kv::AbstractStore::StoreFlag::LEDGER_CHUNK_AT_NEXT_SIGNATURE));
   }
 
   SUBCASE("Chunk before this transaction")
@@ -3255,7 +3257,8 @@ TEST_CASE("Ledger entry chunk request")
       auto tx = store.create_tx();
 
       // Request a ledger chunk before tx
-      tx.set_flag(ccf::kv::CommittableTx::Flag::LEDGER_CHUNK_BEFORE_THIS_TX);
+      tx.set_tx_flag(
+        ccf::kv::CommittableTx::TxFlag::LEDGER_CHUNK_BEFORE_THIS_TX);
 
       auto h1 = tx.rw(map);
       h1->put("key", "value");
@@ -3279,7 +3282,8 @@ TEST_CASE("Ledger entry chunk request")
 
   SUBCASE("Chunk when the snapshotter requires one")
   {
-    store.set_flag(ccf::kv::AbstractStore::Flag::SNAPSHOT_AT_NEXT_SIGNATURE);
+    store.set_flag(
+      ccf::kv::AbstractStore::StoreFlag::SNAPSHOT_AT_NEXT_SIGNATURE);
 
     INFO("Add a signature that triggers a snapshot");
     {
diff --git a/src/node/node_state.h b/src/node/node_state.h
@@ -1501,8 +1501,8 @@ namespace ccf
       {
         throw std::logic_error("Could not cast tx to CommittableTx");
       }
-      tx_->set_flag(
-        ccf::kv::CommittableTx::Flag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);
+      tx_->set_tx_flag(
+        ccf::kv::CommittableTx::TxFlag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);
     }
 
     void trigger_snapshot(ccf::kv::Tx& tx) override
@@ -1512,8 +1512,8 @@ namespace ccf
       {
         throw std::logic_error("Could not cast tx to CommittableTx");
       }
-      committable_tx->set_flag(
-        ccf::kv::CommittableTx::Flag::SNAPSHOT_AT_NEXT_SIGNATURE);
+      committable_tx->set_tx_flag(
+        ccf::kv::CommittableTx::TxFlag::SNAPSHOT_AT_NEXT_SIGNATURE);
     }
 
     void trigger_acme_refresh(
diff --git a/src/node/rpc/node_frontend.h b/src/node/rpc/node_frontend.h
@@ -1579,8 +1579,8 @@ namespace ccf
           {
             throw std::logic_error("Could not cast tx to CommittableTx");
           }
-          tx_->set_flag(
-            ccf::kv::CommittableTx::Flag::LEDGER_CHUNK_BEFORE_THIS_TX);
+          tx_->set_tx_flag(
+            ccf::kv::CommittableTx::TxFlag::LEDGER_CHUNK_BEFORE_THIS_TX);
         }
 
         auto endorsed_certificates =
diff --git a/src/node/snapshotter.h b/src/node/snapshotter.h
@@ -336,7 +336,7 @@ namespace ccf
         next_snapshot_indices.back().idx);
 
       bool forced = store->flag_enabled_unsafe(
-        ccf::kv::AbstractStore::Flag::SNAPSHOT_AT_NEXT_SIGNATURE);
+        ccf::kv::AbstractStore::StoreFlag::SNAPSHOT_AT_NEXT_SIGNATURE);
 
       ::consensus::Index last_unforced_idx = last_snapshot_idx;
       for (auto it = next_snapshot_indices.rbegin();
@@ -357,7 +357,7 @@ namespace ccf
         LOG_TRACE_FMT(
           "{} {} as snapshot index", !due ? "Forced" : "Recorded", idx);
         store->unset_flag_unsafe(
-          ccf::kv::AbstractStore::Flag::SNAPSHOT_AT_NEXT_SIGNATURE);
+          ccf::kv::AbstractStore::StoreFlag::SNAPSHOT_AT_NEXT_SIGNATURE);
         return due;
       }
 
diff --git a/src/node/test/snapshotter.cpp b/src/node/test/snapshotter.cpp
@@ -395,7 +395,7 @@ TEST_CASE("Rollback before snapshot is committed")
     size_t snapshot_idx = network.tables->current_version();
 
     network.tables->set_flag(
-      ccf::kv::AbstractStore::Flag::SNAPSHOT_AT_NEXT_SIGNATURE);
+      ccf::kv::AbstractStore::StoreFlag::SNAPSHOT_AT_NEXT_SIGNATURE);
 
     REQUIRE_FALSE(record_signature(history, snapshotter, snapshot_idx));
     snapshotter->commit(snapshot_idx, true);
@@ -411,7 +411,7 @@ TEST_CASE("Rollback before snapshot is committed")
     REQUIRE(snapshotter->write_snapshot(snapshot, snapshot_count));
 
     REQUIRE(!network.tables->flag_enabled(
-      ccf::kv::AbstractStore::Flag::SNAPSHOT_AT_NEXT_SIGNATURE));
+      ccf::kv::AbstractStore::StoreFlag::SNAPSHOT_AT_NEXT_SIGNATURE));
 
     // Commit evidence
     issue_transactions(network, 1);

Original file line number	Diff line number	Diff line change
`@@ -461,12 +461,12 @@ namespace aft`
`461`	`461`	`data, expected_txid, std::move(hooks));`
`462`	`462`	`}`
`463`	`463`
`464`		`- bool flag_enabled(ccf::kv::AbstractStore::Flag)`
	`464`	`+ bool flag_enabled(ccf::kv::AbstractStore::StoreFlag)`
`465`	`465`	`{`
`466`	`466`	`return false;`
`467`	`467`	`}`
`468`	`468`
`469`		`- void unset_flag(ccf::kv::AbstractStore::Flag) {}`
	`469`	`+ void unset_flag(ccf::kv::AbstractStore::StoreFlag) {}`
`470`	`470`	`};`
`471`	`471`
`472`	`472`	`class LoggingStubStoreConfig : public LoggingStubStore`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ namespace ccf::kv`
`19`	`19`	`public:`
`20`	`20`	`using TxFlags = uint8_t;`
`21`	`21`
`22`		`- enum class Flag : TxFlags`
	`22`	`+ enum class TxFlag : TxFlags`
`23`	`23`	`{`
`24`	`24`	`LEDGER_CHUNK_AT_NEXT_SIGNATURE = 0x01,`
`25`	`25`	`SNAPSHOT_AT_NEXT_SIGNATURE = 0x02,`
`@@ -80,7 +80,7 @@ namespace ccf::kv`
`80`	`80`	`commit_evidence_digest = tx_commit_evidence_digest;`
`81`	`81`	`auto entry_type = EntryType::WriteSetWithCommitEvidenceAndClaims;`
`82`	`82`
`83`		`- if (flag_enabled(Flag::LEDGER_CHUNK_BEFORE_THIS_TX))`
	`83`	`+ if (tx_flag_enabled(TxFlag::LEDGER_CHUNK_BEFORE_THIS_TX))`
`84`	`84`	`{`
`85`	`85`	`entry_flags \|= EntryFlags::FORCE_LEDGER_CHUNK_BEFORE;`
`86`	`86`	`}`
`@@ -190,21 +190,21 @@ namespace ccf::kv`
`190`	`190`	`committed = true;`
`191`	`191`	`version = c.value();`
`192`	`192`
`193`		`- if (flag_enabled(Flag::LEDGER_CHUNK_AT_NEXT_SIGNATURE))`
	`193`	`+ if (tx_flag_enabled(TxFlag::LEDGER_CHUNK_AT_NEXT_SIGNATURE))`
`194`	`194`	`{`
`195`	`195`	`pimpl->store->set_flag(`
`196`		`- AbstractStore::Flag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);`
	`196`	`+ AbstractStore::StoreFlag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);`
`197`	`197`	`// This transaction indicates to the store that the next signature`
`198`	`198`	`// should trigger a new ledger chunk, but this transaction does not`
`199`	`199`	`// create a new ledger chunk`
`200`		`- unset_flag(CommittableTx::Flag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);`
	`200`	`+ unset_tx_flag(TxFlag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);`
`201`	`201`	`}`
`202`	`202`
`203`		`- if (flag_enabled(Flag::SNAPSHOT_AT_NEXT_SIGNATURE))`
	`203`	`+ if (tx_flag_enabled(TxFlag::SNAPSHOT_AT_NEXT_SIGNATURE))`
`204`	`204`	`{`
`205`	`205`	`pimpl->store->set_flag(`
`206`		`- AbstractStore::Flag::SNAPSHOT_AT_NEXT_SIGNATURE);`
`207`		`- unset_flag(CommittableTx::Flag::SNAPSHOT_AT_NEXT_SIGNATURE);`
	`206`	`+ AbstractStore::StoreFlag::SNAPSHOT_AT_NEXT_SIGNATURE);`
	`207`	`+ unset_tx_flag(TxFlag::SNAPSHOT_AT_NEXT_SIGNATURE);`
`208`	`208`	`}`
`209`	`209`
`210`	`210`	`if (version == NoVersion)`
`@@ -368,19 +368,19 @@ namespace ccf::kv`
`368`	`368`	`root_at_read_version = r;`
`369`	`369`	`}`
`370`	`370`
`371`		`- virtual void set_flag(Flag flag)`
	`371`	`+ virtual void set_tx_flag(TxFlag flag)`
`372`	`372`	`{`
`373`		`- flags \|= static_cast<uint8_t>(flag);`
	`373`	`+ flags \|= static_cast<TxFlags>(flag);`
`374`	`374`	`}`
`375`	`375`
`376`		`- virtual void unset_flag(Flag flag)`
	`376`	`+ virtual void unset_tx_flag(TxFlag flag)`
`377`	`377`	`{`
`378`		`- flags &= ~static_cast<uint8_t>(flag);`
	`378`	`+ flags &= ~static_cast<TxFlags>(flag);`
`379`	`379`	`}`
`380`	`380`
`381`		`- virtual bool flag_enabled(Flag f) const`
	`381`	`+ virtual bool tx_flag_enabled(TxFlag f) const`
`382`	`382`	`{`
`383`		`- return (flags & static_cast<uint8_t>(f)) != 0;`
	`383`	`+ return (flags & static_cast<TxFlags>(f)) != 0;`
`384`	`384`	`}`
`385`	`385`	`};`
`386`	`386`
`@@ -455,7 +455,7 @@ namespace ccf::kv`
`455`	`455`
`456`	`456`	`// Reset ledger chunk flag in the store`
`457`	`457`	`pimpl->store->unset_flag_unsafe(`
`458`		`- AbstractStore::Flag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);`
	`458`	`+ AbstractStore::StoreFlag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);`
`459`	`459`
`460`	`460`	`return {`
`461`	`461`	`CommitResult::SUCCESS,`
Original file line number	Diff line number	Diff line change
`@@ -623,8 +623,8 @@ namespace ccf::kv`
`623`	`623`
`624`	`624`	`version = tx_id.version;`
`625`	`625`	`last_replicated = tx_id.version;`
`626`		`- unset_flag_unsafe(Flag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);`
`627`		`- unset_flag_unsafe(Flag::SNAPSHOT_AT_NEXT_SIGNATURE);`
	`626`	`+ unset_flag_unsafe(StoreFlag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);`
	`627`	`+ unset_flag_unsafe(StoreFlag::SNAPSHOT_AT_NEXT_SIGNATURE);`
`628`	`628`	`rollback_count++;`
`629`	`629`	`pending_txs.clear();`
`630`	`630`	`auto e = get_encryptor();`
`@@ -1025,9 +1025,8 @@ namespace ccf::kv`
`1025`	`1025`	`// Note that snapshotter->record_committable, and therefore this function,`
`1026`	`1026`	// assumes that `version` is a committable entry/signature.
`1027`	`1027`
`1028`		`- bool r = flag_enabled_unsafe(`
`1029`		`- AbstractStore::Flag::LEDGER_CHUNK_AT_NEXT_SIGNATURE) \|\|`
`1030`		`- flag_enabled_unsafe(AbstractStore::Flag::SNAPSHOT_AT_NEXT_SIGNATURE);`
	`1028`	`+ bool r = flag_enabled_unsafe(StoreFlag::LEDGER_CHUNK_AT_NEXT_SIGNATURE) \|\|`
	`1029`	`+ flag_enabled_unsafe(StoreFlag::SNAPSHOT_AT_NEXT_SIGNATURE);`
`1031`	`1030`
`1032`	`1031`	`if (snapshotter)`
`1033`	`1032`	`{`
`@@ -1258,35 +1257,35 @@ namespace ccf::kv`
`1258`	`1257`	`return ReservedTx(this, term_of_last_version, tx_id, rollback_count);`
`1259`	`1258`	`}`
`1260`	`1259`
`1261`		`- virtual void set_flag(Flag f) override`
	`1260`	`+ virtual void set_flag(StoreFlag f) override`
`1262`	`1261`	`{`
`1263`	`1262`	`std::lock_guard<ccf::pal::Mutex> vguard(version_lock);`
`1264`	`1263`	`set_flag_unsafe(f);`
`1265`	`1264`	`}`
`1266`	`1265`
`1267`		`- virtual void unset_flag(Flag f) override`
	`1266`	`+ virtual void unset_flag(StoreFlag f) override`
`1268`	`1267`	`{`
`1269`	`1268`	`std::lock_guard<ccf::pal::Mutex> vguard(version_lock);`
`1270`	`1269`	`unset_flag_unsafe(f);`
`1271`	`1270`	`}`
`1272`	`1271`
`1273`		`- virtual bool flag_enabled(Flag f) override`
	`1272`	`+ virtual bool flag_enabled(StoreFlag f) override`
`1274`	`1273`	`{`
`1275`	`1274`	`std::lock_guard<ccf::pal::Mutex> vguard(version_lock);`
`1276`	`1275`	`return flag_enabled_unsafe(f);`
`1277`	`1276`	`}`
`1278`	`1277`
`1279`		`- virtual void set_flag_unsafe(Flag f) override`
	`1278`	`+ virtual void set_flag_unsafe(StoreFlag f) override`
`1280`	`1279`	`{`
`1281`	`1280`	`this->flags \|= static_cast<uint8_t>(f);`
`1282`	`1281`	`}`
`1283`	`1282`
`1284`		`- virtual void unset_flag_unsafe(Flag f) override`
	`1283`	`+ virtual void unset_flag_unsafe(StoreFlag f) override`
`1285`	`1284`	`{`
`1286`	`1285`	`this->flags &= ~static_cast<uint8_t>(f);`
`1287`	`1286`	`}`
`1288`	`1287`
`1289`		`- virtual bool flag_enabled_unsafe(Flag f) const override`
	`1288`	`+ virtual bool flag_enabled_unsafe(StoreFlag f) const override`
`1290`	`1289`	`{`
`1291`	`1290`	`return (flags & static_cast<uint8_t>(f)) != 0;`
`1292`	`1291`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1501,8 +1501,8 @@ namespace ccf`
`1501`	`1501`	`{`
`1502`	`1502`	`throw std::logic_error("Could not cast tx to CommittableTx");`
`1503`	`1503`	`}`
`1504`		`- tx_->set_flag(`
`1505`		`- ccf::kv::CommittableTx::Flag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);`
	`1504`	`+ tx_->set_tx_flag(`
	`1505`	`+ ccf::kv::CommittableTx::TxFlag::LEDGER_CHUNK_AT_NEXT_SIGNATURE);`
`1506`	`1506`	`}`
`1507`	`1507`
`1508`	`1508`	`void trigger_snapshot(ccf::kv::Tx& tx) override`
`@@ -1512,8 +1512,8 @@ namespace ccf`
`1512`	`1512`	`{`
`1513`	`1513`	`throw std::logic_error("Could not cast tx to CommittableTx");`
`1514`	`1514`	`}`
`1515`		`- committable_tx->set_flag(`
`1516`		`- ccf::kv::CommittableTx::Flag::SNAPSHOT_AT_NEXT_SIGNATURE);`
	`1515`	`+ committable_tx->set_tx_flag(`
	`1516`	`+ ccf::kv::CommittableTx::TxFlag::SNAPSHOT_AT_NEXT_SIGNATURE);`
`1517`	`1517`	`}`
`1518`	`1518`
`1519`	`1519`	`void trigger_acme_refresh(`
Original file line number	Diff line number	Diff line change
`@@ -1579,8 +1579,8 @@ namespace ccf`
`1579`	`1579`	`{`
`1580`	`1580`	`throw std::logic_error("Could not cast tx to CommittableTx");`
`1581`	`1581`	`}`
`1582`		`- tx_->set_flag(`
`1583`		`- ccf::kv::CommittableTx::Flag::LEDGER_CHUNK_BEFORE_THIS_TX);`
	`1582`	`+ tx_->set_tx_flag(`
	`1583`	`+ ccf::kv::CommittableTx::TxFlag::LEDGER_CHUNK_BEFORE_THIS_TX);`
`1584`	`1584`	`}`
`1585`	`1585`
`1586`	`1586`	`auto endorsed_certificates =`