diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp
index 171bcfa280e7..9fb0e2b3a35c 100644
--- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp
+++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp
@@ -317,6 +317,33 @@ struct BlockId {
     static BlockId bincodeDeserialize(std::vector<uint8_t>);
 };
 
+struct BlockType {
+
+    struct Memory {
+        friend bool operator==(const Memory&, const Memory&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static Memory bincodeDeserialize(std::vector<uint8_t>);
+    };
+
+    struct CallData {
+        friend bool operator==(const CallData&, const CallData&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static CallData bincodeDeserialize(std::vector<uint8_t>);
+    };
+
+    struct ReturnData {
+        friend bool operator==(const ReturnData&, const ReturnData&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static ReturnData bincodeDeserialize(std::vector<uint8_t>);
+    };
+
+    std::variant<Memory, CallData, ReturnData> value;
+
+    friend bool operator==(const BlockType&, const BlockType&);
+    std::vector<uint8_t> bincodeSerialize() const;
+    static BlockType bincodeDeserialize(std::vector<uint8_t>);
+};
+
 struct Expression {
     std::vector<std::tuple<std::string, Program::Witness, Program::Witness>> mul_terms;
     std::vector<std::tuple<std::string, Program::Witness>> linear_combinations;
@@ -453,6 +480,7 @@ struct Opcode {
     struct MemoryInit {
         Program::BlockId block_id;
         std::vector<Program::Witness> init;
+        Program::BlockType block_type;
 
         friend bool operator==(const MemoryInit&, const MemoryInit&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -5162,6 +5190,177 @@ Program::BlockId serde::Deserializable<Program::BlockId>::deserialize(Deserializ
 
 namespace Program {
 
+inline bool operator==(const BlockType& lhs, const BlockType& rhs)
+{
+    if (!(lhs.value == rhs.value)) {
+        return false;
+    }
+    return true;
+}
+
+inline std::vector<uint8_t> BlockType::bincodeSerialize() const
+{
+    auto serializer = serde::BincodeSerializer();
+    serde::Serializable<BlockType>::serialize(*this, serializer);
+    return std::move(serializer).bytes();
+}
+
+inline BlockType BlockType::bincodeDeserialize(std::vector<uint8_t> input)
+{
+    auto deserializer = serde::BincodeDeserializer(input);
+    auto value = serde::Deserializable<BlockType>::deserialize(deserializer);
+    if (deserializer.get_buffer_offset() < input.size()) {
+        throw_or_abort("Some input bytes were not read");
+    }
+    return value;
+}
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::BlockType>::serialize(const Program::BlockType& obj, Serializer& serializer)
+{
+    serializer.increase_container_depth();
+    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+    serializer.decrease_container_depth();
+}
+
+template <>
+template <typename Deserializer>
+Program::BlockType serde::Deserializable<Program::BlockType>::deserialize(Deserializer& deserializer)
+{
+    deserializer.increase_container_depth();
+    Program::BlockType obj;
+    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    deserializer.decrease_container_depth();
+    return obj;
+}
+
+namespace Program {
+
+inline bool operator==(const BlockType::Memory& lhs, const BlockType::Memory& rhs)
+{
+    return true;
+}
+
+inline std::vector<uint8_t> BlockType::Memory::bincodeSerialize() const
+{
+    auto serializer = serde::BincodeSerializer();
+    serde::Serializable<BlockType::Memory>::serialize(*this, serializer);
+    return std::move(serializer).bytes();
+}
+
+inline BlockType::Memory BlockType::Memory::bincodeDeserialize(std::vector<uint8_t> input)
+{
+    auto deserializer = serde::BincodeDeserializer(input);
+    auto value = serde::Deserializable<BlockType::Memory>::deserialize(deserializer);
+    if (deserializer.get_buffer_offset() < input.size()) {
+        throw_or_abort("Some input bytes were not read");
+    }
+    return value;
+}
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::BlockType::Memory>::serialize(const Program::BlockType::Memory& obj,
+                                                                Serializer& serializer)
+{}
+
+template <>
+template <typename Deserializer>
+Program::BlockType::Memory serde::Deserializable<Program::BlockType::Memory>::deserialize(Deserializer& deserializer)
+{
+    Program::BlockType::Memory obj;
+    return obj;
+}
+
+namespace Program {
+
+inline bool operator==(const BlockType::CallData& lhs, const BlockType::CallData& rhs)
+{
+    return true;
+}
+
+inline std::vector<uint8_t> BlockType::CallData::bincodeSerialize() const
+{
+    auto serializer = serde::BincodeSerializer();
+    serde::Serializable<BlockType::CallData>::serialize(*this, serializer);
+    return std::move(serializer).bytes();
+}
+
+inline BlockType::CallData BlockType::CallData::bincodeDeserialize(std::vector<uint8_t> input)
+{
+    auto deserializer = serde::BincodeDeserializer(input);
+    auto value = serde::Deserializable<BlockType::CallData>::deserialize(deserializer);
+    if (deserializer.get_buffer_offset() < input.size()) {
+        throw_or_abort("Some input bytes were not read");
+    }
+    return value;
+}
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::BlockType::CallData>::serialize(const Program::BlockType::CallData& obj,
+                                                                  Serializer& serializer)
+{}
+
+template <>
+template <typename Deserializer>
+Program::BlockType::CallData serde::Deserializable<Program::BlockType::CallData>::deserialize(
+    Deserializer& deserializer)
+{
+    Program::BlockType::CallData obj;
+    return obj;
+}
+
+namespace Program {
+
+inline bool operator==(const BlockType::ReturnData& lhs, const BlockType::ReturnData& rhs)
+{
+    return true;
+}
+
+inline std::vector<uint8_t> BlockType::ReturnData::bincodeSerialize() const
+{
+    auto serializer = serde::BincodeSerializer();
+    serde::Serializable<BlockType::ReturnData>::serialize(*this, serializer);
+    return std::move(serializer).bytes();
+}
+
+inline BlockType::ReturnData BlockType::ReturnData::bincodeDeserialize(std::vector<uint8_t> input)
+{
+    auto deserializer = serde::BincodeDeserializer(input);
+    auto value = serde::Deserializable<BlockType::ReturnData>::deserialize(deserializer);
+    if (deserializer.get_buffer_offset() < input.size()) {
+        throw_or_abort("Some input bytes were not read");
+    }
+    return value;
+}
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::BlockType::ReturnData>::serialize(const Program::BlockType::ReturnData& obj,
+                                                                    Serializer& serializer)
+{}
+
+template <>
+template <typename Deserializer>
+Program::BlockType::ReturnData serde::Deserializable<Program::BlockType::ReturnData>::deserialize(
+    Deserializer& deserializer)
+{
+    Program::BlockType::ReturnData obj;
+    return obj;
+}
+
+namespace Program {
+
 inline bool operator==(const BrilligBytecode& lhs, const BrilligBytecode& rhs)
 {
     if (!(lhs.bytecode == rhs.bytecode)) {
@@ -7812,6 +8011,9 @@ inline bool operator==(const Opcode::MemoryInit& lhs, const Opcode::MemoryInit&
     if (!(lhs.init == rhs.init)) {
         return false;
     }
+    if (!(lhs.block_type == rhs.block_type)) {
+        return false;
+    }
     return true;
 }
 
@@ -7841,6 +8043,7 @@ void serde::Serializable<Program::Opcode::MemoryInit>::serialize(const Program::
 {
     serde::Serializable<decltype(obj.block_id)>::serialize(obj.block_id, serializer);
     serde::Serializable<decltype(obj.init)>::serialize(obj.init, serializer);
+    serde::Serializable<decltype(obj.block_type)>::serialize(obj.block_type, serializer);
 }
 
 template <>
@@ -7850,6 +8053,7 @@ Program::Opcode::MemoryInit serde::Deserializable<Program::Opcode::MemoryInit>::
     Program::Opcode::MemoryInit obj;
     obj.block_id = serde::Deserializable<decltype(obj.block_id)>::deserialize(deserializer);
     obj.init = serde::Deserializable<decltype(obj.init)>::deserialize(deserializer);
+    obj.block_type = serde::Deserializable<decltype(obj.block_type)>::deserialize(deserializer);
     return obj;
 }
 
diff --git a/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp b/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp
index b7e75c4320dc..5afcd68e987b 100644
--- a/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp
+++ b/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp
@@ -292,6 +292,33 @@ namespace Program {
         static BlockId bincodeDeserialize(std::vector<uint8_t>);
     };
 
+    struct BlockType {
+
+        struct Memory {
+            friend bool operator==(const Memory&, const Memory&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Memory bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct CallData {
+            friend bool operator==(const CallData&, const CallData&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static CallData bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct ReturnData {
+            friend bool operator==(const ReturnData&, const ReturnData&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static ReturnData bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        std::variant<Memory, CallData, ReturnData> value;
+
+        friend bool operator==(const BlockType&, const BlockType&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static BlockType bincodeDeserialize(std::vector<uint8_t>);
+    };
+
     struct Expression {
         std::vector<std::tuple<std::string, Program::Witness, Program::Witness>> mul_terms;
         std::vector<std::tuple<std::string, Program::Witness>> linear_combinations;
@@ -428,6 +455,7 @@ namespace Program {
         struct MemoryInit {
             Program::BlockId block_id;
             std::vector<Program::Witness> init;
+            Program::BlockType block_type;
 
             friend bool operator==(const MemoryInit&, const MemoryInit&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -4307,6 +4335,153 @@ Program::BlockId serde::Deserializable<Program::BlockId>::deserialize(Deserializ
     return obj;
 }
 
+namespace Program {
+
+    inline bool operator==(const BlockType &lhs, const BlockType &rhs) {
+        if (!(lhs.value == rhs.value)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlockType::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlockType>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlockType BlockType::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlockType>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::BlockType>::serialize(const Program::BlockType &obj, Serializer &serializer) {
+    serializer.increase_container_depth();
+    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+    serializer.decrease_container_depth();
+}
+
+template <>
+template <typename Deserializer>
+Program::BlockType serde::Deserializable<Program::BlockType>::deserialize(Deserializer &deserializer) {
+    deserializer.increase_container_depth();
+    Program::BlockType obj;
+    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    deserializer.decrease_container_depth();
+    return obj;
+}
+
+namespace Program {
+
+    inline bool operator==(const BlockType::Memory &lhs, const BlockType::Memory &rhs) {
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlockType::Memory::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlockType::Memory>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlockType::Memory BlockType::Memory::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlockType::Memory>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::BlockType::Memory>::serialize(const Program::BlockType::Memory &obj, Serializer &serializer) {
+}
+
+template <>
+template <typename Deserializer>
+Program::BlockType::Memory serde::Deserializable<Program::BlockType::Memory>::deserialize(Deserializer &deserializer) {
+    Program::BlockType::Memory obj;
+    return obj;
+}
+
+namespace Program {
+
+    inline bool operator==(const BlockType::CallData &lhs, const BlockType::CallData &rhs) {
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlockType::CallData::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlockType::CallData>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlockType::CallData BlockType::CallData::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlockType::CallData>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::BlockType::CallData>::serialize(const Program::BlockType::CallData &obj, Serializer &serializer) {
+}
+
+template <>
+template <typename Deserializer>
+Program::BlockType::CallData serde::Deserializable<Program::BlockType::CallData>::deserialize(Deserializer &deserializer) {
+    Program::BlockType::CallData obj;
+    return obj;
+}
+
+namespace Program {
+
+    inline bool operator==(const BlockType::ReturnData &lhs, const BlockType::ReturnData &rhs) {
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlockType::ReturnData::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlockType::ReturnData>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlockType::ReturnData BlockType::ReturnData::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlockType::ReturnData>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::BlockType::ReturnData>::serialize(const Program::BlockType::ReturnData &obj, Serializer &serializer) {
+}
+
+template <>
+template <typename Deserializer>
+Program::BlockType::ReturnData serde::Deserializable<Program::BlockType::ReturnData>::deserialize(Deserializer &deserializer) {
+    Program::BlockType::ReturnData obj;
+    return obj;
+}
+
 namespace Program {
 
     inline bool operator==(const BrilligBytecode &lhs, const BrilligBytecode &rhs) {
@@ -6443,6 +6618,7 @@ namespace Program {
     inline bool operator==(const Opcode::MemoryInit &lhs, const Opcode::MemoryInit &rhs) {
         if (!(lhs.block_id == rhs.block_id)) { return false; }
         if (!(lhs.init == rhs.init)) { return false; }
+        if (!(lhs.block_type == rhs.block_type)) { return false; }
         return true;
     }
 
@@ -6468,6 +6644,7 @@ template <typename Serializer>
 void serde::Serializable<Program::Opcode::MemoryInit>::serialize(const Program::Opcode::MemoryInit &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.block_id)>::serialize(obj.block_id, serializer);
     serde::Serializable<decltype(obj.init)>::serialize(obj.init, serializer);
+    serde::Serializable<decltype(obj.block_type)>::serialize(obj.block_type, serializer);
 }
 
 template <>
@@ -6476,6 +6653,7 @@ Program::Opcode::MemoryInit serde::Deserializable<Program::Opcode::MemoryInit>::
     Program::Opcode::MemoryInit obj;
     obj.block_id = serde::Deserializable<decltype(obj.block_id)>::deserialize(deserializer);
     obj.init = serde::Deserializable<decltype(obj.init)>::deserialize(deserializer);
+    obj.block_type = serde::Deserializable<decltype(obj.block_type)>::deserialize(deserializer);
     return obj;
 }
 
diff --git a/noir/noir-repo/acvm-repo/acir/src/circuit/opcodes.rs b/noir/noir-repo/acvm-repo/acir/src/circuit/opcodes.rs
index 7db317c41ab3..e6dc11dac780 100644
--- a/noir/noir-repo/acvm-repo/acir/src/circuit/opcodes.rs
+++ b/noir/noir-repo/acvm-repo/acir/src/circuit/opcodes.rs
@@ -11,6 +11,13 @@ mod memory_operation;
 pub use black_box_function_call::{BlackBoxFuncCall, FunctionInput};
 pub use memory_operation::{BlockId, MemOp};
 
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum BlockType {
+    Memory,
+    CallData,
+    ReturnData,
+}
+
 #[allow(clippy::large_enum_variant)]
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum Opcode {
@@ -30,6 +37,7 @@ pub enum Opcode {
     MemoryInit {
         block_id: BlockId,
         init: Vec<Witness>,
+        block_type: BlockType,
     },
     /// Calls to unconstrained functions
     BrilligCall {
@@ -103,8 +111,12 @@ impl std::fmt::Display for Opcode {
                     write!(f, "(id: {}, op {} at: {}) ", block_id.0, op.operation, op.index)
                 }
             }
-            Opcode::MemoryInit { block_id, init } => {
-                write!(f, "INIT ")?;
+            Opcode::MemoryInit { block_id, init, block_type: databus } => {
+                match databus {
+                    BlockType::Memory => write!(f, "INIT ")?,
+                    BlockType::CallData => write!(f, "INIT CALLDATA ")?,
+                    BlockType::ReturnData => write!(f, "INIT RETURNDATA ")?,
+                }
                 write!(f, "(id: {}, len: {}) ", block_id.0, init.len())
             }
             // We keep the display for a BrilligCall and circuit Call separate as they
diff --git a/noir/noir-repo/acvm-repo/acir/src/lib.rs b/noir/noir-repo/acvm-repo/acir/src/lib.rs
index 24f27aae06fa..f60f1b46b6a4 100644
--- a/noir/noir-repo/acvm-repo/acir/src/lib.rs
+++ b/noir/noir-repo/acvm-repo/acir/src/lib.rs
@@ -41,7 +41,7 @@ mod reflection {
         circuit::{
             brillig::{BrilligInputs, BrilligOutputs},
             directives::Directive,
-            opcodes::BlackBoxFuncCall,
+            opcodes::{BlackBoxFuncCall, BlockType},
             AssertionPayload, Circuit, ExpressionOrMemory, ExpressionWidth, Opcode, OpcodeLocation,
             Program,
         },
@@ -60,6 +60,7 @@ mod reflection {
         };
 
         let mut tracer = Tracer::new(TracerConfig::default());
+        tracer.trace_simple_type::<BlockType>().unwrap();
         tracer.trace_simple_type::<Program>().unwrap();
         tracer.trace_simple_type::<Circuit>().unwrap();
         tracer.trace_simple_type::<ExpressionWidth>().unwrap();
diff --git a/noir/noir-repo/acvm-repo/acir/tests/test_program_serialization.rs b/noir/noir-repo/acvm-repo/acir/tests/test_program_serialization.rs
index d9327f784e6b..ecc1a26e3a44 100644
--- a/noir/noir-repo/acvm-repo/acir/tests/test_program_serialization.rs
+++ b/noir/noir-repo/acvm-repo/acir/tests/test_program_serialization.rs
@@ -347,7 +347,11 @@ fn complex_brillig_foreign_call() {
 fn memory_op_circuit() {
     let init = vec![Witness(1), Witness(2)];
 
-    let memory_init = Opcode::MemoryInit { block_id: BlockId(0), init };
+    let memory_init = Opcode::MemoryInit {
+        block_id: BlockId(0),
+        init,
+        block_type: acir::circuit::opcodes::BlockType::Memory,
+    };
     let write = Opcode::MemoryOp {
         block_id: BlockId(0),
         op: MemOp::write_to_mem_index(FieldElement::from(1u128).into(), Witness(3).into()),
@@ -371,11 +375,11 @@ fn memory_op_circuit() {
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 82, 65, 10, 0, 32, 8, 203, 180, 255, 216, 15, 250,
-        255, 171, 10, 154, 16, 210, 45, 61, 52, 144, 13, 132, 49, 135, 84, 54, 218, 26, 134, 22,
-        112, 5, 19, 180, 237, 61, 6, 88, 223, 208, 179, 125, 41, 216, 151, 227, 188, 52, 187, 92,
-        253, 173, 92, 137, 190, 157, 143, 160, 254, 155, 45, 188, 148, 11, 38, 213, 237, 188, 16,
-        35, 3, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 82, 65, 10, 0, 32, 8, 211, 180, 255, 216, 15, 250,
+        255, 171, 10, 82, 176, 232, 150, 30, 26, 200, 118, 144, 49, 135, 8, 11, 117, 14, 169, 102,
+        229, 162, 140, 78, 219, 206, 137, 174, 44, 111, 104, 217, 190, 24, 236, 75, 113, 94, 146,
+        93, 174, 252, 86, 46, 71, 223, 78, 46, 104, 129, 253, 155, 45, 60, 195, 5, 3, 89, 11, 161,
+        73, 39, 3, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
diff --git a/noir/noir-repo/acvm-repo/acvm/src/pwg/mod.rs b/noir/noir-repo/acvm-repo/acvm/src/pwg/mod.rs
index a4219adbfa6b..f2649b93991c 100644
--- a/noir/noir-repo/acvm-repo/acvm/src/pwg/mod.rs
+++ b/noir/noir-repo/acvm-repo/acvm/src/pwg/mod.rs
@@ -335,7 +335,7 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
                 &mut self.bigint_solver,
             ),
             Opcode::Directive(directive) => solve_directives(&mut self.witness_map, directive),
-            Opcode::MemoryInit { block_id, init } => {
+            Opcode::MemoryInit { block_id, init, .. } => {
                 let solver = self.block_solvers.entry(*block_id).or_default();
                 solver.init(init, &self.witness_map)
             }
diff --git a/noir/noir-repo/acvm-repo/acvm/tests/solver.rs b/noir/noir-repo/acvm-repo/acvm/tests/solver.rs
index df61083eee4c..495389d7b3e7 100644
--- a/noir/noir-repo/acvm-repo/acvm/tests/solver.rs
+++ b/noir/noir-repo/acvm-repo/acvm/tests/solver.rs
@@ -4,7 +4,7 @@ use acir::{
     brillig::{BinaryFieldOp, HeapArray, MemoryAddress, Opcode as BrilligOpcode, ValueOrArray},
     circuit::{
         brillig::{BrilligBytecode, BrilligInputs, BrilligOutputs},
-        opcodes::{BlockId, MemOp},
+        opcodes::{BlockId, BlockType, MemOp},
         Opcode, OpcodeLocation,
     },
     native_types::{Expression, Witness, WitnessMap},
@@ -658,7 +658,11 @@ fn memory_operations() {
 
     let block_id = BlockId(0);
 
-    let init = Opcode::MemoryInit { block_id, init: (1..6).map(Witness).collect() };
+    let init = Opcode::MemoryInit {
+        block_id,
+        init: (1..6).map(Witness).collect(),
+        block_type: BlockType::Memory,
+    };
 
     let read_op = Opcode::MemoryOp {
         block_id,
diff --git a/noir/noir-repo/acvm-repo/acvm_js/test/shared/memory_op.ts b/noir/noir-repo/acvm-repo/acvm_js/test/shared/memory_op.ts
index 20ea88c71308..f7443c2258b2 100644
--- a/noir/noir-repo/acvm-repo/acvm_js/test/shared/memory_op.ts
+++ b/noir/noir-repo/acvm-repo/acvm_js/test/shared/memory_op.ts
@@ -1,9 +1,9 @@
 // See `memory_op_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 82, 65, 10, 0, 32, 8, 203, 180, 255, 216, 15, 250, 255, 171, 10, 154, 16, 210,
-  45, 61, 52, 144, 13, 132, 49, 135, 84, 54, 218, 26, 134, 22, 112, 5, 19, 180, 237, 61, 6, 88, 223, 208, 179, 125, 41,
-  216, 151, 227, 188, 52, 187, 92, 253, 173, 92, 137, 190, 157, 143, 160, 254, 155, 45, 188, 148, 11, 38, 213, 237, 188,
-  16, 35, 3, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 82, 65, 10, 0, 32, 8, 211, 180, 255, 216, 15, 250, 255, 171, 10, 82, 176, 232,
+  150, 30, 26, 200, 118, 144, 49, 135, 8, 11, 117, 14, 169, 102, 229, 162, 140, 78, 219, 206, 137, 174, 44, 111, 104,
+  217, 190, 24, 236, 75, 113, 94, 146, 93, 174, 252, 86, 46, 71, 223, 78, 46, 104, 129, 253, 155, 45, 60, 195, 5, 3, 89,
+  11, 161, 73, 39, 3, 0, 0,
 ]);
 
 export const initialWitnessMap = new Map([
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index 407cdf0a17f6..e8f6f7b281a6 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -8,7 +8,7 @@ use crate::ssa::ir::dfg::CallStack;
 use crate::ssa::ir::types::Type as SsaType;
 use crate::ssa::ir::{instruction::Endian, types::NumericType};
 use acvm::acir::circuit::brillig::{BrilligInputs, BrilligOutputs};
-use acvm::acir::circuit::opcodes::{BlockId, MemOp};
+use acvm::acir::circuit::opcodes::{BlockId, BlockType, MemOp};
 use acvm::acir::circuit::{AssertionPayload, ExpressionOrMemory, Opcode};
 use acvm::blackbox_solver;
 use acvm::brillig_vm::{MemoryValue, VMStatus, VM};
@@ -1773,6 +1773,7 @@ impl AcirContext {
         block_id: BlockId,
         len: usize,
         optional_value: Option<AcirValue>,
+        databus: BlockType,
     ) -> Result<(), InternalError> {
         let initialized_values = match optional_value {
             None => {
@@ -1787,7 +1788,11 @@ impl AcirContext {
             }
         };
 
-        self.acir_ir.push_opcode(Opcode::MemoryInit { block_id, init: initialized_values });
+        self.acir_ir.push_opcode(Opcode::MemoryInit {
+            block_id,
+            init: initialized_values,
+            block_type: databus,
+        });
 
         Ok(())
     }
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 2e2f03a00122..8abb31e82760 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -29,6 +29,7 @@ use crate::brillig::brillig_ir::BrilligContext;
 use crate::brillig::{brillig_gen::brillig_fn::FunctionContext as BrilligFunctionContext, Brillig};
 use crate::errors::{InternalError, InternalWarning, RuntimeError, SsaReport};
 pub(crate) use acir_ir::generated_acir::GeneratedAcir;
+use acvm::acir::circuit::opcodes::BlockType;
 use noirc_frontend::monomorphization::ast::InlineType;
 
 use acvm::acir::circuit::brillig::BrilligBytecode;
@@ -1683,7 +1684,18 @@ impl<'a> Context<'a> {
         len: usize,
         value: Option<AcirValue>,
     ) -> Result<(), InternalError> {
-        self.acir_context.initialize_array(array, len, value)?;
+        let databus = if self.data_bus.call_data.is_some()
+            && self.block_id(&self.data_bus.call_data.unwrap()) == array
+        {
+            BlockType::CallData
+        } else if self.data_bus.return_data.is_some()
+            && self.block_id(&self.data_bus.return_data.unwrap()) == array
+        {
+            BlockType::ReturnData
+        } else {
+            BlockType::Memory
+        };
+        self.acir_context.initialize_array(array, len, value, databus)?;
         self.initialized_arrays.insert(array);
         Ok(())
     }
diff --git a/noir/noir-repo/tooling/debugger/src/context.rs b/noir/noir-repo/tooling/debugger/src/context.rs
index ea32c864a0b8..646beaf00963 100644
--- a/noir/noir-repo/tooling/debugger/src/context.rs
+++ b/noir/noir-repo/tooling/debugger/src/context.rs
@@ -862,7 +862,11 @@ mod tests {
 
         let opcodes = vec![
             Opcode::BrilligCall { id: 0, inputs: vec![], outputs: vec![], predicate: None },
-            Opcode::MemoryInit { block_id: BlockId(0), init: vec![] },
+            Opcode::MemoryInit {
+                block_id: BlockId(0),
+                init: vec![],
+                block_type: acvm::acir::circuit::opcodes::BlockType::Memory,
+            },
             Opcode::BrilligCall { id: 0, inputs: vec![], outputs: vec![], predicate: None },
             Opcode::AssertZero(Expression::default()),
         ];