chore: Handle MemoryInit and MemoryOp

cpp/src/barretenberg/dsl/acir_format/acir_to_constraint_buf.hpp

@@ -234,6 +234,44 @@ void handle_memory(Circuit::MemoryBlock const& mem_block, bool is_ram, acir_form
     af.block_constraints.push_back(BlockConstraint{ .init = init, .trace = trace, .type = (BlockType)is_ram });
 }
 
+BlockConstraint handle_memory_init(Circuit::Opcode::MemoryInit const& mem_init)
+{
+    BlockConstraint block{ .init = {}, .trace = {}, .type = BlockType::ROM };
+    std::vector<poly_triple> init;
+    std::vector<MemOp> trace;
+
+    auto len = mem_init.init.size();
+    for (size_t i = 0; i < len; ++i) {
+        block.init.push_back(poly_triple{
+            .a = mem_init.init[i].value,
+            .b = 0,
+            .c = 0,
+            .q_m = 0,
+            .q_l = 1,
+            .q_r = 0,
+            .q_o = 0,
+            .q_c = 0,
+        });
+    }
+    return block;
+}
+
+void handle_memory_op(Circuit::Opcode::MemoryOp const& mem_op, BlockConstraint& block)
+{
+    uint8_t access_type = 1;
+    if (mem_op.op.is_rom()) {
+        access_type = 0;
+    }
+    if (block.type == BlockType::ROM && access_type == 1) {
+        block.type = BlockType::RAM;
+    }
+
+    MemOp acir_mem_op = MemOp{ .access_type = access_type,
+                               .index = serialize_arithmetic_gate(mem_op.op.index),
+                               .value = serialize_arithmetic_gate(mem_op.op.value) };
+    block.trace.push_back(acir_mem_op);
+}
+
 acir_format circuit_buf_to_acir_format(std::vector<uint8_t> const& buf)
 {
     auto circuit = Circuit::Circuit::bincodeDeserialize(buf);
@@ -242,7 +280,7 @@ acir_format circuit_buf_to_acir_format(std::vector<uint8_t> const& buf)
     af.varnum = circuit.current_witness_index + 1;
     af.public_inputs = join({ map(circuit.public_parameters.value, [](auto e) { return e.value; }),
                               map(circuit.return_values.value, [](auto e) { return e.value; }) });
-
+    std::map<uint32_t, BlockConstraint> block_id_to_block_constraint;
     for (auto gate : circuit.opcodes) {
         std::visit(
             [&](auto&& arg) {
@@ -256,13 +294,24 @@ acir_format circuit_buf_to_acir_format(std::vector<uint8_t> const& buf)
                 } else if constexpr (std::is_same_v<T, Circuit::Opcode::ROM>) {
                     handle_memory(arg.value, false, af);
                 } else if constexpr (std::is_same_v<T, Circuit::Opcode::MemoryInit>) {
-                    throw_or_abort("memory init unimplemented");
+                    auto block = handle_memory_init(arg);
+                    uint32_t block_id = arg.block_id.value;
+                    block_id_to_block_constraint[block_id] = block;
                 } else if constexpr (std::is_same_v<T, Circuit::Opcode::MemoryOp>) {
-                    throw_or_abort("memory op unimplemented");
+                    auto block = block_id_to_block_constraint.find(arg.block_id.value);
+                    if (block == block_id_to_block_constraint.end()) {
+                        throw_or_abort("unitialized MemoryOp");
+                    }
+                    handle_memory_op(arg, block->second);
                 }
             },
             gate.value);
     }
+    for (const auto& [block_id, block] : block_id_to_block_constraint) {
+        if (!block.trace.empty()) {
+            af.block_constraints.push_back(block);
+        }
+    }
     return af;
 }
 

cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp

@@ -855,6 +855,12 @@ struct MemOp {
     friend bool operator==(const MemOp&, const MemOp&);
     std::vector<uint8_t> bincodeSerialize() const;
     static MemOp bincodeDeserialize(std::vector<uint8_t>);
+
+    bool is_rom() const
+    {
+        return this->operation.mul_terms.size() == 0 && this->operation.linear_combinations.size() == 0 &&
+               uint256_t(this->operation.q_c) == 0;
+    }
 };
 
 struct MemoryBlock {