feat: Contract updates

.github/workflows/network-deploy.yml

@@ -195,6 +195,7 @@ jobs:
               -var="AZTEC_DOCKER_IMAGE=${{ env.AZTEC_DOCKER_IMAGE }}" \
               -var="L1_DEPLOYMENT_PRIVATE_KEY=${{ secrets.SEPOLIA_L1_DEPLOYMENT_PRIVATE_KEY }}" \
               -var="L1_DEPLOYMENT_MNEMONIC=$L1_DEPLOYMENT_MNEMONIC" \
+              -var="BOT_L1_MNEMONIC=$L1_DEPLOYMENT_MNEMONIC" \
               -var="EXTERNAL_ETHEREUM_HOST=${{ env.EXTERNAL_ETHEREUM_HOST }}" \
               -var="EXTERNAL_ETHEREUM_CONSENSUS_HOST=${{ env.EXTERNAL_ETHEREUM_CONSENSUS_HOST }}" \
               -var="EXTERNAL_ETHEREUM_CONSENSUS_HOST_API_KEY=${{ secrets.SEPOLIA_API_KEY }}" \
@@ -207,6 +208,7 @@ jobs:
               -var="GKE_CLUSTER_CONTEXT=${{ env.GKE_CLUSTER_CONTEXT }}" \
               -var="AZTEC_DOCKER_IMAGE=${{ env.AZTEC_DOCKER_IMAGE }}" \
               -var="L1_DEPLOYMENT_MNEMONIC=${{ steps.get-mnemonic.outputs.mnemonic }}" \
+              -var="BOT_L1_MNEMONIC=$L1_DEPLOYMENT_MNEMONIC" \
               -lock=${{ inputs.respect_tf_lock }}
           fi
 
@@ -222,6 +224,7 @@ jobs:
               -var="AZTEC_DOCKER_IMAGE=${{ env.AZTEC_DOCKER_IMAGE }}" \
               -var="L1_DEPLOYMENT_PRIVATE_KEY=${{ secrets.SEPOLIA_L1_DEPLOYMENT_PRIVATE_KEY }}" \
               -var="L1_DEPLOYMENT_MNEMONIC=$L1_DEPLOYMENT_MNEMONIC" \
+              -var="BOT_L1_MNEMONIC=$L1_DEPLOYMENT_MNEMONIC" \
               -var="L1_DEPLOYMENT_SALT=${DEPLOYMENT_SALT:-$RANDOM}" \
               -var="EXTERNAL_ETHEREUM_HOST=${{ env.EXTERNAL_ETHEREUM_HOST }}" \
               -var="EXTERNAL_ETHEREUM_CONSENSUS_HOST=${{ env.EXTERNAL_ETHEREUM_CONSENSUS_HOST }}" \
@@ -237,6 +240,7 @@ jobs:
               -var="AZTEC_DOCKER_IMAGE=${{ env.AZTEC_DOCKER_IMAGE }}" \
               -var="L1_DEPLOYMENT_MNEMONIC=${{ steps.get-mnemonic.outputs.mnemonic }}" \
               -var="L1_DEPLOYMENT_SALT=${DEPLOYMENT_SALT:-$RANDOM}" \
+              -var="BOT_L1_MNEMONIC=$L1_DEPLOYMENT_MNEMONIC" \
               -out=tfplan \
               -lock=${{ inputs.respect_tf_lock }}
           fi

barretenberg/cpp/src/barretenberg/crypto/merkle_tree/indexed_tree/content_addressed_indexed_tree.hpp

@@ -57,7 +57,12 @@ class ContentAddressedIndexedTree : public ContentAddressedAppendOnlyTree<Store,
 
     ContentAddressedIndexedTree(std::unique_ptr<Store> store,
                                 std::shared_ptr<ThreadPool> workers,
-                                const index_t& initial_size);
+                                const index_t& initial_size,
+                                const std::vector<LeafValueType>& prefilled_values);
+    ContentAddressedIndexedTree(std::unique_ptr<Store> store,
+                                std::shared_ptr<ThreadPool> workers,
+                                const index_t& initial_size)
+        : ContentAddressedIndexedTree(std::move(store), workers, initial_size, std::vector<LeafValueType>()){};
     ContentAddressedIndexedTree(ContentAddressedIndexedTree const& other) = delete;
     ContentAddressedIndexedTree(ContentAddressedIndexedTree&& other) = delete;
     ~ContentAddressedIndexedTree() = default;
@@ -265,14 +270,19 @@ class ContentAddressedIndexedTree : public ContentAddressedAppendOnlyTree<Store,
 };
 
 template <typename Store, typename HashingPolicy>
-ContentAddressedIndexedTree<Store, HashingPolicy>::ContentAddressedIndexedTree(std::unique_ptr<Store> store,
-                                                                               std::shared_ptr<ThreadPool> workers,
-                                                                               const index_t& initial_size)
+ContentAddressedIndexedTree<Store, HashingPolicy>::ContentAddressedIndexedTree(
+    std::unique_ptr<Store> store,
+    std::shared_ptr<ThreadPool> workers,
+    const index_t& initial_size,
+    const std::vector<LeafValueType>& prefilled_values)
     : ContentAddressedAppendOnlyTree<Store, HashingPolicy>(std::move(store), workers, {}, false)
 {
     if (initial_size < 2) {
         throw std::runtime_error("Indexed trees must have initial size > 1");
     }
+    if (prefilled_values.size() > initial_size) {
+        throw std::runtime_error("Number of prefilled values can't be more than initial size");
+    }
     zero_hashes_.resize(depth_ + 1);
 
     // Create the zero hashes for the tree
@@ -293,12 +303,23 @@ ContentAddressedIndexedTree<Store, HashingPolicy>::ContentAddressedIndexedTree(s
 
     std::vector<IndexedLeafValueType> appended_leaves;
     std::vector<bb::fr> appended_hashes;
+    std::vector<LeafValueType> initial_set;
+    auto num_default_values = static_cast<uint32_t>(initial_size - prefilled_values.size());
+    for (uint32_t i = 0; i < num_default_values; ++i) {
+        initial_set.push_back(LeafValueType::padding(i));
+    }
+    initial_set.insert(initial_set.end(), prefilled_values.begin(), prefilled_values.end());
+    for (uint32_t i = num_default_values; i < initial_size; ++i) {
+        if (i > 0 && (uint256_t(initial_set[i].get_key()) <= uint256_t(initial_set[i - 1].get_key()))) {
+            const auto* msg = i == num_default_values ? "Prefilled values must not be the same as the default values"
+                                                      : "Prefilled values must be unique and sorted";
+            throw std::runtime_error(msg);
+        }
+    }
     // Inserts the initial set of leaves as a chain in incrementing value order
     for (uint32_t i = 0; i < initial_size; ++i) {
-        // Insert the zero leaf to the `leaves` and also to the tree at index 0.
-        bool last = i == (initial_size - 1);
-        IndexedLeafValueType initial_leaf =
-            IndexedLeafValueType(LeafValueType::padding(i), last ? 0 : i + 1, last ? 0 : i + 1);
+        uint32_t next_index = i == (initial_size - 1) ? 0 : i + 1;
+        auto initial_leaf = IndexedLeafValueType(initial_set[i], next_index, initial_set[next_index].get_key());
         fr leaf_hash = HashingPolicy::hash(initial_leaf.get_hash_inputs());
         appended_leaves.push_back(initial_leaf);
         appended_hashes.push_back(leaf_hash);

barretenberg/cpp/src/barretenberg/crypto/merkle_tree/indexed_tree/content_addressed_indexed_tree.test.cpp

@@ -32,6 +32,9 @@ using HashPolicy = Poseidon2HashPolicy;
 using Store = ContentAddressedCachedTreeStore<NullifierLeafValue>;
 using TreeType = ContentAddressedIndexedTree<Store, HashPolicy>;
 
+using PublicDataStore = ContentAddressedCachedTreeStore<PublicDataLeafValue>;
+using PublicDataTreeType = ContentAddressedIndexedTree<PublicDataStore, Poseidon2HashPolicy>;
+
 using CompletionCallback = TreeType::AddCompletionCallbackWithWitness;
 using SequentialCompletionCallback = TreeType::AddSequentiallyCompletionCallbackWithWitness;
 
@@ -2775,6 +2778,102 @@ TEST_F(PersistedContentAddressedIndexedTreeTest, can_sync_and_unwind_empty_block
     }
 }
 
+TEST_F(PersistedContentAddressedIndexedTreeTest, test_prefilled_public_data)
+{
+    ThreadPoolPtr workers = make_thread_pool(1);
+    constexpr size_t depth = 3;
+    std::string name = random_string();
+    LMDBTreeStore::SharedPtr db = std::make_shared<LMDBTreeStore>(_directory, name, _mapSize, _maxReaders);
+    std::unique_ptr<PublicDataStore> store = std::make_unique<PublicDataStore>(name, depth, db);
+
+    index_t initial_size = 4;
+    std::vector<PublicDataLeafValue> prefilled_values = { PublicDataLeafValue(3, 9), PublicDataLeafValue(5, 7) };
+    auto tree = PublicDataTreeType(std::move(store), workers, initial_size, prefilled_values);
+
+    /**
+     * Intial state:
+     *
+     *  index     0       1       2       3        4       5       6       7
+     *  ---------------------------------------------------------------------
+     *  slot      0       1       3       5        0       0       0       0
+     *  val       0       0       9       7        0       0       0       0
+     *  nextIdx   1       2       3       0        0       0       0       0
+     *  nextVal   1       3       5       0        0       0       0       0
+     */
+    IndexedPublicDataLeafType leaf_0 = create_indexed_public_data_leaf(0, 0, 1, 1);
+    IndexedPublicDataLeafType leaf_1 = create_indexed_public_data_leaf(1, 0, 2, 3);
+    IndexedPublicDataLeafType leaf_2 = create_indexed_public_data_leaf(3, 9, 3, 5);
+    IndexedPublicDataLeafType leaf_3 = create_indexed_public_data_leaf(5, 7, 0, 0);
+    check_size(tree, initial_size);
+    EXPECT_EQ(get_leaf<PublicDataLeafValue>(tree, 0), leaf_0);
+    EXPECT_EQ(get_leaf<PublicDataLeafValue>(tree, 1), leaf_1);
+    EXPECT_EQ(get_leaf<PublicDataLeafValue>(tree, 2), leaf_2);
+    EXPECT_EQ(get_leaf<PublicDataLeafValue>(tree, 3), leaf_3);
+}
+
+TEST_F(PersistedContentAddressedIndexedTreeTest, test_full_prefilled_public_data)
+{
+    ThreadPoolPtr workers = make_thread_pool(1);
+    constexpr size_t depth = 3;
+    std::string name = random_string();
+    LMDBTreeStore::SharedPtr db = std::make_shared<LMDBTreeStore>(_directory, name, _mapSize, _maxReaders);
+    std::unique_ptr<PublicDataStore> store = std::make_unique<PublicDataStore>(name, depth, db);
+
+    index_t initial_size = 4;
+    std::vector<PublicDataLeafValue> prefilled_values = {
+        PublicDataLeafValue(1, 2), PublicDataLeafValue(3, 4), PublicDataLeafValue(5, 6), PublicDataLeafValue(7, 8)
+    };
+    auto tree = PublicDataTreeType(std::move(store), workers, initial_size, prefilled_values);
+
+    /**
+     * Intial state:
+     *
+     *  index     0       1       2       3        4       5       6       7
+     *  ---------------------------------------------------------------------
+     *  slot      0       1       3       5        0       0       0       0
+     *  val       0       0       9       7        0       0       0       0
+     *  nextIdx   1       2       3       0        0       0       0       0
+     *  nextVal   1       3       5       0        0       0       0       0
+     */
+    IndexedPublicDataLeafType leaf_0 = create_indexed_public_data_leaf(1, 2, 1, 3);
+    IndexedPublicDataLeafType leaf_1 = create_indexed_public_data_leaf(3, 4, 2, 5);
+    IndexedPublicDataLeafType leaf_2 = create_indexed_public_data_leaf(5, 6, 3, 7);
+    IndexedPublicDataLeafType leaf_3 = create_indexed_public_data_leaf(7, 8, 0, 1);
+    check_size(tree, initial_size);
+    EXPECT_EQ(get_leaf<PublicDataLeafValue>(tree, 0), leaf_0);
+    EXPECT_EQ(get_leaf<PublicDataLeafValue>(tree, 1), leaf_1);
+    EXPECT_EQ(get_leaf<PublicDataLeafValue>(tree, 2), leaf_2);
+    EXPECT_EQ(get_leaf<PublicDataLeafValue>(tree, 3), leaf_3);
+}
+
+TEST_F(PersistedContentAddressedIndexedTreeTest, test_prefilled_unsorted_public_data_should_fail)
+{
+    ThreadPoolPtr workers = make_thread_pool(1);
+    constexpr size_t depth = 3;
+    std::string name = random_string();
+    LMDBTreeStore::SharedPtr db = std::make_shared<LMDBTreeStore>(_directory, name, _mapSize, _maxReaders);
+    std::unique_ptr<PublicDataStore> store = std::make_unique<PublicDataStore>(name, depth, db);
+
+    index_t initial_size = 4;
+    // The prefilled values are not sorted: 5 > 3.
+    std::vector<PublicDataLeafValue> prefilled_values = { PublicDataLeafValue(5, 7), PublicDataLeafValue(3, 9) };
+    EXPECT_THROW(PublicDataTreeType(std::move(store), workers, initial_size, prefilled_values), std::runtime_error);
+}
+
+TEST_F(PersistedContentAddressedIndexedTreeTest, test_prefilled_default_public_data_should_fail)
+{
+    ThreadPoolPtr workers = make_thread_pool(1);
+    constexpr size_t depth = 3;
+    std::string name = random_string();
+    LMDBTreeStore::SharedPtr db = std::make_shared<LMDBTreeStore>(_directory, name, _mapSize, _maxReaders);
+    std::unique_ptr<PublicDataStore> store = std::make_unique<PublicDataStore>(name, depth, db);
+
+    index_t initial_size = 4;
+    // The first prefilled value is the same as one of the default values (1).
+    std::vector<PublicDataLeafValue> prefilled_values = { PublicDataLeafValue(1, 9), PublicDataLeafValue(5, 7) };
+    EXPECT_THROW(PublicDataTreeType(std::move(store), workers, initial_size, prefilled_values), std::runtime_error);
+}
+
 TEST_F(PersistedContentAddressedIndexedTreeTest, test_can_commit_and_revert_checkpoints)
 {
     index_t initial_size = 2;

barretenberg/cpp/src/barretenberg/nodejs_module/world_state/world_state.cpp

@@ -46,6 +46,7 @@ WorldStateWrapper::WorldStateWrapper(const Napi::CallbackInfo& info)
     };
     std::unordered_map<MerkleTreeId, uint32_t> tree_height;
     std::unordered_map<MerkleTreeId, index_t> tree_prefill;
+    std::vector<PublicDataLeafValue> prefilled_public_data;
     std::vector<MerkleTreeId> tree_ids{
         MerkleTreeId::NULLIFIER_TREE,        MerkleTreeId::NOTE_HASH_TREE, MerkleTreeId::PUBLIC_DATA_TREE,
         MerkleTreeId::L1_TO_L2_MESSAGE_TREE, MerkleTreeId::ARCHIVE,
@@ -87,15 +88,38 @@ WorldStateWrapper::WorldStateWrapper(const Napi::CallbackInfo& info)
         throw Napi::TypeError::New(env, "Tree prefill must be a map");
     }
 
-    size_t initial_header_generator_point_index = 3;
+    size_t prefilled_public_data_index = 3;
+    if (info.Length() > prefilled_public_data_index && info[prefilled_public_data_index].IsArray()) {
+        Napi::Array arr = info[prefilled_public_data_index].As<Napi::Array>();
+        for (uint32_t i = 0; i < arr.Length(); ++i) {
+            Napi::Array deserialized = arr.Get(i).As<Napi::Array>();
+            if (deserialized.Length() != 2 || !deserialized.Get(uint32_t(0)).IsBuffer() ||
+                !deserialized.Get(uint32_t(1)).IsBuffer()) {
+                throw Napi::TypeError::New(env, "Prefilled public data value must be a buffer array of size 2");
+            }
+            Napi::Buffer<uint8_t> slot_buf = deserialized.Get(uint32_t(0)).As<Napi::Buffer<uint8_t>>();
+            Napi::Buffer<uint8_t> value_buf = deserialized.Get(uint32_t(1)).As<Napi::Buffer<uint8_t>>();
+            uint256_t slot = 0;
+            uint256_t value = 0;
+            for (size_t j = 0; j < 32; ++j) {
+                slot = (slot << 8) | slot_buf[j];
+                value = (value << 8) | value_buf[j];
+            }
+            prefilled_public_data.push_back(PublicDataLeafValue(slot, value));
+        }
+    } else {
+        throw Napi::TypeError::New(env, "Prefilled public data must be an array");
+    }
+
+    size_t initial_header_generator_point_index = 4;
     if (info.Length() > initial_header_generator_point_index && info[initial_header_generator_point_index].IsNumber()) {
         initial_header_generator_point = info[initial_header_generator_point_index].As<Napi::Number>().Uint32Value();
     } else {
         throw Napi::TypeError::New(env, "Header generator point needs to be a number");
     }
 
     // optional parameters
-    size_t map_size_index = 4;
+    size_t map_size_index = 5;
     if (info.Length() > map_size_index) {
         if (info[4].IsObject()) {
             Napi::Object obj = info[map_size_index].As<Napi::Object>();
@@ -115,7 +139,7 @@ WorldStateWrapper::WorldStateWrapper(const Napi::CallbackInfo& info)
         }
     }
 
-    size_t thread_pool_size_index = 5;
+    size_t thread_pool_size_index = 6;
     if (info.Length() > thread_pool_size_index) {
         if (!info[thread_pool_size_index].IsNumber()) {
             throw Napi::TypeError::New(env, "Thread pool size must be a number");
@@ -124,8 +148,13 @@ WorldStateWrapper::WorldStateWrapper(const Napi::CallbackInfo& info)
         thread_pool_size = info[thread_pool_size_index].As<Napi::Number>().Uint32Value();
     }
 
-    _ws = std::make_unique<WorldState>(
-        thread_pool_size, data_dir, map_size, tree_height, tree_prefill, initial_header_generator_point);
+    _ws = std::make_unique<WorldState>(thread_pool_size,
+                                       data_dir,
+                                       map_size,
+                                       tree_height,
+                                       tree_prefill,
+                                       prefilled_public_data,
+                                       initial_header_generator_point);
 
     _dispatcher.registerTarget(
         WorldStateMessageType::GET_TREE_INFO,

barretenberg/cpp/src/barretenberg/vm/avm/tests/execution.test.cpp

@@ -122,9 +122,11 @@ class AvmExecutionTests : public ::testing::Test {
         auto tagging_key = grumpkin::g1::affine_one;
         PublicKeysHint public_keys{ nullifier_key, incoming_viewing_key, outgoing_viewing_key, tagging_key };
         ContractInstanceHint contract_instance = {
-            FF::one() /* temp address */,    true /* exists */, FF(2) /* salt */, FF(3) /* deployer_addr */, class_id,
+            FF::one() /* temp address */,    true /* exists */, FF(2) /* salt */, FF(3) /* deployer_addr */, class_id, class_id,
             FF(8) /* initialisation_hash */, public_keys,
             /*membership_hint=*/ { .low_leaf_preimage = { .nullifier = 0, .next_nullifier = 0, .next_index = 0, }, .low_leaf_index = 0, .low_leaf_sibling_path = {} },
+            /* update_hint*/ { .leaf_preimage = { .slot = 0, .value = 0,  .next_index = 0, .next_slot = 0, }, .leaf_index = 0, .sibling_path = {} },
+            /* update_preimage */ {},
         };
         FF address = AvmBytecodeTraceBuilder::compute_address_from_instance(contract_instance);
         contract_instance.address = address;
@@ -2293,10 +2295,13 @@ TEST_F(AvmExecutionTests, opGetContractInstanceOpcode)
         .exists = true,
         .salt = 2,
         .deployer_addr = 42,
-        .contract_class_id = 66,
+        .current_contract_class_id = 66,
+        .original_contract_class_id = 66,
         .initialisation_hash = 99,
         .public_keys = public_keys_hints,
-        .membership_hint = { .low_leaf_preimage = { .nullifier = 0, .next_nullifier = 0, .next_index = 0, }, .low_leaf_index = 0, .low_leaf_sibling_path = {} },
+        .initialization_membership_hint = { .low_leaf_preimage = { .nullifier = 0, .next_nullifier = 0, .next_index = 0, }, .low_leaf_index = 0, .low_leaf_sibling_path = {} },
+        .update_membership_hint = { .leaf_preimage = { .slot = 0, .value = 0,  .next_index = 0, .next_slot = 0, }, .leaf_index = 0, .sibling_path = {} },
+        .update_preimage = {}
     };
     auto execution_hints = ExecutionHints().with_contract_instance_hints({ { address, instance } });
 
@@ -2341,7 +2346,7 @@ TEST_F(AvmExecutionTests, opGetContractInstanceOpcode)
     std::vector<FF> const calldata{};
     // alternating member value, exists bool
     std::vector<FF> const expected_returndata = {
-        instance.deployer_addr, 1, instance.contract_class_id, 1, instance.initialisation_hash, 1,
+        instance.deployer_addr, 1, instance.current_contract_class_id, 1, instance.initialisation_hash, 1,
     };
 
     std::vector<FF> returndata{};

barretenberg/cpp/src/barretenberg/vm/avm/trace/bytecode_trace.cpp

@@ -32,7 +32,7 @@ FF AvmBytecodeTraceBuilder::compute_address_from_instance(const ContractInstance
                                                       contract_instance.initialisation_hash,
                                                       contract_instance.deployer_addr });
     FF partial_address = poseidon2::hash(
-        { GENERATOR_INDEX__PARTIAL_ADDRESS, contract_instance.contract_class_id, salted_initialization_hash });
+        { GENERATOR_INDEX__PARTIAL_ADDRESS, contract_instance.original_contract_class_id, salted_initialization_hash });
 
     std::vector<FF> public_keys_hash_fields = contract_instance.public_keys.to_fields();
     std::vector<FF> public_key_hash_vec{ GENERATOR_INDEX__PUBLIC_KEYS_HASH };
@@ -144,7 +144,7 @@ void AvmBytecodeTraceBuilder::build_bytecode_hash_columns()
                                           contract_bytecode.contract_class_id_preimage.private_fn_root,
                                           running_hash);
             // Assert that the computed class id is the same as what we received as the hint
-            ASSERT(last_entry.class_id == contract_bytecode.contract_instance.contract_class_id);
+            ASSERT(last_entry.class_id == contract_bytecode.contract_instance.current_contract_class_id);
 
             last_entry.contract_address = compute_address_from_instance(contract_bytecode.contract_instance);
             // Assert that the computed contract address is the same as what we received as the hint