refactor(blocks tree): remove historic roots trees

circuits/cpp/src/aztec3/circuits/abis/c_bind.cpp

@@ -443,9 +443,21 @@ CBIND(abis__silo_nullifier, aztec3::circuits::silo_nullifier<NT>);
 
 /**
  * @brief Computes the block hash from the block information.
+ * Globals is provided as a hash in this instance.
  */
 CBIND(abis__compute_block_hash, aztec3::circuits::compute_block_hash<NT>);
 
+/**
+ * @brief Computes the block hash from the block information.
+ * The entire globals object is provided in this instance, rather than a hash as in above.
+ */
+CBIND(abis__compute_block_hash_with_globals, aztec3::circuits::compute_block_hash_with_globals<NT>);
+
+/**
+ * @brief Computes the hash of the global variables
+ */
+CBIND(abis__compute_globals_hash, aztec3::circuits::compute_globals_hash<NT>);
+
 /**
  * @brief Generates a signed tx request hash from it's pre-image
  * This is a WASM-export that can be called from Typescript.

circuits/cpp/src/aztec3/circuits/abis/c_bind.h

@@ -39,6 +39,8 @@ CBIND_DECL(abis__compute_unique_commitment);
 CBIND_DECL(abis__silo_commitment);
 CBIND_DECL(abis__silo_nullifier);
 CBIND_DECL(abis__compute_block_hash);
+CBIND_DECL(abis__compute_block_hash_with_globals);
+CBIND_DECL(abis__compute_globals_hash);
 
 WASM_EXPORT void abis__compute_message_secret_hash(uint8_t const* secret, uint8_t* output);
 WASM_EXPORT void abis__compute_contract_leaf(uint8_t const* contract_leaf_preimage_buf, uint8_t* output);

circuits/cpp/src/aztec3/circuits/abis/combined_constant_data.hpp

@@ -2,7 +2,7 @@
 
 #include "tx_context.hpp"
 
-#include "aztec3/circuits/abis/combined_historic_tree_roots.hpp"
+#include "aztec3/circuits/abis/constant_historic_block_data.hpp"
 #include "aztec3/utils/types/circuit_types.hpp"
 #include "aztec3/utils/types/convert.hpp"
 #include "aztec3/utils/types/native_types.hpp"
@@ -11,7 +11,7 @@
 
 namespace aztec3::circuits::abis {
 
-using aztec3::circuits::abis::CombinedHistoricTreeRoots;
+using aztec3::circuits::abis::ConstantHistoricBlockData;
 using aztec3::utils::types::CircuitTypes;
 using aztec3::utils::types::NativeTypes;
 using std::is_same;
@@ -20,22 +20,22 @@ template <typename NCT> struct CombinedConstantData {
     using fr = typename NCT::fr;
     using boolean = typename NCT::boolean;
 
-    CombinedHistoricTreeRoots<NCT> historic_tree_roots{};
+    ConstantHistoricBlockData<NCT> block_data{};
     TxContext<NCT> tx_context{};
 
     // for serialization: update up with new fields
-    MSGPACK_FIELDS(historic_tree_roots, tx_context);
+    MSGPACK_FIELDS(block_data, tx_context);
     boolean operator==(CombinedConstantData<NCT> const& other) const
     {
-        return historic_tree_roots == other.historic_tree_roots && tx_context == other.tx_context;
+        return block_data == other.block_data && tx_context == other.tx_context;
     }
 
     template <typename Builder> CombinedConstantData<CircuitTypes<Builder>> to_circuit_type(Builder& builder) const
     {
         static_assert((std::is_same<NativeTypes, NCT>::value));
 
         CombinedConstantData<CircuitTypes<Builder>> constant_data = {
-            historic_tree_roots.to_circuit_type(builder),
+            block_data.to_circuit_type(builder),
             tx_context.to_circuit_type(builder),
         };
 
@@ -49,7 +49,7 @@ template <typename NCT> struct CombinedConstantData {
         auto to_native_type = []<typename T>(T& e) { return e.template to_native_type<Builder>(); };
 
         CombinedConstantData<NativeTypes> constant_data = {
-            to_native_type(historic_tree_roots),
+            to_native_type(block_data),
             to_native_type(tx_context),
         };
 
@@ -60,14 +60,14 @@ template <typename NCT> struct CombinedConstantData {
     {
         static_assert(!(std::is_same<NativeTypes, NCT>::value));
 
-        historic_tree_roots.set_public();
+        block_data.set_public();
         tx_context.set_public();
     }
 };
 
 template <typename NCT> std::ostream& operator<<(std::ostream& os, CombinedConstantData<NCT> const& constant_data)
 {
-    return os << "historic_tree_roots: " << constant_data.historic_tree_roots << "\n"
+    return os << "block_data: " << constant_data.block_data << "\n"
               << "tx_context: " << constant_data.tx_context << "\n";
 }
 

circuits/cpp/src/aztec3/circuits/abis/private_historic_tree_roots.hpp → circuits/cpp/src/aztec3/circuits/abis/constant_historic_block_data.hpp

@@ -1,5 +1,8 @@
 #pragma once
 
+#include "aztec3/circuits/abis/append_only_tree_snapshot.hpp"
+#include "aztec3/circuits/abis/global_variables.hpp"
+#include "aztec3/circuits/hash.hpp"
 #include "aztec3/utils/types/circuit_types.hpp"
 #include "aztec3/utils/types/convert.hpp"
 #include "aztec3/utils/types/native_types.hpp"
@@ -12,57 +15,68 @@ using aztec3::utils::types::CircuitTypes;
 using aztec3::utils::types::NativeTypes;
 using std::is_same;
 
-template <typename NCT> struct PrivateHistoricTreeRoots {
+template <typename NCT> struct ConstantHistoricBlockData {
     using fr = typename NCT::fr;
     using boolean = typename NCT::boolean;
 
+    // Private data
     fr private_data_tree_root = 0;
     fr nullifier_tree_root = 0;
     fr contract_tree_root = 0;
     fr l1_to_l2_messages_tree_root = 0;
     fr blocks_tree_root = 0;
     fr private_kernel_vk_tree_root = 0;  // TODO: future enhancement
 
-    // for serialization: update up with new fields
+    // Public data
+    fr public_data_tree_root = 0;
+    fr prev_global_variables_hash = 0;
+
+    // for serialization, update with new fields
     MSGPACK_FIELDS(private_data_tree_root,
                    nullifier_tree_root,
                    contract_tree_root,
                    l1_to_l2_messages_tree_root,
                    blocks_tree_root,
-                   private_kernel_vk_tree_root);
+                   private_kernel_vk_tree_root,
+                   public_data_tree_root,
+                   prev_global_variables_hash);
 
-    boolean operator==(PrivateHistoricTreeRoots<NCT> const& other) const
+    boolean operator==(ConstantHistoricBlockData<NCT> const& other) const
     {
         return private_data_tree_root == other.private_data_tree_root &&
                nullifier_tree_root == other.nullifier_tree_root && contract_tree_root == other.contract_tree_root &&
                l1_to_l2_messages_tree_root == other.l1_to_l2_messages_tree_root &&
                blocks_tree_root == other.historic_block_root &&
-               private_kernel_vk_tree_root == other.private_kernel_vk_tree_root;
+               private_kernel_vk_tree_root == other.private_kernel_vk_tree_root &&
+               public_data_tree_root == other.public_data_tree_root &&
+               prev_global_variables_hash == other.prev_global_variables_hash;
     };
 
-    template <typename Builder> PrivateHistoricTreeRoots<CircuitTypes<Builder>> to_circuit_type(Builder& builder) const
+    template <typename Builder> ConstantHistoricBlockData<CircuitTypes<Builder>> to_circuit_type(Builder& builder) const
     {
         static_assert((std::is_same<NativeTypes, NCT>::value));
 
         // Capture the circuit builder:
         auto to_ct = [&](auto& e) { return aztec3::utils::types::to_ct(builder, e); };
 
-        PrivateHistoricTreeRoots<CircuitTypes<Builder>> data = {
-            to_ct(private_data_tree_root),      to_ct(nullifier_tree_root), to_ct(contract_tree_root),
-            to_ct(l1_to_l2_messages_tree_root), to_ct(blocks_tree_root),    to_ct(private_kernel_vk_tree_root),
+        ConstantHistoricBlockData<CircuitTypes<Builder>> data = {
+            to_ct(private_data_tree_root),      to_ct(nullifier_tree_root),        to_ct(contract_tree_root),
+            to_ct(l1_to_l2_messages_tree_root), to_ct(blocks_tree_root),           to_ct(private_kernel_vk_tree_root),
+            to_ct(public_data_tree_root),       to_ct(prev_global_variables_hash),
         };
 
         return data;
     };
 
-    template <typename Builder> PrivateHistoricTreeRoots<NativeTypes> to_native_type() const
+    template <typename Builder> ConstantHistoricBlockData<NativeTypes> to_native_type() const
     {
         static_assert(std::is_same<CircuitTypes<Builder>, NCT>::value);
         auto to_nt = [&](auto& e) { return aztec3::utils::types::to_nt<Builder>(e); };
 
-        PrivateHistoricTreeRoots<NativeTypes> data = {
-            to_nt(private_data_tree_root),      to_nt(nullifier_tree_root), to_nt(contract_tree_root),
-            to_nt(l1_to_l2_messages_tree_root), to_nt(blocks_tree_root),    to_nt(private_kernel_vk_tree_root),
+        ConstantHistoricBlockData<NativeTypes> data = {
+            to_nt(private_data_tree_root),      to_nt(nullifier_tree_root),        to_nt(contract_tree_root),
+            to_nt(l1_to_l2_messages_tree_root), to_nt(blocks_tree_root),           to_nt(private_kernel_vk_tree_root),
+            to_nt(public_data_tree_root),       to_nt(prev_global_variables_hash),
         };
 
         return data;
@@ -78,18 +92,33 @@ template <typename NCT> struct PrivateHistoricTreeRoots {
         l1_to_l2_messages_tree_root.set_public();
         blocks_tree_root.set_public();
         private_kernel_vk_tree_root.set_public();
+        public_data_tree_root.set_public();
+        prev_global_variables_hash.set_public();
+    }
+
+
+    fr hash()
+    {
+        return compute_block_hash(prev_global_variables_hash,
+                                  private_data_tree_root,
+                                  nullifier_tree_root,
+                                  contract_tree_root,
+                                  l1_to_l2_messages_tree_root,
+                                  public_data_tree_root);
     }
 };
 
 template <typename NCT>
-std::ostream& operator<<(std::ostream& os, PrivateHistoricTreeRoots<NCT> const& historic_tree_roots)
+std::ostream& operator<<(std::ostream& os, ConstantHistoricBlockData<NCT> const& historic_tree_roots)
 {
     return os << "private_data_tree_root: " << historic_tree_roots.private_data_tree_root << "\n"
               << "nullifier_tree_root: " << historic_tree_roots.nullifier_tree_root << "\n"
               << "contract_tree_root: " << historic_tree_roots.contract_tree_root << "\n"
               << "l1_to_l2_messages_tree_root: " << historic_tree_roots.l1_to_l2_messages_tree_root << "\n"
               << "blocks_tree_root: " << historic_tree_roots.blocks_tree_root << "\n"
-              << "private_kernel_vk_tree_root: " << historic_tree_roots.private_kernel_vk_tree_root << "\n";
+              << "private_kernel_vk_tree_root: " << historic_tree_roots.private_kernel_vk_tree_root << "\n"
+              << "public_data_tree_root: " << historic_tree_roots.public_data_tree_root << "\n"
+              << "prev_global_variables_hash: " << historic_tree_roots.prev_global_variables_hash << "\n";
 }
 
 }  // namespace aztec3::circuits::abis

circuits/cpp/src/aztec3/circuits/abis/global_variables.hpp

@@ -32,6 +32,17 @@ template <typename NCT> struct GlobalVariables {
                timestamp == other.timestamp;
     };
 
+    /**
+     * @brief Returns an object containing all global variables set to zero.
+     *
+     * @return GlobalVariables<NCT>
+     */
+    static GlobalVariables<NCT> empty()
+    {
+        GlobalVariables<NCT> globals = { 0, 0, 0, 0 };
+        return globals;
+    }
+
     template <typename Builder> GlobalVariables<CircuitTypes<Builder>> to_circuit_type(Builder& builder) const
     {
         static_assert((std::is_same<NativeTypes, NCT>::value));
@@ -50,6 +61,7 @@ template <typename NCT> struct GlobalVariables {
         return globals;
     };
 
+
     fr hash() const
     {
         std::vector<fr> inputs;
@@ -60,7 +72,17 @@ template <typename NCT> struct GlobalVariables {
 
         return NCT::compress(inputs, GeneratorIndex::GLOBAL_VARIABLES);
     }
-};
+
+    void set_public()
+    {
+        static_assert(!(std::is_same<NativeTypes, NCT>::value));
+
+        chain_id.set_public();
+        version.set_public();
+        block_number.set_public();
+        timestamp.set_public();
+    }
+};  // namespace aztec3::circuits::abis
 
 template <typename NCT> void read(uint8_t const*& it, GlobalVariables<NCT>& globals)
 {

circuits/cpp/src/aztec3/circuits/abis/packers.hpp

@@ -48,19 +48,16 @@ struct ConstantsPacker {
                  PUBLIC_DATA_TREE_HEIGHT,
                  NULLIFIER_TREE_HEIGHT,
                  L1_TO_L2_MSG_TREE_HEIGHT,
-                 PRIVATE_DATA_TREE_ROOTS_TREE_HEIGHT,
-                 CONTRACT_TREE_ROOTS_TREE_HEIGHT,
-                 L1_TO_L2_MSG_TREE_ROOTS_TREE_HEIGHT,
                  ROLLUP_VK_TREE_HEIGHT,
                  CONTRACT_SUBTREE_HEIGHT,
                  CONTRACT_SUBTREE_SIBLING_PATH_LENGTH,
                  PRIVATE_DATA_SUBTREE_HEIGHT,
                  PRIVATE_DATA_SUBTREE_SIBLING_PATH_LENGTH,
-                 NULLIFIER_SUBTREE_HEIGHT),
-             NVP(HISTORIC_BLOCKS_TREE_HEIGHT,
+                 NULLIFIER_SUBTREE_HEIGHT,
+                 HISTORIC_BLOCKS_TREE_HEIGHT,
                  NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH,
-                 L1_TO_L2_MSG_SUBTREE_HEIGHT,
-                 L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
+                 L1_TO_L2_MSG_SUBTREE_HEIGHT),
+             NVP(L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
                  FUNCTION_SELECTOR_NUM_BYTES,
                  MAPPING_SLOT_PEDERSEN_SEPARATOR,
                  NUM_FIELDS_PER_SHA256,
@@ -71,16 +68,16 @@ struct ConstantsPacker {
                  MAX_NOTES_PER_PAGE,
                  VIEW_NOTE_ORACLE_RETURN_LENGTH,
                  CALL_CONTEXT_LENGTH,
-                 COMMITMENT_TREES_ROOTS_LENGTH,
+                 CONSTANT_HISTORIC_BLOCK_DATA_LENGTH,
                  FUNCTION_DATA_LENGTH,
                  CONTRACT_DEPLOYMENT_DATA_LENGTH,
                  PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH,
                  CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH,
-                 CONTRACT_STORAGE_READ_LENGTH),
-             NVP(PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH,
+                 CONTRACT_STORAGE_READ_LENGTH,
+                 PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH,
                  GET_NOTES_ORACLE_RETURN_LENGTH,
-                 EMPTY_NULLIFIED_COMMITMENT,
-                 CALL_PRIVATE_FUNCTION_RETURN_SIZE,
+                 EMPTY_NULLIFIED_COMMITMENT),
+             NVP(CALL_PRIVATE_FUNCTION_RETURN_SIZE,
                  PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH,
                  PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH,
                  KERNELS_PER_BASE_ROLLUP,