feat!: add slicing to machine::get_proof

Author: diegonehab

src/clua-i-machine.cpp

@@ -36,6 +36,7 @@ extern "C" {
 
 #include "base64.h"
 #include "clua.h"
+#include "hash-tree-constants.h"
 #include "machine-c-api.h"
 
 namespace cartesi {
@@ -548,12 +549,13 @@ void clua_push_schemed_json_table(lua_State *L, const char *s, const std::string
 /// \brief This is the machine:get_proof() method implementation.
 /// \param L Lua state.
 static int machine_obj_index_get_proof(lua_State *L) {
-    lua_settop(L, 3);
+    lua_settop(L, 4);
     auto &m = clua_check<clua_managed_cm_ptr<cm_machine>>(L, 1);
     const uint64_t address = luaL_checkinteger(L, 2);
-    const int log2_size = static_cast<int>(luaL_checkinteger(L, 3));
+    const int log2_target_size = static_cast<int>(luaL_checkinteger(L, 3));
+    const int log2_root_size = static_cast<int>(luaL_optinteger(L, 4, cartesi::HASH_TREE_LOG2_ROOT_SIZE));
     const char *proof = nullptr;
-    if (cm_get_proof(m.get(), address, log2_size, &proof) != 0) {
+    if (cm_get_proof(m.get(), address, log2_target_size, log2_root_size, &proof) != 0) {
         return luaL_error(L, "%s", cm_get_last_error_message());
     }
     clua_push_schemed_json_table(L, proof, "Proof");

src/hash-tree.cpp

@@ -75,10 +75,15 @@ const_machine_hash_view hash_tree::get_sparse_node_hash_view(index_type node_ind
 
 void hash_tree::get_pristine_proof(int curr_log2_size, proof_type &proof) const {
     const auto log2_target_size = proof.get_log2_target_size();
-    for (int log2_size = curr_log2_size - 1; log2_size >= log2_target_size; --log2_size) {
+    const auto log2_root_size = proof.get_log2_root_size();
+    const auto start_log2_size = std::min(log2_root_size, curr_log2_size) - 1;
+    for (int log2_size = start_log2_size; log2_size >= log2_target_size; --log2_size) {
         proof.set_sibling_hash(m_pristine_hashes[log2_size], log2_size);
     }
     proof.set_target_hash(m_pristine_hashes[log2_target_size]);
+    if (log2_root_size <= curr_log2_size) {
+        proof.set_root_hash(m_pristine_hashes[log2_root_size]);
+    }
 }
 
 static inline uint64_t get_sibling_address(uint64_t address, int log2_size) {
@@ -103,46 +108,65 @@ void hash_tree::get_page_proof(address_range &ar, uint64_t address, proof_type &
         update_dirty_page(ar, opt_br->get(), changed);
     }
     const auto log2_target_size = proof.get_log2_target_size();
+    const auto log2_root_size = proof.get_log2_root_size();
     assert(log2_target_size >= HASH_TREE_LOG2_WORD_SIZE && "log2_size is too small");
     const auto &entry = opt_br->get();
     const auto node_offset = address & (HASH_TREE_PAGE_SIZE - 1);
-    for (int log2_size = HASH_TREE_LOG2_PAGE_SIZE - 1; log2_size >= log2_target_size; --log2_size) {
+    const auto start_log2_size = std::min(log2_root_size, HASH_TREE_LOG2_PAGE_SIZE) - 1;
+    for (int log2_size = start_log2_size; log2_size >= log2_target_size; --log2_size) {
         proof.set_sibling_hash(entry.node_hash_view(get_sibling_address(node_offset, log2_size), log2_size), log2_size);
     }
     proof.set_target_hash(entry.node_hash_view(node_offset, log2_target_size));
+    if (log2_root_size <= HASH_TREE_LOG2_PAGE_SIZE) {
+        proof.set_root_hash(entry.node_hash_view(0, log2_root_size));
+    }
     page_hash_tree_cache::return_entry(*opt_br);
 }
 
 void hash_tree::get_dense_proof(address_range &ar, int ar_log2_size, uint64_t address, proof_type &proof) {
     const auto &dht = ar.get_dense_hash_tree();
     const auto log2_target_size = proof.get_log2_target_size();
+    const auto log2_root_size = proof.get_log2_root_size();
     const auto dht_end = std::max<int>(HASH_TREE_LOG2_PAGE_SIZE, log2_target_size);
     const auto node_offset = address - ar.get_start();
-    for (int log2_size = ar_log2_size - 1; log2_size >= dht_end; --log2_size) {
+    const auto start_log2_size = std::min(log2_root_size, ar_log2_size) - 1;
+    for (int log2_size = start_log2_size; log2_size >= dht_end; --log2_size) {
         const auto sibling_offset = get_sibling_address(node_offset, log2_size);
         proof.set_sibling_hash(dht.node_hash_view(sibling_offset, log2_size), log2_size);
     }
+    if (log2_root_size >= HASH_TREE_LOG2_PAGE_SIZE && log2_root_size <= ar_log2_size) {
+        proof.set_root_hash(dht.node_hash_view(0, log2_root_size));
+    }
     if (log2_target_size >= HASH_TREE_LOG2_PAGE_SIZE) {
         proof.set_target_hash(dht.node_hash_view(node_offset, log2_target_size));
     } else {
         get_page_proof(ar, address, proof);
     }
 }
 
-hash_tree::proof_type hash_tree::get_proof(address_ranges ars, uint64_t address, int log2_size) {
-    if (log2_size < HASH_TREE_LOG2_WORD_SIZE || log2_size > HASH_TREE_LOG2_ROOT_SIZE) {
-        throw std::domain_error{"invalid log2_size"};
+hash_tree::proof_type hash_tree::get_proof(address_ranges ars, uint64_t address, int log2_target_size,
+    int log2_root_size) {
+    if (log2_root_size < HASH_TREE_LOG2_WORD_SIZE) {
+        throw std::domain_error{"log2_root_size is too small"};
     }
-    if (log2_size == HASH_TREE_LOG2_ROOT_SIZE) {
+    if (log2_root_size > HASH_TREE_LOG2_ROOT_SIZE) {
+        throw std::domain_error{"log2_root_size is too large"};
+    }
+    if (log2_target_size < HASH_TREE_LOG2_WORD_SIZE) {
+        throw std::domain_error{"log2_target_size is too small"};
+    }
+    if (log2_target_size > log2_root_size) {
+        throw std::domain_error{"log2_target_size is larger than log2_root_size"};
+    }
+    if (log2_target_size == HASH_TREE_LOG2_ROOT_SIZE) {
         if (address != 0) {
-            throw std::domain_error{"address not aligned to log2_size"};
+            throw std::domain_error{"address not aligned to log2_target_size"};
         }
-    } else if (((address >> log2_size) << log2_size) != address) {
-        throw std::domain_error{"address not aligned to log2_size"};
+    } else if (((address >> log2_target_size) << log2_target_size) != address) {
+        throw std::domain_error{"address not aligned to log2_target_size"};
     }
-    proof_type proof{HASH_TREE_LOG2_ROOT_SIZE, log2_size};
+    proof_type proof{log2_root_size, log2_target_size};
     proof.set_target_address(address);
-    proof.set_root_hash(get_root_hash());
     index_type node_index = 1;
     int curr_log2_size = HASH_TREE_LOG2_ROOT_SIZE;
     for (;;) {
@@ -152,9 +176,13 @@ hash_tree::proof_type hash_tree::get_proof(address_ranges ars, uint64_t address,
             break;
         }
         const auto &node = m_sparse_nodes[node_index];
+        // found node corresponding to root along the way
+        if (curr_log2_size == proof.get_log2_root_size()) {
+            proof.set_root_hash(node.hash);
+        }
         assert(std::cmp_equal(node.log2_size, curr_log2_size) && "incorrect node log2_size");
-        // hit sparse tree node
-        if (curr_log2_size == log2_size) {
+        // hit target at a sparse tree node
+        if (curr_log2_size == proof.get_log2_target_size()) {
             proof.set_target_hash(node.hash);
             break;
         }
@@ -169,10 +197,14 @@ hash_tree::proof_type hash_tree::get_proof(address_ranges ars, uint64_t address,
         // go down left or right on sparse tree depending on address
         --curr_log2_size;
         if ((address & (UINT64_C(1) << curr_log2_size)) == 0) {
-            proof.set_sibling_hash(get_sparse_node_hash_view(node.right, curr_log2_size), curr_log2_size);
+            if (curr_log2_size < log2_root_size && curr_log2_size >= log2_target_size) {
+                proof.set_sibling_hash(get_sparse_node_hash_view(node.right, curr_log2_size), curr_log2_size);
+            }
             node_index = node.left;
         } else {
-            proof.set_sibling_hash(get_sparse_node_hash_view(node.left, curr_log2_size), curr_log2_size);
+            if (curr_log2_size < log2_root_size && curr_log2_size >= log2_target_size) {
+                proof.set_sibling_hash(get_sparse_node_hash_view(node.left, curr_log2_size), curr_log2_size);
+            }
             node_index = node.right;
         }
     }
@@ -1061,6 +1093,10 @@ hash_tree::nodes_type hash_tree::create_nodes(const_address_ranges ars) {
 }
 
 // LCOV_EXCL_START
+#if defined(__GNUC__) && __GNUC__ >= 13
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdangling-reference"
+#endif
 void hash_tree::dump(const_address_ranges ars, std::ostream &out) {
     out << "digraph HashTree {\n";
     out << "  rankdir=TB;\n";
@@ -1130,6 +1166,9 @@ void hash_tree::dump(const_address_ranges ars, std::ostream &out) {
     }
     out << "}\n";
 }
+#if defined(__GNUC__) && __GNUC__ >= 13
+#pragma GCC diagnostic pop
+#endif
 // LCOV_EXCL_STOP
 
 } // namespace cartesi

src/hash-tree.h

@@ -172,7 +172,8 @@ class hash_tree {
 
     machine_hash get_root_hash() const noexcept;
     machine_hash get_node_hash(address_ranges ars, uint64_t address, int log2_size);
-    proof_type get_proof(address_ranges ars, uint64_t address, int log2_size);
+    proof_type get_proof(address_ranges ars, uint64_t address, int log2_target_size,
+        int log2_root_size = HASH_TREE_LOG2_ROOT_SIZE);
 
     void dump(const_address_ranges ars, std::ostream &out);
 

src/i-machine.h

@@ -24,6 +24,7 @@
 #include "access-log.h"
 #include "address-range-description.h"
 #include "back-merkle-tree.h"
+#include "hash-tree-constants.h"
 #include "hash-tree-proof.h"
 #include "hash-tree-stats.h"
 #include "interpret.h"
@@ -124,8 +125,9 @@ class i_machine {
     }
 
     /// \brief Obtains the proof for a node in the hash tree.
-    hash_tree_proof get_proof(uint64_t address, int log2_size) const {
-        return do_get_proof(address, log2_size);
+    hash_tree_proof get_proof(uint64_t address, int log2_target_size,
+        int log2_root_size = HASH_TREE_LOG2_ROOT_SIZE) const {
+        return do_get_proof(address, log2_target_size, log2_root_size);
     }
 
     /// \brief Obtains the root hash of the hash tree.
@@ -323,7 +325,7 @@ class i_machine {
     virtual void do_remove_stored(const std::string &dir) const = 0;
     virtual interpreter_break_reason do_log_step(uint64_t mcycle_count, const std::string &filename) = 0;
     virtual access_log do_log_step_uarch(const access_log::type &log_type) = 0;
-    virtual hash_tree_proof do_get_proof(uint64_t address, int log2_size) const = 0;
+    virtual hash_tree_proof do_get_proof(uint64_t address, int log2_target_size, int log2_root_size) const = 0;
     virtual machine_hash do_get_root_hash() const = 0;
     virtual machine_hash do_get_node_hash(uint64_t address, int log2_size) const = 0;
     virtual uint64_t do_read_reg(reg r) const = 0;

src/jsonrpc-discover.json

@@ -511,11 +511,24 @@
           }
         },
         {
-          "name": "log2_size",
-          "description": "Log2 of size of range",
+          "name": "log2_target_size",
+          "description": "Log2 of size of target range",
           "required": true,
           "schema": {
-            "$ref": "#/components/schemas/UnsignedInteger"
+            "$ref": "#/components/schemas/UnsignedInteger",
+            "minimum": 5,
+            "maximum": 64
+          }
+        },
+        {
+          "name": "log2_root_size",
+          "description": "Log2 of size of enclosing range",
+          "required": false,
+          "schema": {
+            "$ref": "#/components/schemas/UnsignedInteger",
+            "minimum": 5,
+            "maximum": 64,
+            "default": 64
           }
         }
       ],

src/jsonrpc-machine.cpp

@@ -810,9 +810,9 @@ machine_hash jsonrpc_machine::do_get_node_hash(uint64_t address, int log2_size)
     return hash;
 }
 
-hash_tree_proof jsonrpc_machine::do_get_proof(uint64_t address, int log2_size) const {
+hash_tree_proof jsonrpc_machine::do_get_proof(uint64_t address, int log2_target_size, int log2_root_size) const {
     not_default_constructible<hash_tree_proof> result;
-    request("machine.get_proof", std::tie(address, log2_size), result);
+    request("machine.get_proof", std::tie(address, log2_target_size, log2_root_size), result);
     if (!result.has_value()) {
         throw std::runtime_error("jsonrpc server error: missing result");
     }

src/jsonrpc-machine.h

@@ -135,7 +135,7 @@ class jsonrpc_machine final : public i_machine {
     access_log do_log_reset_uarch(const access_log::type &log_type) override;
     machine_hash do_get_root_hash() const override;
     machine_hash do_get_node_hash(uint64_t address, int log2_size) const override;
-    hash_tree_proof do_get_proof(uint64_t address, int log2_size) const override;
+    hash_tree_proof do_get_proof(uint64_t address, int log2_target_size, int log2_root_size) const override;
     void do_replace_memory_range(const memory_range_config &new_range) override;
     access_log do_log_step_uarch(const access_log::type &log_type) override;
     machine_runtime_config do_get_runtime_config() const override;

src/jsonrpc-remote-machine.cpp

@@ -120,6 +120,14 @@ static std::ostream &operator<<(std::ostream &out, log_prefix prefix) {
 using namespace std::string_literals;
 using json = nlohmann::json;
 
+/// \brief Checks if uint64_t value can be converted to integer
+static int check_int(uint64_t val, const char *what) {
+    if (val > INT_MAX) {
+        throw std::domain_error{std::string("value ").append(what).append(" is out of range")};
+    }
+    return static_cast<int>(val);
+}
+
 /// \brief Installs a signal handler
 template <typename HANDLER>
 static void install_signal_handler(int signum, HANDLER handler) {
@@ -1158,13 +1166,19 @@ static json jsonrpc_machine_get_proof_handler(const json &j, const std::shared_p
     if (!session->handler->machine) {
         return jsonrpc_response_invalid_request(j, "no machine");
     }
-    static const char *const param_name[] = {"address", "log2_size"};
-    auto args = parse_args<uint64_t, uint64_t>(j, param_name);
-    if (std::get<1>(args) > INT_MAX) {
-        throw std::domain_error("log2_size is out of range");
+    static const char *const param_name[] = {"address", "log2_target_size", "log2_root_size"};
+    auto args = parse_args<uint64_t, uint64_t, cartesi::optional_param<uint64_t>>(j, param_name);
+    switch (count_args(args)) {
+        case 2:
+            return jsonrpc_response_ok(j,
+                session->handler->machine->get_proof(std::get<0>(args), check_int(std::get<1>(args), param_name[1])));
+        case 3:
+            return jsonrpc_response_ok(j,
+                session->handler->machine->get_proof(std::get<0>(args), check_int(std::get<1>(args), param_name[1]),
+                    check_int(std::get<2>(args).value(), param_name[2]))); // NOLINT(bugprone-unchecked-optional-access)
+        default:
+            throw std::runtime_error{"error detecting number of arguments"};
     }
-    return jsonrpc_response_ok(j,
-        session->handler->machine->get_proof(std::get<0>(args), static_cast<int>(std::get<1>(args))));
 }
 
 /// \brief JSONRPC handler for the machine.get_hash_tree_stats method

src/local-machine.cpp

@@ -104,8 +104,8 @@ access_log local_machine::do_log_step_uarch(const access_log::type &log_type) {
     return get_machine()->log_step_uarch(log_type);
 }
 
-hash_tree_proof local_machine::do_get_proof(uint64_t address, int log2_size) const {
-    return get_machine()->get_proof(address, log2_size);
+hash_tree_proof local_machine::do_get_proof(uint64_t address, int log2_target_size, int log2_root_size) const {
+    return get_machine()->get_proof(address, log2_target_size, log2_root_size);
 }
 
 machine_hash local_machine::do_get_root_hash() const {

src/local-machine.h

@@ -63,7 +63,7 @@ class local_machine final : public i_machine {
     void do_clone_stored(const std::string &from_dir, const std::string &to_dir) const override;
     void do_remove_stored(const std::string &dir) const override;
     access_log do_log_step_uarch(const access_log::type &log_type) override;
-    hash_tree_proof do_get_proof(uint64_t address, int log2_size) const override;
+    hash_tree_proof do_get_proof(uint64_t address, int log2_target_size, int log2_root_size) const override;
     machine_hash do_get_root_hash() const override;
     machine_hash do_get_node_hash(uint64_t address, int log2_size) const override;
     bool do_verify_hash_tree() const override;