chore: World state tech debt cleanup 1

barretenberg/cpp/src/barretenberg/crypto/merkle_tree/append_only_tree/content_addressed_append_only_tree.hpp

@@ -113,7 +113,7 @@ template <typename Store, typename HashingPolicy> class ContentAddressedAppendOn
      * @param on_completion Callback to be called on completion
      * @param includeUncommitted Whether to include uncommitted changes
      */
-    void get_subtree_sibling_path(index_t leaf_index,
+    void get_subtree_sibling_path(const index_t& leaf_index,
                                   uint32_t subtree_depth,
                                   const HashPathCallback& on_completion,
                                   bool includeUncommitted) const;
@@ -131,7 +131,9 @@ template <typename Store, typename HashingPolicy> class ContentAddressedAppendOn
      * @param includeUncommitted Whether to include uncommitted changes
      * @param on_completion Callback to be called on completion
      */
-    void get_meta_data(index_t blockNumber, bool includeUncommitted, const MetaDataCallback& on_completion) const;
+    void get_meta_data(const index_t& blockNumber,
+                       bool includeUncommitted,
+                       const MetaDataCallback& on_completion) const;
 
     /**
      * @brief Returns the leaf value at the provided index
@@ -226,12 +228,12 @@ template <typename Store, typename HashingPolicy> class ContentAddressedAppendOn
                                                           const RequestContext& requestContext,
                                                           ReadTransaction& tx) const;
 
-    std::optional<fr> find_leaf_hash(index_t leaf_index,
+    std::optional<fr> find_leaf_hash(const index_t& leaf_index,
                                      const RequestContext& requestContext,
                                      ReadTransaction& tx,
                                      bool updateNodesByIndexCache = false) const;
 
-    index_t get_batch_insertion_size(index_t treeSize, index_t remainingAppendSize);
+    index_t get_batch_insertion_size(const index_t& treeSize, const index_t& remainingAppendSize);
 
     void add_batch_internal(
         std::vector<fr>& values, fr& new_root, index_t& new_size, bool update_index, ReadTransaction& tx);
@@ -323,7 +325,7 @@ void ContentAddressedAppendOnlyTree<Store, HashingPolicy>::get_meta_data(bool in
 }
 
 template <typename Store, typename HashingPolicy>
-void ContentAddressedAppendOnlyTree<Store, HashingPolicy>::get_meta_data(index_t blockNumber,
+void ContentAddressedAppendOnlyTree<Store, HashingPolicy>::get_meta_data(const index_t& blockNumber,
                                                                          bool includeUncommitted,
                                                                          const MetaDataCallback& on_completion) const
 {
@@ -335,7 +337,9 @@ void ContentAddressedAppendOnlyTree<Store, HashingPolicy>::get_meta_data(index_t
 
                 BlockPayload blockData;
                 if (!store_->get_block_data(blockNumber, blockData, *tx)) {
-                    throw std::runtime_error("Data for block unavailable");
+                    throw std::runtime_error((std::stringstream() << "Unable to get meta data for block " << blockNumber
+                                                                  << ", failed to get block data.")
+                                                 .str());
                 }
 
                 response.inner.meta.size = blockData.size;
@@ -365,12 +369,15 @@ void ContentAddressedAppendOnlyTree<Store, HashingPolicy>::get_sibling_path(cons
         execute_and_report<GetSiblingPathResponse>(
             [=, this](TypedResponse<GetSiblingPathResponse>& response) {
                 if (blockNumber == 0) {
-                    throw std::runtime_error("Invalid block number");
+                    throw std::runtime_error("Unable to get sibling path at block 0");
                 }
                 ReadTransactionPtr tx = store_->create_read_transaction();
                 BlockPayload blockData;
                 if (!store_->get_block_data(blockNumber, blockData, *tx)) {
-                    throw std::runtime_error("Data for block unavailable");
+                    throw std::runtime_error((std::stringstream()
+                                              << "Unable to get sibling path for index " << index << " at block "
+                                              << blockNumber << ", failed to get block data.")
+                                                 .str());
                 }
 
                 RequestContext requestContext;
@@ -387,7 +394,7 @@ void ContentAddressedAppendOnlyTree<Store, HashingPolicy>::get_sibling_path(cons
 
 template <typename Store, typename HashingPolicy>
 void ContentAddressedAppendOnlyTree<Store, HashingPolicy>::get_subtree_sibling_path(
-    const uint32_t subtree_depth, const HashPathCallback& on_completion, bool includeUncommitted) const
+    uint32_t subtree_depth, const HashPathCallback& on_completion, bool includeUncommitted) const
 {
     auto job = [=, this]() {
         execute_and_report<GetSiblingPathResponse>(
@@ -409,8 +416,8 @@ void ContentAddressedAppendOnlyTree<Store, HashingPolicy>::get_subtree_sibling_p
 
 template <typename Store, typename HashingPolicy>
 void ContentAddressedAppendOnlyTree<Store, HashingPolicy>::get_subtree_sibling_path(
-    const index_t leaf_index,
-    const uint32_t subtree_depth,
+    const index_t& leaf_index,
+    uint32_t subtree_depth,
     const HashPathCallback& on_completion,
     bool includeUncommitted) const
 {
@@ -450,7 +457,10 @@ fr_sibling_path ContentAddressedAppendOnlyTree<Store, HashingPolicy>::optional_s
 
 template <typename Store, typename HashingPolicy>
 std::optional<fr> ContentAddressedAppendOnlyTree<Store, HashingPolicy>::find_leaf_hash(
-    index_t leaf_index, const RequestContext& requestContext, ReadTransaction& tx, bool updateNodesByIndexCache) const
+    const index_t& leaf_index,
+    const RequestContext& requestContext,
+    ReadTransaction& tx,
+    bool updateNodesByIndexCache) const
 {
     fr hash = requestContext.root;
     // std::cout << "Finding leaf hash for root " << hash << " at index " << leaf_index << std::endl;
@@ -510,7 +520,7 @@ template <typename Store, typename HashingPolicy>
 ContentAddressedAppendOnlyTree<Store, HashingPolicy>::OptionalSiblingPath ContentAddressedAppendOnlyTree<
     Store,
     HashingPolicy>::get_subtree_sibling_path_internal(const index_t& leaf_index,
-                                                      const uint32_t subtree_depth,
+                                                      uint32_t subtree_depth,
                                                       const RequestContext& requestContext,
                                                       ReadTransaction& tx) const
 {
@@ -586,15 +596,21 @@ void ContentAddressedAppendOnlyTree<Store, HashingPolicy>::get_leaf(const index_
         execute_and_report<GetLeafResponse>(
             [=, this](TypedResponse<GetLeafResponse>& response) {
                 if (blockNumber == 0) {
-                    throw std::runtime_error("Invalid block number");
+                    throw std::runtime_error("Unable to get leaf at block 0");
                 }
                 ReadTransactionPtr tx = store_->create_read_transaction();
                 BlockPayload blockData;
                 if (!store_->get_block_data(blockNumber, blockData, *tx)) {
-                    throw std::runtime_error("Data for block unavailable");
+                    throw std::runtime_error((std::stringstream()
+                                              << "Unable to get leaf at index " << leaf_index << " for block "
+                                              << blockNumber << ", failed to get block data.")
+                                                 .str());
                 }
                 if (blockData.size < leaf_index) {
-                    response.message = "Data for block unavailable";
+                    response.message =
+                        (std::stringstream() << "Unable to get leaf at index " << leaf_index << " for block "
+                                             << blockNumber << ", leaf index is too high.")
+                            .str();
                     response.success = false;
                     return;
                 }
@@ -665,12 +681,15 @@ void ContentAddressedAppendOnlyTree<Store, HashingPolicy>::find_leaf_index_from(
         execute_and_report<FindLeafIndexResponse>(
             [=, this](TypedResponse<FindLeafIndexResponse>& response) {
                 if (blockNumber == 0) {
-                    throw std::runtime_error("Invalid block number");
+                    throw std::runtime_error("Unable to find leaf index for block number 0");
                 }
                 ReadTransactionPtr tx = store_->create_read_transaction();
                 BlockPayload blockData;
                 if (!store_->get_block_data(blockNumber, blockData, *tx)) {
-                    throw std::runtime_error("Data for block unavailable");
+                    throw std::runtime_error((std::stringstream()
+                                              << "Unable to find leaf from index " << start_index << " for block "
+                                              << blockNumber << ", failed to get block data.")
+                                                 .str());
                 }
                 RequestContext requestContext;
                 requestContext.blockNumber = blockNumber;
@@ -739,7 +758,7 @@ void ContentAddressedAppendOnlyTree<Store, HashingPolicy>::remove_historic_block
         execute_and_report(
             [=, this]() {
                 if (blockNumber == 0) {
-                    throw std::runtime_error("Invalid block number");
+                    throw std::runtime_error("Unable to remove historic block 0");
                 }
                 store_->remove_historical_block(blockNumber);
             },
@@ -756,7 +775,7 @@ void ContentAddressedAppendOnlyTree<Store, HashingPolicy>::unwind_block(
         execute_and_report(
             [=, this]() {
                 if (blockNumber == 0) {
-                    throw std::runtime_error("Invalid block number");
+                    throw std::runtime_error("Unable to unwind block 0");
                 }
                 store_->unwind_block(blockNumber);
             },
@@ -773,7 +792,7 @@ void ContentAddressedAppendOnlyTree<Store, HashingPolicy>::finalise_block(const
         execute_and_report(
             [=, this]() {
                 if (blockNumber == 0) {
-                    throw std::runtime_error("Invalid block number");
+                    throw std::runtime_error("Unable to finalise block 0");
                 }
                 store_->advance_finalised_block(blockNumber);
             },
@@ -783,8 +802,8 @@ void ContentAddressedAppendOnlyTree<Store, HashingPolicy>::finalise_block(const
 }
 
 template <typename Store, typename HashingPolicy>
-index_t ContentAddressedAppendOnlyTree<Store, HashingPolicy>::get_batch_insertion_size(index_t treeSize,
-                                                                                       index_t remainingAppendSize)
+index_t ContentAddressedAppendOnlyTree<Store, HashingPolicy>::get_batch_insertion_size(
+    const index_t& treeSize, const index_t& remainingAppendSize)
 {
     index_t minPower2 = 1;
     if (treeSize != 0U) {
@@ -845,7 +864,9 @@ void ContentAddressedAppendOnlyTree<Store, HashingPolicy>::add_batch_internal(
     }
 
     if (new_size > max_size_) {
-        throw std::runtime_error("Tree is full");
+        throw std::runtime_error((std::stringstream() << "Unable to append leaves to tree " << meta.name
+                                                      << " new size: " << new_size << " max size: " << max_size_)
+                                     .str());
     }
 
     // Add the values at the leaf nodes of the tree

barretenberg/cpp/src/barretenberg/crypto/merkle_tree/append_only_tree/content_addressed_append_only_tree.test.cpp

@@ -455,10 +455,13 @@ TEST_F(PersistedContentAddressedAppendOnlyTreeTest, reports_an_error_if_tree_is_
     }
     add_values(tree, values);
 
+    std::stringstream ss;
+    ss << "Unable to append leaves to tree " << name << " new size: 17 max size: 16";
+
     Signal signal;
     auto add_completion = [&](const TypedResponse<AddDataResponse>& response) {
         EXPECT_EQ(response.success, false);
-        EXPECT_EQ(response.message, "Tree is full");
+        EXPECT_EQ(response.message, ss.str());
         signal.signal_level();
     };
     tree.add_value(VALUES[16], add_completion);