diff --git a/acvm-repo/acir/codegen/acir.cpp b/acvm-repo/acir/codegen/acir.cpp
index 973963029f3..18d6ce3c48b 100644
--- a/acvm-repo/acir/codegen/acir.cpp
+++ b/acvm-repo/acir/codegen/acir.cpp
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "serde.hpp"
-#include "msgpack.hpp"
+#include "barretenberg/serialize/msgpack_impl.hpp"
 #include "bincode.hpp"
 
 namespace Acir {
@@ -10,7 +10,7 @@ namespace Acir {
             msgpack::object const& o,
             std::string const& name
         ) {
-            if(o.type != msgpack::type::MAP) {
+            if (o.type != msgpack::type::MAP) {
                 std::cerr << o << std::endl;
                 throw_or_abort("expected MAP for " + name);
             }
@@ -28,6 +28,7 @@ namespace Acir {
             }
             return kvmap;
         }
+
         template<typename T>
         static void conv_fld_from_kvmap(
             std::map<std::string, msgpack::object const*> const& kvmap,
@@ -48,6 +49,26 @@ namespace Acir {
                 throw_or_abort("missing field: " + struct_name + "::" + field_name);
             }
         }
+
+        template<typename T>
+        static void conv_fld_from_array(
+            msgpack::object_array const& array,
+            std::string const& struct_name,
+            std::string const& field_name,
+            T& field,
+            uint32_t index
+        ) {
+            if (index >= array.size) {
+                throw_or_abort("index out of bounds: " + struct_name + "::" + field_name + " at " + std::to_string(index));
+            }
+            auto element = array.ptr[index];
+            try {
+                element.convert(field);
+            } catch (const msgpack::type_error&) {
+                std::cerr << element << std::endl;
+                throw_or_abort("error converting into field " + struct_name + "::" + field_name);
+            }
+        }
     };
     }
 
@@ -177,9 +198,9 @@ namespace Acir {
                 packer.pack(tag);
             } else {
                 std::visit([&packer, tag](const auto& arg) {
-                    std::map<std::string, msgpack::object> data;
-                    data[tag] = msgpack::object(arg);
-                    packer.pack(data);
+                    packer.pack_map(1);
+                    packer.pack(tag);
+                    arg.msgpack_pack(packer);
                 }, value);
             }
         }
@@ -419,9 +440,9 @@ namespace Acir {
                 packer.pack(tag);
             } else {
                 std::visit([&packer, tag](const auto& arg) {
-                    std::map<std::string, msgpack::object> data;
-                    data[tag] = msgpack::object(arg);
-                    packer.pack(data);
+                    packer.pack_map(1);
+                    packer.pack(tag);
+                    arg.msgpack_pack(packer);
                 }, value);
             }
         }
@@ -599,9 +620,9 @@ namespace Acir {
                 packer.pack(tag);
             } else {
                 std::visit([&packer, tag](const auto& arg) {
-                    std::map<std::string, msgpack::object> data;
-                    data[tag] = msgpack::object(arg);
-                    packer.pack(data);
+                    packer.pack_map(1);
+                    packer.pack(tag);
+                    arg.msgpack_pack(packer);
                 }, value);
             }
         }
@@ -713,9 +734,9 @@ namespace Acir {
                 packer.pack(tag);
             } else {
                 std::visit([&packer, tag](const auto& arg) {
-                    std::map<std::string, msgpack::object> data;
-                    data[tag] = msgpack::object(arg);
-                    packer.pack(data);
+                    packer.pack_map(1);
+                    packer.pack(tag);
+                    arg.msgpack_pack(packer);
                 }, value);
             }
         }
@@ -828,9 +849,9 @@ namespace Acir {
                 packer.pack(tag);
             } else {
                 std::visit([&packer, tag](const auto& arg) {
-                    std::map<std::string, msgpack::object> data;
-                    data[tag] = msgpack::object(arg);
-                    packer.pack(data);
+                    packer.pack_map(1);
+                    packer.pack(tag);
+                    arg.msgpack_pack(packer);
                 }, value);
             }
         }
@@ -899,10 +920,18 @@ namespace Acir {
         }
 
         void msgpack_unpack(msgpack::object const& o) {
-            auto name = "HeapArray";
-            auto kvmap = Helpers::make_kvmap(o, name);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "pointer", pointer, false);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "size", size, false);
+            std::string name = "HeapArray";
+            if (o.type == msgpack::type::MAP) {
+                auto kvmap = Helpers::make_kvmap(o, name);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "pointer", pointer, false);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "size", size, false);
+            } else if (o.type == msgpack::type::ARRAY) {
+                auto array = o.via.array; 
+                Helpers::conv_fld_from_array(array, name, "pointer", pointer, 0);
+                Helpers::conv_fld_from_array(array, name, "size", size, 1);
+            } else {
+                throw_or_abort("expected MAP or ARRAY for " + name);
+            }
         }
     };
 
@@ -921,10 +950,18 @@ namespace Acir {
         }
 
         void msgpack_unpack(msgpack::object const& o) {
-            auto name = "HeapVector";
-            auto kvmap = Helpers::make_kvmap(o, name);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "pointer", pointer, false);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "size", size, false);
+            std::string name = "HeapVector";
+            if (o.type == msgpack::type::MAP) {
+                auto kvmap = Helpers::make_kvmap(o, name);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "pointer", pointer, false);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "size", size, false);
+            } else if (o.type == msgpack::type::ARRAY) {
+                auto array = o.via.array; 
+                Helpers::conv_fld_from_array(array, name, "pointer", pointer, 0);
+                Helpers::conv_fld_from_array(array, name, "size", size, 1);
+            } else {
+                throw_or_abort("expected MAP or ARRAY for " + name);
+            }
         }
     };
 
@@ -949,12 +986,22 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "AES128Encrypt";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "inputs", inputs, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "iv", iv, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "key", key, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
+                std::string name = "AES128Encrypt";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "inputs", inputs, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "iv", iv, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "key", key, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "inputs", inputs, 0);
+                    Helpers::conv_fld_from_array(array, name, "iv", iv, 1);
+                    Helpers::conv_fld_from_array(array, name, "key", key, 2);
+                    Helpers::conv_fld_from_array(array, name, "outputs", outputs, 3);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -973,10 +1020,18 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Blake2s";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "message", message, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "output", output, false);
+                std::string name = "Blake2s";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "message", message, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "output", output, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "message", message, 0);
+                    Helpers::conv_fld_from_array(array, name, "output", output, 1);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -995,10 +1050,18 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Blake3";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "message", message, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "output", output, false);
+                std::string name = "Blake3";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "message", message, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "output", output, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "message", message, 0);
+                    Helpers::conv_fld_from_array(array, name, "output", output, 1);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -1017,10 +1080,18 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Keccakf1600";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "input", input, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "output", output, false);
+                std::string name = "Keccakf1600";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "input", input, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "output", output, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "input", input, 0);
+                    Helpers::conv_fld_from_array(array, name, "output", output, 1);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -1045,13 +1116,24 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "EcdsaSecp256k1";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "hashed_msg", hashed_msg, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "public_key_x", public_key_x, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "public_key_y", public_key_y, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "signature", signature, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "result", result, false);
+                std::string name = "EcdsaSecp256k1";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "hashed_msg", hashed_msg, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "public_key_x", public_key_x, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "public_key_y", public_key_y, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "signature", signature, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "result", result, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "hashed_msg", hashed_msg, 0);
+                    Helpers::conv_fld_from_array(array, name, "public_key_x", public_key_x, 1);
+                    Helpers::conv_fld_from_array(array, name, "public_key_y", public_key_y, 2);
+                    Helpers::conv_fld_from_array(array, name, "signature", signature, 3);
+                    Helpers::conv_fld_from_array(array, name, "result", result, 4);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -1076,13 +1158,24 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "EcdsaSecp256r1";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "hashed_msg", hashed_msg, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "public_key_x", public_key_x, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "public_key_y", public_key_y, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "signature", signature, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "result", result, false);
+                std::string name = "EcdsaSecp256r1";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "hashed_msg", hashed_msg, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "public_key_x", public_key_x, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "public_key_y", public_key_y, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "signature", signature, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "result", result, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "hashed_msg", hashed_msg, 0);
+                    Helpers::conv_fld_from_array(array, name, "public_key_x", public_key_x, 1);
+                    Helpers::conv_fld_from_array(array, name, "public_key_y", public_key_y, 2);
+                    Helpers::conv_fld_from_array(array, name, "signature", signature, 3);
+                    Helpers::conv_fld_from_array(array, name, "result", result, 4);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -1103,11 +1196,20 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "MultiScalarMul";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "points", points, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "scalars", scalars, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
+                std::string name = "MultiScalarMul";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "points", points, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "scalars", scalars, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "points", points, 0);
+                    Helpers::conv_fld_from_array(array, name, "scalars", scalars, 1);
+                    Helpers::conv_fld_from_array(array, name, "outputs", outputs, 2);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -1136,15 +1238,28 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "EmbeddedCurveAdd";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "input1_x", input1_x, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "input1_y", input1_y, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "input1_infinite", input1_infinite, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "input2_x", input2_x, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "input2_y", input2_y, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "input2_infinite", input2_infinite, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "result", result, false);
+                std::string name = "EmbeddedCurveAdd";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "input1_x", input1_x, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "input1_y", input1_y, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "input1_infinite", input1_infinite, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "input2_x", input2_x, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "input2_y", input2_y, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "input2_infinite", input2_infinite, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "result", result, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "input1_x", input1_x, 0);
+                    Helpers::conv_fld_from_array(array, name, "input1_y", input1_y, 1);
+                    Helpers::conv_fld_from_array(array, name, "input1_infinite", input1_infinite, 2);
+                    Helpers::conv_fld_from_array(array, name, "input2_x", input2_x, 3);
+                    Helpers::conv_fld_from_array(array, name, "input2_y", input2_y, 4);
+                    Helpers::conv_fld_from_array(array, name, "input2_infinite", input2_infinite, 5);
+                    Helpers::conv_fld_from_array(array, name, "result", result, 6);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -1163,10 +1278,18 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Poseidon2Permutation";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "message", message, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "output", output, false);
+                std::string name = "Poseidon2Permutation";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "message", message, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "output", output, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "message", message, 0);
+                    Helpers::conv_fld_from_array(array, name, "output", output, 1);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -1187,11 +1310,20 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Sha256Compression";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "input", input, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "hash_values", hash_values, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "output", output, false);
+                std::string name = "Sha256Compression";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "input", input, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "hash_values", hash_values, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "output", output, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "input", input, 0);
+                    Helpers::conv_fld_from_array(array, name, "hash_values", hash_values, 1);
+                    Helpers::conv_fld_from_array(array, name, "output", output, 2);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -1216,13 +1348,24 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "ToRadix";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "input", input, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "radix", radix, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "output_pointer", output_pointer, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "num_limbs", num_limbs, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "output_bits", output_bits, false);
+                std::string name = "ToRadix";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "input", input, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "radix", radix, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "output_pointer", output_pointer, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "num_limbs", num_limbs, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "output_bits", output_bits, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "input", input, 0);
+                    Helpers::conv_fld_from_array(array, name, "radix", radix, 1);
+                    Helpers::conv_fld_from_array(array, name, "output_pointer", output_pointer, 2);
+                    Helpers::conv_fld_from_array(array, name, "num_limbs", num_limbs, 3);
+                    Helpers::conv_fld_from_array(array, name, "output_bits", output_bits, 4);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -1288,9 +1431,9 @@ namespace Acir {
                 packer.pack(tag);
             } else {
                 std::visit([&packer, tag](const auto& arg) {
-                    std::map<std::string, msgpack::object> data;
-                    data[tag] = msgpack::object(arg);
-                    packer.pack(data);
+                    packer.pack_map(1);
+                    packer.pack(tag);
+                    arg.msgpack_pack(packer);
                 }, value);
             }
         }
@@ -1481,10 +1624,18 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Array";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "value_types", value_types, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "size", size, false);
+                std::string name = "Array";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "value_types", value_types, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "size", size, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "value_types", value_types, 0);
+                    Helpers::conv_fld_from_array(array, name, "size", size, 1);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -1501,9 +1652,16 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Vector";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "value_types", value_types, false);
+                std::string name = "Vector";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "value_types", value_types, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "value_types", value_types, 0);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -1537,9 +1695,9 @@ namespace Acir {
                 packer.pack(tag);
             } else {
                 std::visit([&packer, tag](const auto& arg) {
-                    std::map<std::string, msgpack::object> data;
-                    data[tag] = msgpack::object(arg);
-                    packer.pack(data);
+                    packer.pack_map(1);
+                    packer.pack(tag);
+                    arg.msgpack_pack(packer);
                 }, value);
             }
         }
@@ -1693,9 +1851,9 @@ namespace Acir {
                 packer.pack(tag);
             } else {
                 std::visit([&packer, tag](const auto& arg) {
-                    std::map<std::string, msgpack::object> data;
-                    data[tag] = msgpack::object(arg);
-                    packer.pack(data);
+                    packer.pack_map(1);
+                    packer.pack(tag);
+                    arg.msgpack_pack(packer);
                 }, value);
             }
         }
@@ -1781,12 +1939,22 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "BinaryFieldOp";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "destination", destination, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "op", op, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "lhs", lhs, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "rhs", rhs, false);
+                std::string name = "BinaryFieldOp";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "destination", destination, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "op", op, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "lhs", lhs, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "rhs", rhs, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "destination", destination, 0);
+                    Helpers::conv_fld_from_array(array, name, "op", op, 1);
+                    Helpers::conv_fld_from_array(array, name, "lhs", lhs, 2);
+                    Helpers::conv_fld_from_array(array, name, "rhs", rhs, 3);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -1811,13 +1979,24 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "BinaryIntOp";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "destination", destination, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "op", op, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "bit_size", bit_size, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "lhs", lhs, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "rhs", rhs, false);
+                std::string name = "BinaryIntOp";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "destination", destination, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "op", op, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "bit_size", bit_size, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "lhs", lhs, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "rhs", rhs, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "destination", destination, 0);
+                    Helpers::conv_fld_from_array(array, name, "op", op, 1);
+                    Helpers::conv_fld_from_array(array, name, "bit_size", bit_size, 2);
+                    Helpers::conv_fld_from_array(array, name, "lhs", lhs, 3);
+                    Helpers::conv_fld_from_array(array, name, "rhs", rhs, 4);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -1838,11 +2017,20 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Not";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "destination", destination, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "source", source, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "bit_size", bit_size, false);
+                std::string name = "Not";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "destination", destination, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "source", source, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "bit_size", bit_size, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "destination", destination, 0);
+                    Helpers::conv_fld_from_array(array, name, "source", source, 1);
+                    Helpers::conv_fld_from_array(array, name, "bit_size", bit_size, 2);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -1863,11 +2051,20 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Cast";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "destination", destination, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "source", source, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "bit_size", bit_size, false);
+                std::string name = "Cast";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "destination", destination, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "source", source, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "bit_size", bit_size, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "destination", destination, 0);
+                    Helpers::conv_fld_from_array(array, name, "source", source, 1);
+                    Helpers::conv_fld_from_array(array, name, "bit_size", bit_size, 2);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -1886,10 +2083,18 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "JumpIf";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "condition", condition, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "location", location, false);
+                std::string name = "JumpIf";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "condition", condition, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "location", location, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "condition", condition, 0);
+                    Helpers::conv_fld_from_array(array, name, "location", location, 1);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -1906,9 +2111,16 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Jump";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "location", location, false);
+                std::string name = "Jump";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "location", location, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "location", location, 0);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -1929,11 +2141,20 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "CalldataCopy";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "destination_address", destination_address, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "size_address", size_address, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "offset_address", offset_address, false);
+                std::string name = "CalldataCopy";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "destination_address", destination_address, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "size_address", size_address, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "offset_address", offset_address, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "destination_address", destination_address, 0);
+                    Helpers::conv_fld_from_array(array, name, "size_address", size_address, 1);
+                    Helpers::conv_fld_from_array(array, name, "offset_address", offset_address, 2);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -1950,9 +2171,16 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Call";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "location", location, false);
+                std::string name = "Call";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "location", location, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "location", location, 0);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -1973,11 +2201,20 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Const";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "destination", destination, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "bit_size", bit_size, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "value", value, false);
+                std::string name = "Const";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "destination", destination, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "bit_size", bit_size, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "value", value, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "destination", destination, 0);
+                    Helpers::conv_fld_from_array(array, name, "bit_size", bit_size, 1);
+                    Helpers::conv_fld_from_array(array, name, "value", value, 2);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -1998,11 +2235,20 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "IndirectConst";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "destination_pointer", destination_pointer, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "bit_size", bit_size, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "value", value, false);
+                std::string name = "IndirectConst";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "destination_pointer", destination_pointer, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "bit_size", bit_size, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "value", value, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "destination_pointer", destination_pointer, 0);
+                    Helpers::conv_fld_from_array(array, name, "bit_size", bit_size, 1);
+                    Helpers::conv_fld_from_array(array, name, "value", value, 2);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -2036,13 +2282,24 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "ForeignCall";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "function", function, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "destinations", destinations, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "destination_value_types", destination_value_types, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "inputs", inputs, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "input_value_types", input_value_types, false);
+                std::string name = "ForeignCall";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "function", function, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "destinations", destinations, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "destination_value_types", destination_value_types, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "inputs", inputs, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "input_value_types", input_value_types, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "function", function, 0);
+                    Helpers::conv_fld_from_array(array, name, "destinations", destinations, 1);
+                    Helpers::conv_fld_from_array(array, name, "destination_value_types", destination_value_types, 2);
+                    Helpers::conv_fld_from_array(array, name, "inputs", inputs, 3);
+                    Helpers::conv_fld_from_array(array, name, "input_value_types", input_value_types, 4);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -2061,10 +2318,18 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Mov";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "destination", destination, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "source", source, false);
+                std::string name = "Mov";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "destination", destination, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "source", source, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "destination", destination, 0);
+                    Helpers::conv_fld_from_array(array, name, "source", source, 1);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -2087,12 +2352,22 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "ConditionalMov";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "destination", destination, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "source_a", source_a, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "source_b", source_b, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "condition", condition, false);
+                std::string name = "ConditionalMov";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "destination", destination, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "source_a", source_a, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "source_b", source_b, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "condition", condition, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "destination", destination, 0);
+                    Helpers::conv_fld_from_array(array, name, "source_a", source_a, 1);
+                    Helpers::conv_fld_from_array(array, name, "source_b", source_b, 2);
+                    Helpers::conv_fld_from_array(array, name, "condition", condition, 3);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -2111,10 +2386,18 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Load";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "destination", destination, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "source_pointer", source_pointer, false);
+                std::string name = "Load";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "destination", destination, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "source_pointer", source_pointer, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "destination", destination, 0);
+                    Helpers::conv_fld_from_array(array, name, "source_pointer", source_pointer, 1);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -2133,10 +2416,18 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Store";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "destination_pointer", destination_pointer, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "source", source, false);
+                std::string name = "Store";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "destination_pointer", destination_pointer, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "source", source, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "destination_pointer", destination_pointer, 0);
+                    Helpers::conv_fld_from_array(array, name, "source", source, 1);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -2172,9 +2463,16 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Trap";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "revert_data", revert_data, false);
+                std::string name = "Trap";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "revert_data", revert_data, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "revert_data", revert_data, 0);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -2191,9 +2489,16 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Stop";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "return_data", return_data, false);
+                std::string name = "Stop";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "return_data", return_data, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "return_data", return_data, 0);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -2291,9 +2596,9 @@ namespace Acir {
                 packer.pack(tag);
             } else {
                 std::visit([&packer, tag](const auto& arg) {
-                    std::map<std::string, msgpack::object> data;
-                    data[tag] = msgpack::object(arg);
-                    packer.pack(data);
+                    packer.pack_map(1);
+                    packer.pack(tag);
+                    arg.msgpack_pack(packer);
                 }, value);
             }
         }
@@ -2612,9 +2917,9 @@ namespace Acir {
                 packer.pack(tag);
             } else {
                 std::visit([&packer, tag](const auto& arg) {
-                    std::map<std::string, msgpack::object> data;
-                    data[tag] = msgpack::object(arg);
-                    packer.pack(data);
+                    packer.pack_map(1);
+                    packer.pack(tag);
+                    arg.msgpack_pack(packer);
                 }, value);
             }
         }
@@ -2689,12 +2994,22 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "AES128Encrypt";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "inputs", inputs, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "iv", iv, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "key", key, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
+                std::string name = "AES128Encrypt";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "inputs", inputs, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "iv", iv, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "key", key, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "inputs", inputs, 0);
+                    Helpers::conv_fld_from_array(array, name, "iv", iv, 1);
+                    Helpers::conv_fld_from_array(array, name, "key", key, 2);
+                    Helpers::conv_fld_from_array(array, name, "outputs", outputs, 3);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -2717,12 +3032,22 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "AND";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "lhs", lhs, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "rhs", rhs, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "num_bits", num_bits, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "output", output, false);
+                std::string name = "AND";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "lhs", lhs, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "rhs", rhs, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "num_bits", num_bits, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "output", output, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "lhs", lhs, 0);
+                    Helpers::conv_fld_from_array(array, name, "rhs", rhs, 1);
+                    Helpers::conv_fld_from_array(array, name, "num_bits", num_bits, 2);
+                    Helpers::conv_fld_from_array(array, name, "output", output, 3);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -2745,12 +3070,22 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "XOR";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "lhs", lhs, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "rhs", rhs, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "num_bits", num_bits, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "output", output, false);
+                std::string name = "XOR";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "lhs", lhs, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "rhs", rhs, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "num_bits", num_bits, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "output", output, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "lhs", lhs, 0);
+                    Helpers::conv_fld_from_array(array, name, "rhs", rhs, 1);
+                    Helpers::conv_fld_from_array(array, name, "num_bits", num_bits, 2);
+                    Helpers::conv_fld_from_array(array, name, "output", output, 3);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -2769,10 +3104,18 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "RANGE";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "input", input, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "num_bits", num_bits, false);
+                std::string name = "RANGE";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "input", input, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "num_bits", num_bits, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "input", input, 0);
+                    Helpers::conv_fld_from_array(array, name, "num_bits", num_bits, 1);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -2791,10 +3134,18 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Blake2s";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "inputs", inputs, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
+                std::string name = "Blake2s";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "inputs", inputs, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "inputs", inputs, 0);
+                    Helpers::conv_fld_from_array(array, name, "outputs", outputs, 1);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -2813,10 +3164,18 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Blake3";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "inputs", inputs, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
+                std::string name = "Blake3";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "inputs", inputs, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "inputs", inputs, 0);
+                    Helpers::conv_fld_from_array(array, name, "outputs", outputs, 1);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -2843,14 +3202,26 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "EcdsaSecp256k1";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "public_key_x", public_key_x, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "public_key_y", public_key_y, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "signature", signature, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "hashed_message", hashed_message, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "predicate", predicate, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "output", output, false);
+                std::string name = "EcdsaSecp256k1";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "public_key_x", public_key_x, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "public_key_y", public_key_y, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "signature", signature, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "hashed_message", hashed_message, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "predicate", predicate, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "output", output, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "public_key_x", public_key_x, 0);
+                    Helpers::conv_fld_from_array(array, name, "public_key_y", public_key_y, 1);
+                    Helpers::conv_fld_from_array(array, name, "signature", signature, 2);
+                    Helpers::conv_fld_from_array(array, name, "hashed_message", hashed_message, 3);
+                    Helpers::conv_fld_from_array(array, name, "predicate", predicate, 4);
+                    Helpers::conv_fld_from_array(array, name, "output", output, 5);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -2877,14 +3248,26 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "EcdsaSecp256r1";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "public_key_x", public_key_x, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "public_key_y", public_key_y, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "signature", signature, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "hashed_message", hashed_message, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "predicate", predicate, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "output", output, false);
+                std::string name = "EcdsaSecp256r1";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "public_key_x", public_key_x, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "public_key_y", public_key_y, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "signature", signature, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "hashed_message", hashed_message, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "predicate", predicate, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "output", output, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "public_key_x", public_key_x, 0);
+                    Helpers::conv_fld_from_array(array, name, "public_key_y", public_key_y, 1);
+                    Helpers::conv_fld_from_array(array, name, "signature", signature, 2);
+                    Helpers::conv_fld_from_array(array, name, "hashed_message", hashed_message, 3);
+                    Helpers::conv_fld_from_array(array, name, "predicate", predicate, 4);
+                    Helpers::conv_fld_from_array(array, name, "output", output, 5);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -2907,12 +3290,22 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "MultiScalarMul";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "points", points, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "scalars", scalars, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "predicate", predicate, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
+                std::string name = "MultiScalarMul";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "points", points, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "scalars", scalars, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "predicate", predicate, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "points", points, 0);
+                    Helpers::conv_fld_from_array(array, name, "scalars", scalars, 1);
+                    Helpers::conv_fld_from_array(array, name, "predicate", predicate, 2);
+                    Helpers::conv_fld_from_array(array, name, "outputs", outputs, 3);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -2935,12 +3328,22 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "EmbeddedCurveAdd";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "input1", input1, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "input2", input2, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "predicate", predicate, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
+                std::string name = "EmbeddedCurveAdd";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "input1", input1, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "input2", input2, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "predicate", predicate, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "input1", input1, 0);
+                    Helpers::conv_fld_from_array(array, name, "input2", input2, 1);
+                    Helpers::conv_fld_from_array(array, name, "predicate", predicate, 2);
+                    Helpers::conv_fld_from_array(array, name, "outputs", outputs, 3);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -2959,10 +3362,18 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Keccakf1600";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "inputs", inputs, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
+                std::string name = "Keccakf1600";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "inputs", inputs, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "inputs", inputs, 0);
+                    Helpers::conv_fld_from_array(array, name, "outputs", outputs, 1);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -2989,14 +3400,26 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "RecursiveAggregation";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "verification_key", verification_key, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "proof", proof, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "public_inputs", public_inputs, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "key_hash", key_hash, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "proof_type", proof_type, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "predicate", predicate, false);
+                std::string name = "RecursiveAggregation";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "verification_key", verification_key, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "proof", proof, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "public_inputs", public_inputs, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "key_hash", key_hash, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "proof_type", proof_type, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "predicate", predicate, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "verification_key", verification_key, 0);
+                    Helpers::conv_fld_from_array(array, name, "proof", proof, 1);
+                    Helpers::conv_fld_from_array(array, name, "public_inputs", public_inputs, 2);
+                    Helpers::conv_fld_from_array(array, name, "key_hash", key_hash, 3);
+                    Helpers::conv_fld_from_array(array, name, "proof_type", proof_type, 4);
+                    Helpers::conv_fld_from_array(array, name, "predicate", predicate, 5);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -3015,10 +3438,18 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Poseidon2Permutation";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "inputs", inputs, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
+                std::string name = "Poseidon2Permutation";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "inputs", inputs, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "inputs", inputs, 0);
+                    Helpers::conv_fld_from_array(array, name, "outputs", outputs, 1);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -3039,11 +3470,20 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Sha256Compression";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "inputs", inputs, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "hash_values", hash_values, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
+                std::string name = "Sha256Compression";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "inputs", inputs, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "hash_values", hash_values, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "inputs", inputs, 0);
+                    Helpers::conv_fld_from_array(array, name, "hash_values", hash_values, 1);
+                    Helpers::conv_fld_from_array(array, name, "outputs", outputs, 2);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -3121,9 +3561,9 @@ namespace Acir {
                 packer.pack(tag);
             } else {
                 std::visit([&packer, tag](const auto& arg) {
-                    std::map<std::string, msgpack::object> data;
-                    data[tag] = msgpack::object(arg);
-                    packer.pack(data);
+                    packer.pack_map(1);
+                    packer.pack(tag);
+                    arg.msgpack_pack(packer);
                 }, value);
             }
         }
@@ -3397,9 +3837,9 @@ namespace Acir {
                 packer.pack(tag);
             } else {
                 std::visit([&packer, tag](const auto& arg) {
-                    std::map<std::string, msgpack::object> data;
-                    data[tag] = msgpack::object(arg);
-                    packer.pack(data);
+                    packer.pack_map(1);
+                    packer.pack(tag);
+                    arg.msgpack_pack(packer);
                 }, value);
             }
         }
@@ -3467,11 +3907,20 @@ namespace Acir {
         }
 
         void msgpack_unpack(msgpack::object const& o) {
-            auto name = "Expression";
-            auto kvmap = Helpers::make_kvmap(o, name);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "mul_terms", mul_terms, false);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "linear_combinations", linear_combinations, false);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "q_c", q_c, false);
+            std::string name = "Expression";
+            if (o.type == msgpack::type::MAP) {
+                auto kvmap = Helpers::make_kvmap(o, name);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "mul_terms", mul_terms, false);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "linear_combinations", linear_combinations, false);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "q_c", q_c, false);
+            } else if (o.type == msgpack::type::ARRAY) {
+                auto array = o.via.array; 
+                Helpers::conv_fld_from_array(array, name, "mul_terms", mul_terms, 0);
+                Helpers::conv_fld_from_array(array, name, "linear_combinations", linear_combinations, 1);
+                Helpers::conv_fld_from_array(array, name, "q_c", q_c, 2);
+            } else {
+                throw_or_abort("expected MAP or ARRAY for " + name);
+            }
         }
     };
 
@@ -3564,9 +4013,9 @@ namespace Acir {
                 packer.pack(tag);
             } else {
                 std::visit([&packer, tag](const auto& arg) {
-                    std::map<std::string, msgpack::object> data;
-                    data[tag] = msgpack::object(arg);
-                    packer.pack(data);
+                    packer.pack_map(1);
+                    packer.pack(tag);
+                    arg.msgpack_pack(packer);
                 }, value);
             }
         }
@@ -3697,9 +4146,9 @@ namespace Acir {
                 packer.pack(tag);
             } else {
                 std::visit([&packer, tag](const auto& arg) {
-                    std::map<std::string, msgpack::object> data;
-                    data[tag] = msgpack::object(arg);
-                    packer.pack(data);
+                    packer.pack_map(1);
+                    packer.pack(tag);
+                    arg.msgpack_pack(packer);
                 }, value);
             }
         }
@@ -3770,11 +4219,20 @@ namespace Acir {
         }
 
         void msgpack_unpack(msgpack::object const& o) {
-            auto name = "MemOp";
-            auto kvmap = Helpers::make_kvmap(o, name);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "operation", operation, false);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "index", index, false);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "value", value, false);
+            std::string name = "MemOp";
+            if (o.type == msgpack::type::MAP) {
+                auto kvmap = Helpers::make_kvmap(o, name);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "operation", operation, false);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "index", index, false);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "value", value, false);
+            } else if (o.type == msgpack::type::ARRAY) {
+                auto array = o.via.array; 
+                Helpers::conv_fld_from_array(array, name, "operation", operation, 0);
+                Helpers::conv_fld_from_array(array, name, "index", index, 1);
+                Helpers::conv_fld_from_array(array, name, "value", value, 2);
+            } else {
+                throw_or_abort("expected MAP or ARRAY for " + name);
+            }
         }
     };
 
@@ -3833,10 +4291,18 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "MemoryOp";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "block_id", block_id, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "op", op, false);
+                std::string name = "MemoryOp";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "block_id", block_id, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "op", op, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "block_id", block_id, 0);
+                    Helpers::conv_fld_from_array(array, name, "op", op, 1);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -3857,11 +4323,20 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "MemoryInit";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "block_id", block_id, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "init", init, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "block_type", block_type, false);
+                std::string name = "MemoryInit";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "block_id", block_id, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "init", init, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "block_type", block_type, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "block_id", block_id, 0);
+                    Helpers::conv_fld_from_array(array, name, "init", init, 1);
+                    Helpers::conv_fld_from_array(array, name, "block_type", block_type, 2);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -3884,12 +4359,22 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "BrilligCall";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "id", id, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "inputs", inputs, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "predicate", predicate, true);
+                std::string name = "BrilligCall";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "id", id, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "inputs", inputs, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "predicate", predicate, true);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "id", id, 0);
+                    Helpers::conv_fld_from_array(array, name, "inputs", inputs, 1);
+                    Helpers::conv_fld_from_array(array, name, "outputs", outputs, 2);
+                    Helpers::conv_fld_from_array(array, name, "predicate", predicate, 3);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -3912,12 +4397,22 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Call";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "id", id, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "inputs", inputs, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "predicate", predicate, true);
+                std::string name = "Call";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "id", id, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "inputs", inputs, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "predicate", predicate, true);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "id", id, 0);
+                    Helpers::conv_fld_from_array(array, name, "inputs", inputs, 1);
+                    Helpers::conv_fld_from_array(array, name, "outputs", outputs, 2);
+                    Helpers::conv_fld_from_array(array, name, "predicate", predicate, 3);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -3963,9 +4458,9 @@ namespace Acir {
                 packer.pack(tag);
             } else {
                 std::visit([&packer, tag](const auto& arg) {
-                    std::map<std::string, msgpack::object> data;
-                    data[tag] = msgpack::object(arg);
-                    packer.pack(data);
+                    packer.pack_map(1);
+                    packer.pack(tag);
+                    arg.msgpack_pack(packer);
                 }, value);
             }
         }
@@ -4129,9 +4624,9 @@ namespace Acir {
                 packer.pack(tag);
             } else {
                 std::visit([&packer, tag](const auto& arg) {
-                    std::map<std::string, msgpack::object> data;
-                    data[tag] = msgpack::object(arg);
-                    packer.pack(data);
+                    packer.pack_map(1);
+                    packer.pack(tag);
+                    arg.msgpack_pack(packer);
                 }, value);
             }
         }
@@ -4200,10 +4695,18 @@ namespace Acir {
         }
 
         void msgpack_unpack(msgpack::object const& o) {
-            auto name = "AssertionPayload";
-            auto kvmap = Helpers::make_kvmap(o, name);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "error_selector", error_selector, false);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "payload", payload, false);
+            std::string name = "AssertionPayload";
+            if (o.type == msgpack::type::MAP) {
+                auto kvmap = Helpers::make_kvmap(o, name);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "error_selector", error_selector, false);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "payload", payload, false);
+            } else if (o.type == msgpack::type::ARRAY) {
+                auto array = o.via.array; 
+                Helpers::conv_fld_from_array(array, name, "error_selector", error_selector, 0);
+                Helpers::conv_fld_from_array(array, name, "payload", payload, 1);
+            } else {
+                throw_or_abort("expected MAP or ARRAY for " + name);
+            }
         }
     };
 
@@ -4243,10 +4746,18 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Brillig";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "acir_index", acir_index, false);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "brillig_index", brillig_index, false);
+                std::string name = "Brillig";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "acir_index", acir_index, false);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "brillig_index", brillig_index, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "acir_index", acir_index, 0);
+                    Helpers::conv_fld_from_array(array, name, "brillig_index", brillig_index, 1);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -4276,9 +4787,9 @@ namespace Acir {
                 packer.pack(tag);
             } else {
                 std::visit([&packer, tag](const auto& arg) {
-                    std::map<std::string, msgpack::object> data;
-                    data[tag] = msgpack::object(arg);
-                    packer.pack(data);
+                    packer.pack_map(1);
+                    packer.pack(tag);
+                    arg.msgpack_pack(packer);
                 }, value);
             }
         }
@@ -4376,15 +4887,28 @@ namespace Acir {
         }
 
         void msgpack_unpack(msgpack::object const& o) {
-            auto name = "Circuit";
-            auto kvmap = Helpers::make_kvmap(o, name);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "function_name", function_name, false);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "current_witness_index", current_witness_index, false);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "opcodes", opcodes, false);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "private_parameters", private_parameters, false);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "public_parameters", public_parameters, false);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "return_values", return_values, false);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "assert_messages", assert_messages, false);
+            std::string name = "Circuit";
+            if (o.type == msgpack::type::MAP) {
+                auto kvmap = Helpers::make_kvmap(o, name);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "function_name", function_name, false);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "current_witness_index", current_witness_index, false);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "opcodes", opcodes, false);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "private_parameters", private_parameters, false);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "public_parameters", public_parameters, false);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "return_values", return_values, false);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "assert_messages", assert_messages, false);
+            } else if (o.type == msgpack::type::ARRAY) {
+                auto array = o.via.array; 
+                Helpers::conv_fld_from_array(array, name, "function_name", function_name, 0);
+                Helpers::conv_fld_from_array(array, name, "current_witness_index", current_witness_index, 1);
+                Helpers::conv_fld_from_array(array, name, "opcodes", opcodes, 2);
+                Helpers::conv_fld_from_array(array, name, "private_parameters", private_parameters, 3);
+                Helpers::conv_fld_from_array(array, name, "public_parameters", public_parameters, 4);
+                Helpers::conv_fld_from_array(array, name, "return_values", return_values, 5);
+                Helpers::conv_fld_from_array(array, name, "assert_messages", assert_messages, 6);
+            } else {
+                throw_or_abort("expected MAP or ARRAY for " + name);
+            }
         }
     };
 
@@ -4403,10 +4927,18 @@ namespace Acir {
         }
 
         void msgpack_unpack(msgpack::object const& o) {
-            auto name = "BrilligBytecode";
-            auto kvmap = Helpers::make_kvmap(o, name);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "function_name", function_name, false);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "bytecode", bytecode, false);
+            std::string name = "BrilligBytecode";
+            if (o.type == msgpack::type::MAP) {
+                auto kvmap = Helpers::make_kvmap(o, name);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "function_name", function_name, false);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "bytecode", bytecode, false);
+            } else if (o.type == msgpack::type::ARRAY) {
+                auto array = o.via.array; 
+                Helpers::conv_fld_from_array(array, name, "function_name", function_name, 0);
+                Helpers::conv_fld_from_array(array, name, "bytecode", bytecode, 1);
+            } else {
+                throw_or_abort("expected MAP or ARRAY for " + name);
+            }
         }
     };
 
@@ -4425,15 +4957,24 @@ namespace Acir {
         }
 
         void msgpack_unpack(msgpack::object const& o) {
-            auto name = "Program";
-            auto kvmap = Helpers::make_kvmap(o, name);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "functions", functions, false);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "unconstrained_functions", unconstrained_functions, false);
+            std::string name = "Program";
+            if (o.type == msgpack::type::MAP) {
+                auto kvmap = Helpers::make_kvmap(o, name);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "functions", functions, false);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "unconstrained_functions", unconstrained_functions, false);
+            } else if (o.type == msgpack::type::ARRAY) {
+                auto array = o.via.array; 
+                Helpers::conv_fld_from_array(array, name, "functions", functions, 0);
+                Helpers::conv_fld_from_array(array, name, "unconstrained_functions", unconstrained_functions, 1);
+            } else {
+                throw_or_abort("expected MAP or ARRAY for " + name);
+            }
         }
     };
 
     struct ProgramWithoutBrillig {
         std::vector<Acir::Circuit> functions;
+        std::monostate unconstrained_functions;
 
         friend bool operator==(const ProgramWithoutBrillig&, const ProgramWithoutBrillig&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -4445,9 +4986,16 @@ namespace Acir {
         }
 
         void msgpack_unpack(msgpack::object const& o) {
-            auto name = "ProgramWithoutBrillig";
-            auto kvmap = Helpers::make_kvmap(o, name);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "functions", functions, false);
+            std::string name = "ProgramWithoutBrillig";
+            if (o.type == msgpack::type::MAP) {
+                auto kvmap = Helpers::make_kvmap(o, name);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "functions", functions, false);
+            } else if (o.type == msgpack::type::ARRAY) {
+                auto array = o.via.array; 
+                Helpers::conv_fld_from_array(array, name, "functions", functions, 0);
+            } else {
+                throw_or_abort("expected MAP or ARRAY for " + name);
+            }
         }
     };
 
@@ -4475,9 +5023,16 @@ namespace Acir {
             }
 
             void msgpack_unpack(msgpack::object const& o) {
-                auto name = "Bounded";
-                auto kvmap = Helpers::make_kvmap(o, name);
-                Helpers::conv_fld_from_kvmap(kvmap, name, "width", width, false);
+                std::string name = "Bounded";
+                if (o.type == msgpack::type::MAP) {
+                    auto kvmap = Helpers::make_kvmap(o, name);
+                    Helpers::conv_fld_from_kvmap(kvmap, name, "width", width, false);
+                } else if (o.type == msgpack::type::ARRAY) {
+                    auto array = o.via.array; 
+                    Helpers::conv_fld_from_array(array, name, "width", width, 0);
+                } else {
+                    throw_or_abort("expected MAP or ARRAY for " + name);
+                }
             }
         };
 
@@ -4507,9 +5062,9 @@ namespace Acir {
                 packer.pack(tag);
             } else {
                 std::visit([&packer, tag](const auto& arg) {
-                    std::map<std::string, msgpack::object> data;
-                    data[tag] = msgpack::object(arg);
-                    packer.pack(data);
+                    packer.pack_map(1);
+                    packer.pack(tag);
+                    arg.msgpack_pack(packer);
                 }, value);
             }
         }
@@ -9684,6 +10239,7 @@ namespace Acir {
 
     inline bool operator==(const ProgramWithoutBrillig &lhs, const ProgramWithoutBrillig &rhs) {
         if (!(lhs.functions == rhs.functions)) { return false; }
+        if (!(lhs.unconstrained_functions == rhs.unconstrained_functions)) { return false; }
         return true;
     }
 
@@ -9709,6 +10265,7 @@ template <typename Serializer>
 void serde::Serializable<Acir::ProgramWithoutBrillig>::serialize(const Acir::ProgramWithoutBrillig &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.functions)>::serialize(obj.functions, serializer);
+    serde::Serializable<decltype(obj.unconstrained_functions)>::serialize(obj.unconstrained_functions, serializer);
     serializer.decrease_container_depth();
 }
 
@@ -9718,6 +10275,7 @@ Acir::ProgramWithoutBrillig serde::Deserializable<Acir::ProgramWithoutBrillig>::
     deserializer.increase_container_depth();
     Acir::ProgramWithoutBrillig obj;
     obj.functions = serde::Deserializable<decltype(obj.functions)>::deserialize(deserializer);
+    obj.unconstrained_functions = serde::Deserializable<decltype(obj.unconstrained_functions)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
diff --git a/acvm-repo/acir/codegen/witness.cpp b/acvm-repo/acir/codegen/witness.cpp
index 01825d0acb7..15ae319fdcb 100644
--- a/acvm-repo/acir/codegen/witness.cpp
+++ b/acvm-repo/acir/codegen/witness.cpp
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "serde.hpp"
-#include "msgpack.hpp"
+#include "barretenberg/serialize/msgpack_impl.hpp"
 #include "bincode.hpp"
 
 namespace Witnesses {
@@ -10,7 +10,7 @@ namespace Witnesses {
             msgpack::object const& o,
             std::string const& name
         ) {
-            if(o.type != msgpack::type::MAP) {
+            if (o.type != msgpack::type::MAP) {
                 std::cerr << o << std::endl;
                 throw_or_abort("expected MAP for " + name);
             }
@@ -28,6 +28,7 @@ namespace Witnesses {
             }
             return kvmap;
         }
+
         template<typename T>
         static void conv_fld_from_kvmap(
             std::map<std::string, msgpack::object const*> const& kvmap,
@@ -48,6 +49,26 @@ namespace Witnesses {
                 throw_or_abort("missing field: " + struct_name + "::" + field_name);
             }
         }
+
+        template<typename T>
+        static void conv_fld_from_array(
+            msgpack::object_array const& array,
+            std::string const& struct_name,
+            std::string const& field_name,
+            T& field,
+            uint32_t index
+        ) {
+            if (index >= array.size) {
+                throw_or_abort("index out of bounds: " + struct_name + "::" + field_name + " at " + std::to_string(index));
+            }
+            auto element = array.ptr[index];
+            try {
+                element.convert(field);
+            } catch (const msgpack::type_error&) {
+                std::cerr << element << std::endl;
+                throw_or_abort("error converting into field " + struct_name + "::" + field_name);
+            }
+        }
     };
     }
 
@@ -106,10 +127,18 @@ namespace Witnesses {
         }
 
         void msgpack_unpack(msgpack::object const& o) {
-            auto name = "StackItem";
-            auto kvmap = Helpers::make_kvmap(o, name);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "index", index, false);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "witness", witness, false);
+            std::string name = "StackItem";
+            if (o.type == msgpack::type::MAP) {
+                auto kvmap = Helpers::make_kvmap(o, name);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "index", index, false);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "witness", witness, false);
+            } else if (o.type == msgpack::type::ARRAY) {
+                auto array = o.via.array; 
+                Helpers::conv_fld_from_array(array, name, "index", index, 0);
+                Helpers::conv_fld_from_array(array, name, "witness", witness, 1);
+            } else {
+                throw_or_abort("expected MAP or ARRAY for " + name);
+            }
         }
     };
 
@@ -126,9 +155,16 @@ namespace Witnesses {
         }
 
         void msgpack_unpack(msgpack::object const& o) {
-            auto name = "WitnessStack";
-            auto kvmap = Helpers::make_kvmap(o, name);
-            Helpers::conv_fld_from_kvmap(kvmap, name, "stack", stack, false);
+            std::string name = "WitnessStack";
+            if (o.type == msgpack::type::MAP) {
+                auto kvmap = Helpers::make_kvmap(o, name);
+                Helpers::conv_fld_from_kvmap(kvmap, name, "stack", stack, false);
+            } else if (o.type == msgpack::type::ARRAY) {
+                auto array = o.via.array; 
+                Helpers::conv_fld_from_array(array, name, "stack", stack, 0);
+            } else {
+                throw_or_abort("expected MAP or ARRAY for " + name);
+            }
         }
     };
 
diff --git a/acvm-repo/acir/src/circuit/mod.rs b/acvm-repo/acir/src/circuit/mod.rs
index 1f61c3f0168..08c3aeb2bd1 100644
--- a/acvm-repo/acir/src/circuit/mod.rs
+++ b/acvm-repo/acir/src/circuit/mod.rs
@@ -5,9 +5,10 @@ pub mod brillig;
 pub mod opcodes;
 
 use crate::{
+    SerializationFormat,
     circuit::opcodes::display_opcode,
     native_types::{Expression, Witness},
-    serialization::{deserialize_any_format, serialize_with_format_from_env},
+    serialization::{self, deserialize_any_format, serialize_with_format},
 };
 use acir_field::AcirField;
 pub use opcodes::Opcode;
@@ -266,24 +267,30 @@ impl<F: AcirField> Circuit<F> {
 }
 
 impl<F: Serialize + AcirField> Program<F> {
-    /// Serialize and compress the [Program] into bytes.
-    fn write<W: Write>(&self, writer: W) -> std::io::Result<()> {
-        let buf = serialize_with_format_from_env(self)?;
-
+    /// Compress a serialized [Program].
+    fn compress(buf: Vec<u8>) -> std::io::Result<Vec<u8>> {
+        let mut compressed: Vec<u8> = Vec::new();
         // Compress the data, which should help with formats that uses field names.
-        let mut encoder = flate2::write::GzEncoder::new(writer, Compression::default());
+        let mut encoder = flate2::write::GzEncoder::new(&mut compressed, Compression::default());
         encoder.write_all(&buf)?;
         encoder.finish()?;
-        Ok(())
+        Ok(compressed)
+    }
+
+    /// Serialize and compress a [Program] into bytes, using the given format.
+    pub fn serialize_program_with_format(program: &Self, format: serialization::Format) -> Vec<u8> {
+        let program_bytes =
+            serialize_with_format(program, format).expect("expected circuit to be serializable");
+        Self::compress(program_bytes).expect("expected circuit to compress")
     }
 
+    /// Serialize and compress a [Program] into bytes, using the format from the environment, or the default format.
     pub fn serialize_program(program: &Self) -> Vec<u8> {
-        let mut program_bytes: Vec<u8> = Vec::new();
-        program.write(&mut program_bytes).expect("expected circuit to be serializable");
-        program_bytes
+        let format = SerializationFormat::from_env().expect("invalid format");
+        Self::serialize_program_with_format(program, format.unwrap_or_default())
     }
 
-    /// Serialize and base64 encode program
+    /// Serialize, compress then base64 encode a [Program], using the format from the environment, or the default format,
     pub fn serialize_program_base64<S>(program: &Self, s: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
diff --git a/acvm-repo/acir/src/lib.rs b/acvm-repo/acir/src/lib.rs
index 278902f6c4e..5ffc19d9b6e 100644
--- a/acvm-repo/acir/src/lib.rs
+++ b/acvm-repo/acir/src/lib.rs
@@ -19,6 +19,7 @@ pub use brillig;
 pub use circuit::black_box_functions::BlackBoxFunc;
 pub use circuit::opcodes::InvalidInputBitSize;
 pub use parser::parse_opcodes;
+pub use serialization::Format as SerializationFormat;
 
 #[cfg(test)]
 mod reflection {
@@ -75,6 +76,11 @@ mod reflection {
     #[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Default, Hash)]
     struct ProgramWithoutBrillig<F: AcirField> {
         pub functions: Vec<Circuit<F>>,
+        /// We want to ignore this field. By setting its type as `unit`
+        /// it will not be deserialized, but it will correctly maintain
+        /// the position of the others (although in this case it doesn't)
+        /// matter since it's the last field.
+        pub unconstrained_functions: (),
     }
 
     #[test]
@@ -225,7 +231,10 @@ mod reflection {
         fn add_preamble(source: &mut String) {
             let inc = r#"#include "serde.hpp""#;
             let pos = source.find(inc).expect("serde.hpp missing");
-            source.insert_str(pos + inc.len(), "\n#include \"msgpack.hpp\"");
+            source.insert_str(
+                pos + inc.len(),
+                "\n#include \"barretenberg/serialize/msgpack_impl.hpp\"",
+            );
         }
 
         /// Add helper functions to cut down repetition in the generated code.
@@ -239,7 +248,7 @@ mod reflection {
             msgpack::object const& o,
             std::string const& name
         ) {
-            if(o.type != msgpack::type::MAP) {
+            if (o.type != msgpack::type::MAP) {
                 std::cerr << o << std::endl;
                 throw_or_abort("expected MAP for " + name);
             }
@@ -257,6 +266,7 @@ mod reflection {
             }
             return kvmap;
         }
+
         template<typename T>
         static void conv_fld_from_kvmap(
             std::map<std::string, msgpack::object const*> const& kvmap,
@@ -277,6 +287,26 @@ mod reflection {
                 throw_or_abort("missing field: " + struct_name + "::" + field_name);
             }
         }
+
+        template<typename T>
+        static void conv_fld_from_array(
+            msgpack::object_array const& array,
+            std::string const& struct_name,
+            std::string const& field_name,
+            T& field,
+            uint32_t index
+        ) {
+            if (index >= array.size) {
+                throw_or_abort("index out of bounds: " + struct_name + "::" + field_name + " at " + std::to_string(index));
+            }
+            auto element = array.ptr[index];
+            try {
+                element.convert(field);
+            } catch (const msgpack::type_error&) {
+                std::cerr << element << std::endl;
+                throw_or_abort("error converting into field " + struct_name + "::" + field_name);
+            }
+        }
     };
     "#;
             // cSpell:enable
@@ -361,13 +391,24 @@ mod reflection {
             // or we could reject the data if there was a new field we could
             // not recognize, or we could even handle aliases.
 
+            // We treat unit fields as special, using them to ignore fields during deserialization:
+            // * in 'map' format we skip over them, never try to deserialize them from the map
+            // * in 'tuple' format we jump over their index, ignoring whatever is in that position
+            fn is_unit(field: &Named<Format>) -> bool {
+                matches!(field.value, Format::Unit)
+            }
+
+            let non_unit_field_count = fields.iter().filter(|f| !is_unit(f)).count();
+
             self.msgpack_pack(name, &{
                 let mut body = format!(
                     "
-    packer.pack_map({});",
-                    fields.len()
+    packer.pack_map({non_unit_field_count});",
                 );
                 for field in fields {
+                    if is_unit(field) {
+                        continue;
+                    }
                     let field_name = &field.name;
                     body.push_str(&format!(
                         r#"
@@ -383,20 +424,48 @@ mod reflection {
                 // cSpell:disable
                 let mut body = format!(
                     r#"
-    auto name = "{name}";
-    auto kvmap = Helpers::make_kvmap(o, name);"#
+    std::string name = "{name}";
+    if (o.type == msgpack::type::MAP) {{
+        auto kvmap = Helpers::make_kvmap(o, name);"#
                 );
                 // cSpell:enable
                 for field in fields {
+                    if is_unit(field) {
+                        continue;
+                    }
                     let field_name = &field.name;
                     let is_optional = matches!(field.value, Format::Option(_));
                     // cSpell:disable
                     body.push_str(&format!(
                         r#"
-    Helpers::conv_fld_from_kvmap(kvmap, name, "{field_name}", {field_name}, {is_optional});"#
+        Helpers::conv_fld_from_kvmap(kvmap, name, "{field_name}", {field_name}, {is_optional});"#
                     ));
                     // cSpell:enable
                 }
+                body.push_str(
+                    "
+    } else if (o.type == msgpack::type::ARRAY) {
+        auto array = o.via.array; ",
+                );
+                for (index, field) in fields.iter().enumerate() {
+                    if is_unit(field) {
+                        continue;
+                    }
+                    let field_name = &field.name;
+                    // cSpell:disable
+                    body.push_str(&format!(
+                        r#"
+        Helpers::conv_fld_from_array(array, name, "{field_name}", {field_name}, {index});"#
+                    ));
+                    // cSpell:enable
+                }
+
+                body.push_str(
+                    r#"
+    } else {
+        throw_or_abort("expected MAP or ARRAY for " + name);
+    }"#,
+                );
                 body
             });
         }
@@ -466,9 +535,9 @@ mod reflection {
         packer.pack(tag);
     }} else {{
         std::visit([&packer, tag](const auto& arg) {{
-            std::map<std::string, msgpack::object> data;
-            data[tag] = msgpack::object(arg);
-            packer.pack(data);
+            packer.pack_map(1);
+            packer.pack(tag);
+            arg.msgpack_pack(packer);
         }}, value);
     }}"#
                 )
diff --git a/acvm-repo/acir/src/native_types/witness_map.rs b/acvm-repo/acir/src/native_types/witness_map.rs
index cae4c53e302..1cf19a5b65a 100644
--- a/acvm-repo/acir/src/native_types/witness_map.rs
+++ b/acvm-repo/acir/src/native_types/witness_map.rs
@@ -11,7 +11,7 @@ use flate2::bufread::GzEncoder;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
-use crate::{native_types::Witness, serialization};
+use crate::{SerializationFormat, native_types::Witness, serialization};
 
 #[derive(Debug, Error)]
 enum SerializationError {
@@ -91,7 +91,17 @@ impl<F> From<BTreeMap<Witness, F>> for WitnessMap<F> {
 impl<F: AcirField + Serialize> WitnessMap<F> {
     /// Serialize and compress.
     pub fn serialize(&self) -> Result<Vec<u8>, WitnessMapError> {
-        let buf = serialization::serialize_with_format_from_env(self)
+        let format = SerializationFormat::from_env()
+            .map_err(|err| SerializationError::Serialize(std::io::Error::other(err)))?;
+        self.serialize_with_format(format.unwrap_or_default())
+    }
+
+    /// Serialize and compress with a given format.
+    pub fn serialize_with_format(
+        &self,
+        format: SerializationFormat,
+    ) -> Result<Vec<u8>, WitnessMapError> {
+        let buf = serialization::serialize_with_format(self, format)
             .map_err(|e| WitnessMapError(SerializationError::Serialize(e)))?;
 
         let mut deflater = GzEncoder::new(buf.as_slice(), Compression::best());
diff --git a/acvm-repo/acir/src/native_types/witness_stack.rs b/acvm-repo/acir/src/native_types/witness_stack.rs
index 368f85e4abc..0db806b1ec9 100644
--- a/acvm-repo/acir/src/native_types/witness_stack.rs
+++ b/acvm-repo/acir/src/native_types/witness_stack.rs
@@ -7,6 +7,7 @@ use flate2::bufread::GzEncoder;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
+use crate::SerializationFormat;
 use crate::serialization;
 
 use super::WitnessMap;
@@ -72,7 +73,17 @@ impl<F> WitnessStack<F> {
 impl<F: AcirField + Serialize> WitnessStack<F> {
     /// Serialize and compress.
     pub fn serialize(&self) -> Result<Vec<u8>, WitnessStackError> {
-        let buf = serialization::serialize_with_format_from_env(self)
+        let format = SerializationFormat::from_env()
+            .map_err(|err| SerializationError::Serialize(std::io::Error::other(err)))?;
+        self.serialize_with_format(format.unwrap_or_default())
+    }
+
+    /// Serialize and compress with a given format.
+    pub fn serialize_with_format(
+        &self,
+        format: SerializationFormat,
+    ) -> Result<Vec<u8>, WitnessStackError> {
+        let buf = serialization::serialize_with_format(self, format)
             .map_err(|e| WitnessStackError(SerializationError::Serialize(e)))?;
 
         let mut deflater = GzEncoder::new(buf.as_slice(), Compression::best());
diff --git a/acvm-repo/acir/src/serialization.rs b/acvm-repo/acir/src/serialization.rs
index 93e2bbfe77c..185aa9e5792 100644
--- a/acvm-repo/acir/src/serialization.rs
+++ b/acvm-repo/acir/src/serialization.rs
@@ -11,7 +11,7 @@ const FORMAT_ENV_VAR: &str = "NOIR_SERIALIZATION_FORMAT";
 #[derive(Debug, Clone, Copy, IntoPrimitive, TryFromPrimitive, EnumString, PartialEq, Eq)]
 #[strum(serialize_all = "kebab-case")]
 #[repr(u8)]
-pub(crate) enum Format {
+pub enum Format {
     /// Bincode without format marker.
     /// This does not actually appear in the data.
     BincodeLegacy = 0,
@@ -23,6 +23,12 @@ pub(crate) enum Format {
     MsgpackCompact = 3,
 }
 
+impl Default for Format {
+    fn default() -> Self {
+        Self::MsgpackCompact
+    }
+}
+
 impl Format {
     /// Look for a `NOIR_SERIALIZATION_FORMAT` env var to turn on formatted serialization.
     ///
@@ -30,7 +36,7 @@ impl Format {
     /// 1. It has to be picked up in methods like `Program::serialize_program_base64` where no config is available.
     /// 2. At the moment this is mostly for testing, to be able to commit code that _can_ produce different formats,
     ///    but only activate it once a version of `bb` that can handle it is released.
-    pub(crate) fn from_env() -> Result<Option<Self>, String> {
+    pub fn from_env() -> Result<Option<Self>, String> {
         let Ok(format) = std::env::var(FORMAT_ENV_VAR) else {
             return Ok(None);
         };
@@ -65,25 +71,33 @@ pub(crate) fn bincode_deserialize<T: for<'a> Deserialize<'a>>(buf: &[u8]) -> std
 ///
 /// Set `compact` to `true` if we want old readers to fail when a new field is added to a struct,
 /// that is, if we think that ignoring a new field could lead to incorrect behavior.
-#[allow(dead_code)]
 pub(crate) fn msgpack_serialize<T: Serialize>(
     value: &T,
     compact: bool,
 ) -> std::io::Result<Vec<u8>> {
-    if compact {
-        // The default behavior encodes struct fields as
-        rmp_serde::to_vec(value).map_err(std::io::Error::other)
+    // There are convenience methods to serialize structs as tuples or maps:
+    // * `rmp_serde::to_vec` uses tuples
+    // * `rmp_serde::to_vec_named` uses maps
+    // However it looks like the default `BytesMode` is not compatible with the C++ deserializer,
+    // so we have to use `rmp_serde::Serializer` directly.
+    let mut buf = Vec::new();
+
+    let serializer = rmp_serde::Serializer::new(&mut buf)
+        .with_bytes(rmp_serde::config::BytesMode::ForceIterables);
+
+    let result = if compact {
+        value.serialize(&mut serializer.with_struct_tuple())
     } else {
-        // Or this to be able to configure the serialization:
-        // * `Serializer::with_struct_map` encodes structs with field names instead of positions, which is backwards compatible when new fields are added, or optional fields removed.
-        // * consider using `Serializer::with_bytes` to force buffers to be compact, or use `serde_bytes` on the field.
-        // * enums have their name encoded in `Serializer::serialize_newtype_variant`, but originally it was done by index instead
-        rmp_serde::to_vec_named(value).map_err(std::io::Error::other)
+        value.serialize(&mut serializer.with_struct_map())
+    };
+
+    match result {
+        Ok(()) => Ok(buf),
+        Err(e) => Err(std::io::Error::other(e)),
     }
 }
 
 /// Deserialize a value using MessagePack, based on `serde`.
-#[allow(dead_code)]
 pub(crate) fn msgpack_deserialize<T: for<'a> Deserialize<'a>>(buf: &[u8]) -> std::io::Result<T> {
     rmp_serde::from_slice(buf).map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidInput, e))
 }
@@ -139,23 +153,6 @@ where
     Ok(res)
 }
 
-pub(crate) fn serialize_with_format_from_env<T>(value: &T) -> std::io::Result<Vec<u8>>
-where
-    T: Serialize,
-{
-    match Format::from_env() {
-        Ok(Some(format)) => {
-            // This will need a new `bb` even if it's the bincode format, because of the format byte.
-            serialize_with_format(value, format)
-        }
-        Ok(None) => {
-            // This is how the currently released `bb` expects the data.
-            bincode_serialize(value)
-        }
-        Err(e) => Err(std::io::Error::other(e)),
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use acir_field::FieldElement;
diff --git a/acvm-repo/acir/tests/test_program_serialization.rs b/acvm-repo/acir/tests/test_program_serialization.rs
index f34f1fe3f82..29b8355ded9 100644
--- a/acvm-repo/acir/tests/test_program_serialization.rs
+++ b/acvm-repo/acir/tests/test_program_serialization.rs
@@ -10,6 +10,7 @@
 //! actual output, **HOWEVER** note that this results in a breaking change to the backend ACIR format.
 
 use acir::{
+    SerializationFormat,
     circuit::{Circuit, Program, brillig::BrilligBytecode},
     native_types::Witness,
 };
@@ -18,6 +19,15 @@ use brillig::{
     BitSize, HeapArray, HeapValueType, HeapVector, IntegerBitSize, MemoryAddress, ValueOrArray,
 };
 
+fn assert_deserialization(expected: &Program<FieldElement>, bytes: [Vec<u8>; 3]) {
+    for (i, bytes) in bytes.iter().enumerate() {
+        let program = Program::deserialize_program(bytes)
+            .map_err(|e| format!("failed to deserialize format {i}: {e:?}"))
+            .unwrap();
+        assert_eq!(&program, expected, "incorrect deserialized program for format {i}");
+    }
+}
+
 #[test]
 fn addition_circuit() {
     let src = "
@@ -31,12 +41,18 @@ fn addition_circuit() {
 
     let program = Program { functions: vec![circuit], unconstrained_functions: vec![] };
 
-    let bytes = Program::serialize_program(&program);
+    let bytes_legacy =
+        Program::serialize_program_with_format(&program, SerializationFormat::BincodeLegacy);
+    insta::assert_compact_debug_snapshot!(bytes_legacy, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 149, 143, 49, 10, 128, 48, 12, 69, 127, 170, 7, 113, 212, 77, 241, 8, 34, 56, 137, 163, 139, 155, 7, 16, 55, 199, 30, 65, 188, 128, 167, 16, 61, 78, 55, 71, 23, 119, 29, 90, 140, 116, 105, 31, 132, 36, 240, 73, 254, 39, 252, 9, 223, 34, 216, 4, 186, 71, 112, 130, 200, 67, 43, 152, 54, 237, 235, 81, 101, 107, 178, 55, 229, 38, 101, 219, 197, 249, 89, 77, 199, 48, 23, 234, 94, 46, 237, 195, 241, 46, 132, 121, 192, 102, 179, 3, 95, 38, 206, 3, 2, 103, 244, 195, 16, 1, 0, 0]");
 
-    insta::assert_compact_debug_snapshot!(bytes, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 149, 143, 49, 10, 128, 48, 12, 69, 127, 170, 7, 113, 212, 77, 241, 8, 34, 56, 137, 163, 139, 155, 7, 16, 55, 199, 30, 65, 188, 128, 167, 16, 61, 78, 55, 71, 23, 119, 29, 90, 140, 116, 105, 31, 132, 36, 240, 73, 254, 39, 252, 9, 223, 34, 216, 4, 186, 71, 112, 130, 200, 67, 43, 152, 54, 237, 235, 81, 101, 107, 178, 55, 229, 38, 101, 219, 197, 249, 89, 77, 199, 48, 23, 234, 94, 46, 237, 195, 241, 46, 132, 121, 192, 102, 179, 3, 95, 38, 206, 3, 2, 103, 244, 195, 16, 1, 0, 0]");
+    let bytes_msgpack =
+        Program::serialize_program_with_format(&program, SerializationFormat::Msgpack);
+    insta::assert_compact_debug_snapshot!(bytes_msgpack, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 141, 144, 187, 74, 3, 81, 16, 134, 179, 27, 31, 196, 82, 59, 197, 39, 16, 17, 172, 196, 82, 4, 25, 78, 206, 142, 114, 96, 207, 197, 153, 115, 162, 150, 171, 133, 237, 110, 242, 2, 1, 11, 137, 16, 68, 197, 91, 239, 139, 164, 179, 180, 177, 119, 8, 36, 164, 74, 50, 213, 48, 252, 252, 204, 247, 229, 55, 195, 179, 228, 116, 52, 222, 113, 115, 55, 154, 238, 224, 148, 197, 193, 155, 78, 68, 232, 34, 92, 154, 232, 144, 25, 140, 43, 240, 106, 237, 193, 7, 237, 11, 228, 166, 122, 220, 101, 70, 138, 39, 72, 254, 118, 104, 83, 9, 17, 201, 114, 253, 90, 26, 135, 138, 64, 123, 219, 49, 78, 77, 202, 251, 189, 239, 245, 214, 226, 201, 178, 21, 50, 185, 100, 182, 138, 67, 26, 111, 15, 54, 63, 143, 246, 223, 171, 234, 248, 116, 99, 231, 231, 224, 250, 43, 52, 123, 227, 191, 254, 175, 132, 218, 247, 23, 160, 151, 86, 181, 94, 2, 153, 174, 138, 8, 65, 145, 224, 202, 239, 220, 203, 242, 231, 144, 58, 165, 209, 115, 199, 122, 68, 24, 19, 57, 232, 170, 50, 9, 118, 251, 73, 77, 176, 193, 138, 19, 117, 142, 92, 127, 136, 54, 97, 140, 164, 4, 188, 128, 153, 209, 250, 31, 140, 53, 217, 21, 95, 1, 0, 0]");
 
-    let program_de = Program::deserialize_program(&bytes).unwrap();
-    assert_eq!(program_de, program);
+    let bytes_default = Program::serialize_program(&program);
+    insta::assert_compact_debug_snapshot!(bytes_default, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 141, 204, 59, 14, 64, 48, 0, 128, 225, 62, 28, 196, 200, 70, 156, 64, 68, 98, 18, 163, 72, 108, 58, 147, 214, 98, 236, 13, 250, 24, 172, 157, 29, 64, 216, 93, 164, 155, 209, 98, 215, 19, 224, 159, 191, 252, 88, 201, 217, 120, 146, 47, 41, 99, 132, 142, 13, 161, 189, 22, 90, 29, 62, 120, 15, 194, 31, 6, 57, 19, 117, 37, 181, 177, 9, 183, 42, 95, 57, 175, 219, 32, 57, 139, 105, 31, 100, 102, 111, 125, 57, 132, 63, 55, 64, 65, 36, 36, 22, 226, 1, 27, 166, 206, 10, 172, 0, 0, 0]");
+
+    assert_deserialization(&program, [bytes_legacy, bytes_msgpack, bytes_default]);
 }
 
 #[test]
@@ -52,12 +68,18 @@ fn multi_scalar_mul_circuit() {
 
     let program = Program { functions: vec![circuit], unconstrained_functions: vec![] };
 
-    let bytes = Program::serialize_program(&program);
+    let bytes_legacy =
+        Program::serialize_program_with_format(&program, SerializationFormat::BincodeLegacy);
+    insta::assert_compact_debug_snapshot!(bytes_legacy, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 141, 11, 10, 0, 32, 12, 66, 87, 235, 127, 255, 3, 183, 224, 5, 214, 64, 84, 68, 151, 236, 189, 21, 72, 232, 195, 35, 224, 226, 47, 50, 236, 232, 155, 23, 184, 194, 45, 208, 217, 153, 120, 147, 13, 167, 83, 37, 51, 249, 169, 221, 255, 54, 129, 45, 40, 232, 188, 0, 0, 0]");
+
+    let bytes_msgpack =
+        Program::serialize_program_with_format(&program, SerializationFormat::Msgpack);
+    insta::assert_compact_debug_snapshot!(bytes_msgpack, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 144, 75, 75, 3, 65, 16, 132, 201, 230, 225, 227, 103, 69, 240, 230, 201, 131, 199, 161, 157, 109, 165, 113, 210, 51, 116, 247, 196, 92, 87, 4, 175, 27, 5, 207, 158, 92, 114, 136, 47, 16, 255, 158, 67, 196, 33, 183, 143, 42, 170, 232, 174, 230, 110, 115, 149, 217, 27, 69, 214, 245, 195, 246, 159, 29, 195, 2, 95, 190, 125, 22, 65, 54, 119, 75, 198, 168, 234, 136, 91, 92, 29, 15, 49, 249, 216, 162, 174, 187, 143, 121, 0, 127, 51, 143, 171, 211, 146, 59, 129, 16, 186, 183, 179, 28, 140, 206, 61, 4, 144, 130, 247, 175, 41, 18, 155, 62, 117, 195, 197, 95, 199, 168, 82, 83, 105, 60, 232, 46, 160, 143, 85, 154, 84, 154, 110, 146, 96, 75, 30, 12, 171, 54, 27, 98, 182, 148, 75, 239, 193, 225, 209, 87, 18, 90, 22, 215, 37, 144, 114, 181, 161, 232, 243, 168, 25, 79, 166, 179, 207, 148, 47, 3, 249, 61, 163, 223, 10, 90, 22, 118, 75, 8, 25, 119, 241, 119, 80, 69, 49, 183, 40, 189, 112, 141, 218, 255, 148, 95, 202, 26, 38, 64, 140, 173, 171, 243, 244, 191, 238, 86, 173, 160, 44, 1, 0, 0]");
 
-    insta::assert_compact_debug_snapshot!(bytes, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 141, 11, 10, 0, 32, 12, 66, 87, 235, 127, 255, 3, 183, 224, 5, 214, 64, 84, 68, 151, 236, 189, 21, 72, 232, 195, 35, 224, 226, 47, 50, 236, 232, 155, 23, 184, 194, 45, 208, 217, 153, 120, 147, 13, 167, 83, 37, 51, 249, 169, 221, 255, 54, 129, 45, 40, 232, 188, 0, 0, 0]");
+    let bytes_default = Program::serialize_program(&program);
+    insta::assert_compact_debug_snapshot!(bytes_default, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 61, 198, 171, 10, 128, 48, 20, 0, 80, 116, 190, 63, 75, 193, 102, 50, 152, 199, 48, 12, 47, 19, 220, 6, 214, 253, 193, 30, 162, 213, 102, 19, 63, 81, 45, 183, 29, 226, 221, 113, 86, 206, 60, 53, 80, 54, 213, 243, 218, 106, 193, 26, 10, 96, 238, 78, 131, 226, 61, 163, 64, 151, 143, 91, 48, 215, 192, 149, 24, 165, 140, 80, 49, 138, 120, 100, 130, 74, 81, 89, 200, 139, 114, 143, 98, 146, 164, 153, 253, 109, 237, 11, 181, 107, 246, 16, 122, 0, 0, 0]");
 
-    let program_de = Program::deserialize_program(&bytes).unwrap();
-    assert_eq!(program_de, program);
+    assert_deserialization(&program, [bytes_legacy, bytes_msgpack, bytes_default]);
 }
 
 #[test]
@@ -114,12 +136,18 @@ fn simple_brillig_foreign_call() {
     let program =
         Program { functions: vec![circuit], unconstrained_functions: vec![brillig_bytecode] };
 
-    let bytes = Program::serialize_program(&program);
+    let bytes_legacy =
+        Program::serialize_program_with_format(&program, SerializationFormat::BincodeLegacy);
+    insta::assert_compact_debug_snapshot!(bytes_legacy, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 149, 81, 237, 10, 128, 32, 12, 116, 246, 193, 160, 127, 61, 65, 111, 22, 17, 253, 8, 164, 31, 17, 61, 127, 69, 91, 204, 156, 48, 7, 58, 61, 239, 240, 142, 129, 139, 11, 239, 5, 116, 174, 169, 131, 75, 139, 177, 193, 153, 10, 192, 206, 141, 254, 243, 223, 70, 15, 222, 32, 236, 168, 175, 219, 185, 236, 199, 56, 79, 33, 52, 4, 225, 143, 250, 244, 170, 192, 27, 74, 95, 229, 122, 104, 21, 80, 70, 146, 17, 152, 251, 198, 208, 166, 32, 21, 185, 123, 14, 239, 21, 156, 157, 92, 163, 94, 232, 115, 22, 2, 0, 0]");
 
-    insta::assert_compact_debug_snapshot!(bytes, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 149, 81, 237, 10, 128, 32, 12, 116, 246, 193, 160, 127, 61, 65, 111, 22, 17, 253, 8, 164, 31, 17, 61, 127, 69, 91, 204, 156, 48, 7, 58, 61, 239, 240, 142, 129, 139, 11, 239, 5, 116, 174, 169, 131, 75, 139, 177, 193, 153, 10, 192, 206, 141, 254, 243, 223, 70, 15, 222, 32, 236, 168, 175, 219, 185, 236, 199, 56, 79, 33, 52, 4, 225, 143, 250, 244, 170, 192, 27, 74, 95, 229, 122, 104, 21, 80, 70, 146, 17, 152, 251, 198, 208, 166, 32, 21, 185, 123, 14, 239, 21, 156, 157, 92, 163, 94, 232, 115, 22, 2, 0, 0]");
+    let bytes_msgpack =
+        Program::serialize_program_with_format(&program, SerializationFormat::Msgpack);
+    insta::assert_compact_debug_snapshot!(bytes_msgpack, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 165, 146, 207, 78, 27, 49, 16, 198, 179, 123, 234, 99, 244, 25, 218, 39, 104, 83, 33, 245, 208, 19, 234, 217, 114, 236, 201, 106, 36, 175, 237, 142, 103, 211, 166, 183, 77, 64, 92, 3, 18, 119, 4, 228, 159, 54, 1, 1, 66, 92, 57, 240, 96, 120, 3, 9, 33, 18, 225, 128, 79, 214, 216, 51, 223, 124, 191, 153, 180, 55, 109, 23, 86, 49, 58, 27, 14, 15, 230, 203, 187, 176, 50, 135, 147, 91, 85, 16, 129, 101, 241, 23, 217, 66, 8, 2, 173, 134, 127, 159, 198, 206, 43, 167, 33, 28, 150, 213, 119, 66, 99, 48, 107, 74, 99, 246, 78, 81, 55, 70, 104, 125, 193, 241, 101, 180, 139, 54, 51, 208, 159, 230, 133, 17, 12, 148, 135, 193, 141, 65, 11, 146, 132, 114, 121, 11, 173, 124, 146, 60, 122, 248, 220, 216, 126, 146, 228, 236, 143, 80, 239, 126, 107, 140, 93, 193, 43, 237, 220, 27, 72, 167, 158, 64, 163, 146, 12, 247, 215, 158, 176, 19, 47, 194, 75, 138, 206, 98, 67, 225, 40, 73, 175, 124, 209, 50, 168, 214, 130, 131, 57, 1, 23, 100, 69, 71, 154, 2, 194, 224, 82, 134, 0, 196, 34, 143, 238, 101, 22, 3, 119, 17, 80, 236, 155, 73, 70, 51, 90, 188, 176, 235, 189, 102, 87, 161, 237, 212, 137, 42, 146, 153, 180, 186, 12, 53, 177, 227, 114, 216, 172, 147, 251, 85, 164, 199, 207, 12, 202, 209, 15, 36, 80, 156, 76, 90, 200, 34, 224, 127, 40, 199, 63, 45, 67, 6, 116, 246, 251, 235, 151, 225, 162, 147, 247, 237, 111, 43, 157, 126, 168, 116, 82, 206, 234, 249, 106, 201, 178, 233, 124, 183, 127, 179, 166, 32, 164, 214, 20, 217, 44, 149, 26, 179, 90, 101, 51, 154, 94, 184, 118, 59, 0, 111, 198, 147, 178, 218, 113, 4, 152, 217, 90, 96, 127, 178, 36, 56, 122, 130, 55, 91, 19, 138, 99, 157, 255, 130, 220, 81, 247, 219, 134, 226, 221, 122, 59, 11, 71, 130, 187, 30, 94, 246, 96, 184, 131, 96, 244, 106, 51, 223, 40, 115, 181, 120, 223, 82, 160, 60, 223, 101, 231, 203, 234, 121, 65, 106, 28, 189, 177, 119, 24, 121, 210, 202, 208, 249, 2, 242, 210, 246, 35, 236, 162, 101, 87, 93, 3, 0, 0]");
 
-    let program_de = Program::deserialize_program(&bytes).unwrap();
-    assert_eq!(program_de, program);
+    let bytes_default = Program::serialize_program(&program);
+    insta::assert_compact_debug_snapshot!(bytes_default, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 149, 143, 49, 14, 130, 48, 20, 134, 41, 46, 30, 195, 51, 232, 9, 20, 99, 226, 224, 68, 156, 13, 129, 23, 210, 164, 180, 164, 52, 38, 140, 189, 1, 45, 18, 87, 19, 5, 7, 244, 14, 14, 30, 76, 8, 177, 36, 14, 162, 111, 126, 223, 247, 255, 255, 72, 171, 227, 105, 172, 100, 189, 224, 152, 16, 28, 58, 30, 33, 7, 75, 201, 202, 197, 52, 36, 144, 103, 74, 63, 39, 214, 247, 67, 104, 240, 165, 51, 70, 49, 1, 251, 161, 145, 157, 101, 141, 183, 198, 116, 15, 92, 236, 252, 38, 178, 144, 165, 195, 104, 34, 114, 89, 45, 49, 7, 95, 32, 121, 93, 83, 1, 33, 240, 243, 118, 54, 29, 246, 127, 242, 246, 127, 60, 146, 183, 118, 121, 224, 9, 207, 97, 113, 106, 52, 86, 239, 51, 197, 234, 21, 227, 128, 67, 218, 2, 69, 213, 141, 80, 242, 190, 129, 136, 241, 116, 30, 4, 28, 146, 196, 240, 102, 119, 185, 194, 64, 130, 95, 255, 228, 197, 21, 44, 86, 186, 79, 125, 247, 120, 1, 82, 78, 27, 216, 177, 1, 0, 0]");
+
+    assert_deserialization(&program, [bytes_legacy, bytes_msgpack, bytes_default]);
 }
 
 #[test]
@@ -229,12 +257,18 @@ fn complex_brillig_foreign_call() {
     let program =
         Program { functions: vec![circuit], unconstrained_functions: vec![brillig_bytecode] };
 
-    let bytes = Program::serialize_program(&program);
+    let bytes_legacy =
+        Program::serialize_program_with_format(&program, SerializationFormat::BincodeLegacy);
+    insta::assert_compact_debug_snapshot!(bytes_legacy, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 181, 84, 219, 10, 194, 48, 12, 109, 154, 109, 22, 244, 201, 47, 24, 232, 127, 137, 12, 223, 42, 250, 232, 231, 187, 66, 50, 178, 88, 181, 233, 182, 64, 73, 27, 206, 201, 101, 39, 12, 220, 220, 194, 120, 128, 238, 13, 121, 79, 62, 197, 81, 225, 25, 219, 187, 34, 3, 40, 199, 86, 215, 240, 110, 251, 26, 232, 236, 53, 146, 161, 177, 142, 225, 123, 89, 230, 54, 245, 207, 61, 75, 253, 211, 110, 180, 227, 233, 232, 189, 35, 31, 52, 193, 187, 207, 165, 153, 117, 66, 254, 64, 126, 120, 220, 159, 241, 246, 186, 12, 215, 24, 247, 50, 169, 226, 24, 6, 192, 160, 106, 25, 249, 211, 144, 223, 240, 156, 119, 97, 159, 61, 243, 177, 142, 15, 204, 111, 234, 248, 216, 9, 222, 20, 20, 119, 206, 155, 116, 97, 193, 73, 47, 204, 80, 53, 61, 217, 73, 189, 207, 10, 7, 5, 57, 216, 228, 127, 233, 23, 30, 50, 248, 127, 156, 181, 164, 172, 92, 185, 246, 152, 9, 114, 174, 55, 111, 172, 240, 81, 180, 5, 0, 0]");
+
+    let bytes_msgpack =
+        Program::serialize_program_with_format(&program, SerializationFormat::Msgpack);
+    insta::assert_compact_debug_snapshot!(bytes_msgpack, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 197, 85, 203, 110, 211, 64, 20, 181, 227, 20, 250, 25, 145, 224, 11, 224, 11, 74, 80, 5, 11, 86, 21, 235, 209, 196, 190, 137, 70, 26, 207, 12, 119, 198, 165, 97, 55, 9, 136, 109, 30, 75, 54, 136, 54, 47, 57, 1, 149, 10, 117, 203, 130, 15, 99, 28, 226, 224, 84, 228, 161, 166, 128, 87, 215, 71, 246, 61, 231, 158, 57, 215, 46, 181, 38, 245, 68, 132, 134, 73, 161, 187, 239, 103, 121, 77, 4, 141, 225, 227, 183, 48, 65, 4, 97, 200, 107, 102, 4, 104, 77, 152, 136, 224, 236, 112, 36, 85, 40, 35, 208, 93, 155, 62, 65, 198, 57, 107, 84, 41, 231, 111, 63, 177, 200, 27, 50, 161, 18, 163, 123, 118, 112, 132, 72, 155, 253, 246, 36, 78, 56, 49, 128, 177, 238, 92, 113, 38, 128, 34, 9, 101, 92, 99, 130, 254, 162, 236, 253, 168, 120, 155, 47, 223, 63, 127, 69, 194, 173, 143, 121, 119, 65, 85, 250, 119, 84, 193, 110, 84, 118, 120, 194, 68, 131, 195, 54, 202, 254, 46, 70, 238, 226, 192, 221, 73, 31, 201, 196, 100, 97, 232, 231, 97, 40, 31, 220, 203, 198, 137, 21, 135, 251, 121, 113, 56, 81, 8, 17, 11, 169, 129, 239, 95, 21, 178, 83, 87, 16, 69, 209, 197, 207, 13, 171, 251, 126, 41, 184, 84, 73, 141, 179, 176, 128, 118, 102, 8, 38, 65, 65, 78, 41, 79, 64, 119, 190, 80, 173, 1, 13, 137, 93, 70, 105, 195, 1, 215, 46, 198, 206, 20, 131, 212, 57, 21, 145, 223, 9, 111, 173, 38, 124, 234, 44, 116, 34, 206, 72, 232, 2, 60, 174, 53, 13, 100, 193, 254, 96, 7, 213, 236, 237, 118, 234, 66, 110, 22, 14, 219, 225, 83, 134, 16, 26, 111, 92, 99, 134, 104, 246, 6, 236, 232, 185, 48, 208, 0, 60, 127, 249, 248, 209, 96, 46, 101, 171, 41, 193, 166, 214, 254, 94, 173, 61, 59, 205, 214, 48, 162, 134, 86, 165, 106, 182, 175, 10, 12, 132, 70, 17, 58, 115, 114, 166, 202, 52, 99, 185, 137, 122, 159, 101, 189, 174, 193, 220, 196, 253, 191, 231, 71, 101, 83, 235, 96, 175, 214, 27, 85, 151, 247, 60, 197, 221, 173, 246, 255, 104, 117, 176, 198, 234, 178, 77, 143, 37, 2, 107, 136, 140, 224, 221, 56, 79, 235, 104, 17, 212, 105, 129, 201, 45, 214, 228, 25, 80, 53, 95, 174, 214, 72, 73, 230, 6, 193, 229, 185, 92, 100, 188, 129, 157, 189, 128, 88, 98, 243, 104, 149, 231, 193, 26, 252, 225, 117, 113, 148, 185, 27, 196, 52, 21, 44, 151, 184, 149, 22, 192, 110, 190, 197, 131, 99, 6, 60, 90, 48, 174, 96, 171, 119, 203, 223, 195, 173, 133, 251, 151, 243, 22, 69, 105, 189, 219, 74, 251, 63, 169, 222, 111, 203, 15, 236, 197, 137, 145, 202, 166, 139, 47, 96, 150, 193, 53, 22, 46, 9, 127, 2, 175, 169, 227, 172, 228, 7, 0, 0]");
 
-    insta::assert_compact_debug_snapshot!(bytes, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 181, 84, 219, 10, 194, 48, 12, 109, 154, 109, 22, 244, 201, 47, 24, 232, 127, 137, 12, 223, 42, 250, 232, 231, 187, 66, 50, 178, 88, 181, 233, 182, 64, 73, 27, 206, 201, 101, 39, 12, 220, 220, 194, 120, 128, 238, 13, 121, 79, 62, 197, 81, 225, 25, 219, 187, 34, 3, 40, 199, 86, 215, 240, 110, 251, 26, 232, 236, 53, 146, 161, 177, 142, 225, 123, 89, 230, 54, 245, 207, 61, 75, 253, 211, 110, 180, 227, 233, 232, 189, 35, 31, 52, 193, 187, 207, 165, 153, 117, 66, 254, 64, 126, 120, 220, 159, 241, 246, 186, 12, 215, 24, 247, 50, 169, 226, 24, 6, 192, 160, 106, 25, 249, 211, 144, 223, 240, 156, 119, 97, 159, 61, 243, 177, 142, 15, 204, 111, 234, 248, 216, 9, 222, 20, 20, 119, 206, 155, 116, 97, 193, 73, 47, 204, 80, 53, 61, 217, 73, 189, 207, 10, 7, 5, 57, 216, 228, 127, 233, 23, 30, 50, 248, 127, 156, 181, 164, 172, 92, 185, 246, 152, 9, 114, 174, 55, 111, 172, 240, 81, 180, 5, 0, 0]");
+    let bytes_default = Program::serialize_program(&program);
+    insta::assert_compact_debug_snapshot!(bytes_default, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 82, 65, 78, 195, 48, 16, 140, 235, 22, 250, 140, 72, 240, 2, 120, 65, 9, 170, 224, 192, 169, 226, 140, 172, 196, 138, 44, 185, 113, 228, 248, 64, 142, 254, 65, 108, 131, 56, 112, 65, 130, 180, 66, 45, 127, 224, 192, 195, 104, 16, 78, 213, 22, 154, 88, 141, 79, 222, 181, 103, 118, 118, 119, 160, 86, 79, 47, 67, 37, 23, 23, 156, 80, 74, 226, 0, 81, 250, 224, 105, 89, 142, 56, 71, 185, 49, 133, 210, 95, 190, 183, 255, 0, 208, 248, 197, 107, 71, 212, 235, 138, 8, 54, 19, 201, 217, 132, 36, 49, 197, 166, 48, 109, 90, 108, 163, 190, 27, 97, 198, 14, 191, 63, 56, 170, 68, 78, 83, 138, 143, 237, 101, 248, 105, 64, 15, 22, 197, 106, 10, 203, 144, 85, 153, 251, 187, 112, 181, 179, 103, 89, 6, 44, 201, 132, 145, 179, 75, 194, 113, 40, 60, 57, 191, 78, 4, 142, 49, 127, 189, 61, 63, 107, 172, 10, 183, 241, 192, 13, 239, 201, 101, 101, 157, 8, 9, 20, 176, 52, 175, 105, 252, 181, 158, 154, 248, 48, 165, 254, 54, 30, 186, 225, 119, 234, 247, 93, 39, 245, 119, 167, 96, 173, 167, 38, 94, 140, 25, 199, 36, 78, 42, 192, 227, 252, 119, 95, 70, 190, 95, 97, 148, 254, 236, 88, 215, 67, 128, 242, 227, 6, 79, 25, 207, 71, 81, 196, 113, 150, 217, 135, 147, 127, 242, 167, 214, 38, 90, 89, 111, 148, 99, 130, 105, 4, 55, 195, 205, 72, 59, 213, 6, 186, 101, 141, 142, 55, 234, 232, 189, 129, 124, 155, 8, 150, 42, 189, 235, 181, 111, 81, 157, 181, 15, 223, 4, 0, 0]");
 
-    let program_de = Program::deserialize_program(&bytes).unwrap();
-    assert_eq!(program_de, program);
+    assert_deserialization(&program, [bytes_legacy, bytes_msgpack, bytes_default]);
 }
 
 #[test]
@@ -252,12 +286,18 @@ fn memory_op_circuit() {
 
     let program = Program { functions: vec![circuit], unconstrained_functions: vec![] };
 
-    let bytes = Program::serialize_program(&program);
+    let bytes_legacy =
+        Program::serialize_program_with_format(&program, SerializationFormat::BincodeLegacy);
+    insta::assert_compact_debug_snapshot!(bytes_legacy, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 165, 81, 65, 10, 0, 32, 8, 115, 106, 255, 232, 255, 175, 172, 131, 70, 129, 7, 211, 129, 108, 135, 13, 28, 3, 189, 24, 251, 196, 180, 51, 27, 227, 210, 76, 49, 38, 165, 128, 110, 14, 159, 57, 201, 123, 187, 221, 170, 185, 114, 55, 205, 123, 207, 166, 190, 165, 4, 15, 104, 144, 91, 71, 10, 197, 194, 40, 2, 0, 0]");
 
-    insta::assert_compact_debug_snapshot!(bytes, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 165, 81, 65, 10, 0, 32, 8, 115, 106, 255, 232, 255, 175, 172, 131, 70, 129, 7, 211, 129, 108, 135, 13, 28, 3, 189, 24, 251, 196, 180, 51, 27, 227, 210, 76, 49, 38, 165, 128, 110, 14, 159, 57, 201, 123, 187, 221, 170, 185, 114, 55, 205, 123, 207, 166, 190, 165, 4, 15, 104, 144, 91, 71, 10, 197, 194, 40, 2, 0, 0]");
+    let bytes_msgpack =
+        Program::serialize_program_with_format(&program, SerializationFormat::Msgpack);
+    insta::assert_compact_debug_snapshot!(bytes_msgpack, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 205, 147, 75, 78, 195, 48, 16, 134, 147, 180, 220, 131, 235, 176, 64, 28, 97, 228, 56, 3, 178, 136, 31, 204, 216, 133, 46, 219, 44, 216, 38, 237, 5, 16, 207, 166, 82, 133, 0, 33, 46, 192, 193, 48, 137, 120, 172, 104, 23, 168, 170, 55, 182, 199, 163, 255, 255, 52, 250, 157, 77, 219, 227, 96, 164, 87, 214, 112, 115, 185, 250, 58, 131, 17, 26, 175, 94, 101, 32, 66, 227, 225, 92, 121, 131, 204, 160, 76, 129, 23, 123, 15, 214, 73, 91, 32, 207, 39, 203, 67, 212, 150, 198, 7, 70, 249, 106, 145, 151, 86, 158, 130, 42, 146, 91, 21, 239, 179, 52, 91, 246, 21, 63, 118, 120, 223, 55, 78, 22, 253, 126, 228, 166, 63, 237, 215, 214, 85, 173, 117, 72, 226, 211, 185, 106, 117, 40, 193, 35, 105, 174, 95, 74, 101, 80, 16, 72, 171, 115, 101, 186, 103, 174, 111, 206, 64, 190, 239, 39, 127, 175, 244, 174, 67, 253, 47, 177, 145, 40, 3, 174, 19, 107, 102, 235, 149, 6, 27, 25, 38, 91, 155, 83, 178, 163, 115, 26, 110, 70, 255, 236, 72, 141, 132, 71, 112, 130, 98, 96, 163, 39, 207, 211, 108, 240, 228, 66, 94, 42, 249, 171, 90, 175, 8, 125, 32, 3, 29, 33, 55, 195, 71, 193, 140, 228, 65, 199, 88, 139, 19, 228, 250, 45, 38, 63, 194, 121, 18, 145, 184, 128, 239, 79, 81, 127, 0, 205, 96, 137, 59, 34, 3, 0, 0]");
 
-    let program_de = Program::deserialize_program(&bytes).unwrap();
-    assert_eq!(program_de, program);
+    let bytes_default = Program::serialize_program(&program);
+    insta::assert_compact_debug_snapshot!(bytes_default, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 142, 187, 9, 128, 64, 16, 68, 119, 111, 207, 62, 108, 199, 64, 172, 194, 192, 192, 15, 98, 98, 120, 29, 236, 39, 48, 53, 18, 177, 14, 11, 51, 184, 220, 59, 193, 73, 134, 129, 7, 243, 72, 101, 219, 11, 11, 87, 221, 246, 227, 188, 86, 67, 183, 24, 40, 186, 35, 238, 112, 198, 110, 38, 5, 51, 230, 187, 132, 247, 96, 38, 36, 154, 166, 40, 137, 192, 103, 63, 248, 209, 207, 103, 188, 161, 35, 22, 207, 252, 0, 167, 131, 176, 229, 104, 1, 0, 0]");
+
+    assert_deserialization(&program, [bytes_legacy, bytes_msgpack, bytes_default]);
 }
 
 #[test]
@@ -307,10 +347,16 @@ fn nested_acir_call_circuit() {
     let program =
         Program { functions: vec![main, nested_call, inner_call], unconstrained_functions: vec![] };
 
-    let bytes = Program::serialize_program(&program);
+    let bytes_legacy =
+        Program::serialize_program_with_format(&program, SerializationFormat::BincodeLegacy);
+    insta::assert_compact_debug_snapshot!(bytes_legacy, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 181, 81, 59, 10, 131, 64, 16, 157, 15, 222, 35, 101, 210, 37, 228, 8, 33, 144, 42, 88, 218, 216, 121, 0, 177, 179, 244, 8, 226, 5, 60, 133, 232, 113, 236, 44, 109, 236, 85, 88, 101, 92, 23, 119, 45, 124, 240, 96, 216, 125, 204, 188, 55, 195, 176, 5, 43, 206, 240, 38, 226, 68, 18, 255, 168, 8, 203, 187, 77, 196, 218, 128, 85, 120, 3, 39, 32, 9, 237, 51, 250, 39, 237, 171, 124, 212, 254, 183, 202, 178, 32, 188, 191, 187, 95, 218, 196, 249, 167, 29, 138, 94, 13, 115, 236, 187, 26, 148, 53, 30, 232, 25, 182, 33, 23, 156, 205, 35, 181, 182, 60, 228, 222, 151, 60, 165, 39, 225, 107, 119, 8, 253, 74, 122, 205, 96, 118, 108, 90, 204, 149, 193, 209, 189, 175, 53, 147, 9, 35, 191, 119, 205, 214, 247, 2, 0, 0]");
+
+    let bytes_msgpack =
+        Program::serialize_program_with_format(&program, SerializationFormat::Msgpack);
+    insta::assert_compact_debug_snapshot!(bytes_msgpack,  @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 197, 211, 205, 74, 3, 49, 16, 0, 224, 221, 236, 139, 120, 212, 155, 226, 19, 72, 17, 60, 137, 71, 17, 36, 164, 217, 81, 2, 187, 217, 56, 73, 170, 30, 171, 130, 215, 253, 121, 129, 162, 98, 89, 161, 136, 138, 127, 55, 15, 190, 72, 111, 30, 189, 120, 55, 22, 86, 43, 45, 117, 45, 130, 57, 133, 97, 8, 51, 223, 76, 200, 65, 185, 101, 37, 55, 34, 145, 186, 56, 238, 85, 119, 42, 89, 12, 157, 91, 110, 17, 65, 26, 186, 43, 140, 4, 173, 169, 144, 33, 236, 5, 221, 68, 241, 36, 4, 93, 180, 207, 26, 44, 138, 142, 78, 68, 232, 159, 11, 169, 172, 209, 185, 231, 119, 19, 107, 62, 174, 25, 41, 21, 66, 40, 56, 51, 240, 52, 57, 51, 24, 206, 188, 88, 210, 26, 208, 108, 0, 38, 135, 101, 108, 35, 106, 0, 99, 157, 222, 68, 66, 2, 67, 202, 147, 184, 41, 36, 27, 20, 156, 231, 207, 51, 222, 228, 227, 19, 151, 51, 31, 174, 98, 127, 161, 51, 247, 176, 182, 124, 215, 110, 175, 111, 206, 46, 190, 172, 236, 63, 170, 172, 209, 127, 43, 94, 93, 82, 112, 186, 67, 249, 143, 79, 121, 215, 10, 69, 203, 213, 72, 21, 67, 199, 227, 234, 210, 153, 119, 165, 108, 51, 18, 124, 56, 230, 247, 16, 140, 69, 73, 91, 44, 178, 160, 211, 75, 54, 232, 136, 198, 142, 144, 109, 187, 192, 47, 157, 243, 191, 54, 241, 106, 152, 144, 90, 38, 228, 107, 176, 164, 26, 44, 25, 63, 216, 49, 122, 110, 7, 70, 249, 210, 239, 122, 89, 48, 37, 159, 95, 241, 101, 255, 193, 231, 79, 189, 82, 181, 80, 188, 17, 148, 123, 71, 226, 234, 55, 200, 92, 83, 33, 253, 252, 212, 233, 59, 226, 130, 57, 211, 226, 3, 0, 0]");
 
-    insta::assert_compact_debug_snapshot!(bytes, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 181, 81, 59, 10, 131, 64, 16, 157, 15, 222, 35, 101, 210, 37, 228, 8, 33, 144, 42, 88, 218, 216, 121, 0, 177, 179, 244, 8, 226, 5, 60, 133, 232, 113, 236, 44, 109, 236, 85, 88, 101, 92, 23, 119, 45, 124, 240, 96, 216, 125, 204, 188, 55, 195, 176, 5, 43, 206, 240, 38, 226, 68, 18, 255, 168, 8, 203, 187, 77, 196, 218, 128, 85, 120, 3, 39, 32, 9, 237, 51, 250, 39, 237, 171, 124, 212, 254, 183, 202, 178, 32, 188, 191, 187, 95, 218, 196, 249, 167, 29, 138, 94, 13, 115, 236, 187, 26, 148, 53, 30, 232, 25, 182, 33, 23, 156, 205, 35, 181, 182, 60, 228, 222, 151, 60, 165, 39, 225, 107, 119, 8, 253, 74, 122, 205, 96, 118, 108, 90, 204, 149, 193, 209, 189, 175, 53, 147, 9, 35, 191, 119, 205, 214, 247, 2, 0, 0]");
+    let bytes_default = Program::serialize_program(&program);
+    insta::assert_compact_debug_snapshot!(bytes_default, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 181, 144, 161, 10, 2, 65, 20, 69, 223, 123, 243, 35, 70, 109, 138, 95, 32, 139, 96, 18, 163, 8, 6, 193, 109, 11, 202, 172, 197, 56, 127, 240, 222, 27, 193, 186, 193, 228, 7, 136, 182, 13, 254, 200, 54, 163, 197, 238, 40, 6, 147, 227, 134, 189, 237, 194, 229, 114, 56, 70, 253, 190, 48, 222, 29, 146, 69, 150, 237, 80, 1, 133, 202, 239, 102, 74, 119, 28, 228, 121, 106, 55, 179, 212, 174, 60, 171, 94, 91, 240, 59, 72, 97, 211, 93, 142, 109, 213, 43, 58, 231, 201, 240, 228, 220, 116, 222, 238, 223, 70, 219, 203, 90, 146, 234, 225, 239, 97, 100, 162, 55, 32, 32, 200, 28, 240, 180, 62, 2, 252, 129, 64, 209, 27, 250, 152, 32, 165, 151, 137, 224, 131, 197, 4, 34, 148, 102, 136, 48, 46, 229, 205, 0, 204, 79, 117, 204, 11, 148, 185, 1, 0, 0]");
 
-    let program_de = Program::deserialize_program(&bytes).unwrap();
-    assert_eq!(program_de, program);
+    assert_deserialization(&program, [bytes_legacy, bytes_msgpack, bytes_default]);
 }
diff --git a/acvm-repo/acvm_js/test/shared/addition.ts b/acvm-repo/acvm_js/test/shared/addition.ts
index cceb1c1fd61..1fc9ae27174 100644
--- a/acvm-repo/acvm_js/test/shared/addition.ts
+++ b/acvm-repo/acvm_js/test/shared/addition.ts
@@ -2,11 +2,11 @@ import { WitnessMap } from '@noir-lang/acvm_js';
 
 // See `addition_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, 149, 143, 49, 10, 128, 48, 12, 69, 127, 170, 7, 113, 212, 77, 241, 8, 34, 56, 137,
-  163, 139, 155, 7, 16, 55, 199, 30, 65, 188, 128, 167, 16, 61, 78, 55, 71, 23, 119, 29, 90, 140, 116, 105, 31, 132, 36,
-  240, 73, 254, 39, 252, 9, 223, 34, 216, 4, 186, 71, 112, 130, 200, 67, 43, 152, 54, 237, 235, 81, 101, 107, 178, 55,
-  229, 38, 101, 219, 197, 249, 89, 77, 199, 48, 23, 234, 94, 46, 237, 195, 241, 46, 132, 121, 192, 102, 179, 3, 95, 38,
-  206, 3, 2, 103, 244, 195, 16, 1, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 141, 204, 59, 14, 64, 48, 0, 128, 225, 62, 28, 196, 200, 70, 156, 64, 68, 98, 18,
+  163, 72, 108, 58, 147, 214, 98, 236, 13, 250, 24, 172, 157, 29, 64, 216, 93, 164, 155, 209, 98, 215, 19, 224, 159,
+  191, 252, 88, 201, 217, 120, 146, 47, 41, 99, 132, 142, 13, 161, 189, 22, 90, 29, 62, 120, 15, 194, 31, 6, 57, 19,
+  117, 37, 181, 177, 9, 183, 42, 95, 57, 175, 219, 32, 57, 139, 105, 31, 100, 102, 111, 125, 57, 132, 63, 55, 64, 65,
+  36, 36, 22, 226, 1, 27, 166, 206, 10, 172, 0, 0, 0,
 ]);
 
 export const initialWitnessMap: WitnessMap = new Map([
diff --git a/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts b/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
index 762704b80d3..56df50e4778 100644
--- a/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
+++ b/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
@@ -2,14 +2,18 @@ import { WitnessMap } from '@noir-lang/acvm_js';
 
 // See `complex_brillig_foreign_call` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 181, 84, 219, 10, 194, 48, 12, 109, 154, 109, 22, 244, 201, 47, 24, 232, 127, 137,
-  12, 223, 42, 250, 232, 231, 187, 66, 50, 178, 88, 181, 233, 182, 64, 73, 27, 206, 201, 101, 39, 12, 220, 220, 194,
-  120, 128, 238, 13, 121, 79, 62, 197, 81, 225, 25, 219, 187, 34, 3, 40, 199, 86, 215, 240, 110, 251, 26, 232, 236, 53,
-  146, 161, 177, 142, 225, 123, 89, 230, 54, 245, 207, 61, 75, 253, 211, 110, 180, 227, 233, 232, 189, 35, 31, 52, 193,
-  187, 207, 165, 153, 117, 66, 254, 64, 126, 120, 220, 159, 241, 246, 186, 12, 215, 24, 247, 50, 169, 226, 24, 6, 192,
-  160, 106, 25, 249, 211, 144, 223, 240, 156, 119, 97, 159, 61, 243, 177, 142, 15, 204, 111, 234, 248, 216, 9, 222, 20,
-  20, 119, 206, 155, 116, 97, 193, 73, 47, 204, 80, 53, 61, 217, 73, 189, 207, 10, 7, 5, 57, 216, 228, 127, 233, 23, 30,
-  50, 248, 127, 156, 181, 164, 172, 92, 185, 246, 152, 9, 114, 174, 55, 111, 172, 240, 81, 180, 5, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 82, 65, 78, 195, 48, 16, 140, 235, 22, 250, 140, 72, 240, 2, 120, 65, 9, 170,
+  224, 192, 169, 226, 140, 172, 196, 138, 44, 185, 113, 228, 248, 64, 142, 254, 65, 108, 131, 56, 112, 65, 130, 180, 66,
+  45, 127, 224, 192, 195, 104, 16, 78, 213, 22, 154, 88, 141, 79, 222, 181, 103, 118, 118, 119, 160, 86, 79, 47, 67, 37,
+  23, 23, 156, 80, 74, 226, 0, 81, 250, 224, 105, 89, 142, 56, 71, 185, 49, 133, 210, 95, 190, 183, 255, 0, 208, 248,
+  197, 107, 71, 212, 235, 138, 8, 54, 19, 201, 217, 132, 36, 49, 197, 166, 48, 109, 90, 108, 163, 190, 27, 97, 198, 14,
+  191, 63, 56, 170, 68, 78, 83, 138, 143, 237, 101, 248, 105, 64, 15, 22, 197, 106, 10, 203, 144, 85, 153, 251, 187,
+  112, 181, 179, 103, 89, 6, 44, 201, 132, 145, 179, 75, 194, 113, 40, 60, 57, 191, 78, 4, 142, 49, 127, 189, 61, 63,
+  107, 172, 10, 183, 241, 192, 13, 239, 201, 101, 101, 157, 8, 9, 20, 176, 52, 175, 105, 252, 181, 158, 154, 248, 48,
+  165, 254, 54, 30, 186, 225, 119, 234, 247, 93, 39, 245, 119, 167, 96, 173, 167, 38, 94, 140, 25, 199, 36, 78, 42, 192,
+  227, 252, 119, 95, 70, 190, 95, 97, 148, 254, 236, 88, 215, 67, 128, 242, 227, 6, 79, 25, 207, 71, 81, 196, 113, 150,
+  217, 135, 147, 127, 242, 167, 214, 38, 90, 89, 111, 148, 99, 130, 105, 4, 55, 195, 205, 72, 59, 213, 6, 186, 101, 141,
+  142, 55, 234, 232, 189, 129, 124, 155, 8, 150, 42, 189, 235, 181, 111, 81, 157, 181, 15, 223, 4, 0, 0,
 ]);
 export const initialWitnessMap: WitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],
diff --git a/acvm-repo/acvm_js/test/shared/foreign_call.ts b/acvm-repo/acvm_js/test/shared/foreign_call.ts
index 5d8cc95719e..d2eba854296 100644
--- a/acvm-repo/acvm_js/test/shared/foreign_call.ts
+++ b/acvm-repo/acvm_js/test/shared/foreign_call.ts
@@ -2,11 +2,14 @@ import { WitnessMap } from '@noir-lang/acvm_js';
 
 // See `simple_brillig_foreign_call` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 149, 81, 237, 10, 128, 32, 12, 116, 246, 193, 160, 127, 61, 65, 111, 22, 17, 253,
-  8, 164, 31, 17, 61, 127, 69, 91, 204, 156, 48, 7, 58, 61, 239, 240, 142, 129, 139, 11, 239, 5, 116, 174, 169, 131, 75,
-  139, 177, 193, 153, 10, 192, 206, 141, 254, 243, 223, 70, 15, 222, 32, 236, 168, 175, 219, 185, 236, 199, 56, 79, 33,
-  52, 4, 225, 143, 250, 244, 170, 192, 27, 74, 95, 229, 122, 104, 21, 80, 70, 146, 17, 152, 251, 198, 208, 166, 32, 21,
-  185, 123, 14, 239, 21, 156, 157, 92, 163, 94, 232, 115, 22, 2, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 149, 143, 49, 14, 130, 48, 20, 134, 41, 46, 30, 195, 51, 232, 9, 20, 99, 226, 224,
+  68, 156, 13, 129, 23, 210, 164, 180, 164, 52, 38, 140, 189, 1, 45, 18, 87, 19, 5, 7, 244, 14, 14, 30, 76, 8, 177, 36,
+  14, 162, 111, 126, 223, 247, 255, 255, 72, 171, 227, 105, 172, 100, 189, 224, 152, 16, 28, 58, 30, 33, 7, 75, 201,
+  202, 197, 52, 36, 144, 103, 74, 63, 39, 214, 247, 67, 104, 240, 165, 51, 70, 49, 1, 251, 161, 145, 157, 101, 141, 183,
+  198, 116, 15, 92, 236, 252, 38, 178, 144, 165, 195, 104, 34, 114, 89, 45, 49, 7, 95, 32, 121, 93, 83, 1, 33, 240, 243,
+  118, 54, 29, 246, 127, 242, 246, 127, 60, 146, 183, 118, 121, 224, 9, 207, 97, 113, 106, 52, 86, 239, 51, 197, 234,
+  21, 227, 128, 67, 218, 2, 69, 213, 141, 80, 242, 190, 129, 136, 241, 116, 30, 4, 28, 146, 196, 240, 102, 119, 185,
+  194, 64, 130, 95, 255, 228, 197, 21, 44, 86, 186, 79, 125, 247, 120, 1, 82, 78, 27, 216, 177, 1, 0, 0,
 ]);
 export const initialWitnessMap: WitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000005'],
diff --git a/acvm-repo/acvm_js/test/shared/memory_op.ts b/acvm-repo/acvm_js/test/shared/memory_op.ts
index 26d9fa1a3d4..04eb8bcdff4 100644
--- a/acvm-repo/acvm_js/test/shared/memory_op.ts
+++ b/acvm-repo/acvm_js/test/shared/memory_op.ts
@@ -1,8 +1,10 @@
 // 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, 165, 81, 65, 10, 0, 32, 8, 115, 106, 255, 232, 255, 175, 172, 131, 70, 129, 7, 211,
-  129, 108, 135, 13, 28, 3, 189, 24, 251, 196, 180, 51, 27, 227, 210, 76, 49, 38, 165, 128, 110, 14, 159, 57, 201, 123,
-  187, 221, 170, 185, 114, 55, 205, 123, 207, 166, 190, 165, 4, 15, 104, 144, 91, 71, 10, 197, 194, 40, 2, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 142, 187, 9, 128, 64, 16, 68, 119, 111, 207, 62, 108, 199, 64, 172, 194, 192,
+  192, 15, 98, 98, 120, 29, 236, 39, 48, 53, 18, 177, 14, 11, 51, 184, 220, 59, 193, 73, 134, 129, 7, 243, 72, 101, 219,
+  11, 11, 87, 221, 246, 227, 188, 86, 67, 183, 24, 40, 186, 35, 238, 112, 198, 110, 38, 5, 51, 230, 187, 132, 247, 96,
+  38, 36, 154, 166, 40, 137, 192, 103, 63, 248, 209, 207, 103, 188, 161, 35, 22, 207, 252, 0, 167, 131, 176, 229, 104,
+  1, 0, 0,
 ]);
 
 export const initialWitnessMap = new Map([
diff --git a/acvm-repo/acvm_js/test/shared/multi_scalar_mul.ts b/acvm-repo/acvm_js/test/shared/multi_scalar_mul.ts
index 42ee70b82d8..6c415411f94 100644
--- a/acvm-repo/acvm_js/test/shared/multi_scalar_mul.ts
+++ b/acvm-repo/acvm_js/test/shared/multi_scalar_mul.ts
@@ -1,8 +1,10 @@
 // See `multi_scalar_mul_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, 93, 141, 11, 10, 0, 32, 12, 66, 87, 235, 127, 255, 3, 183, 224, 5, 214, 64, 84, 68,
-  151, 236, 189, 21, 72, 232, 195, 35, 224, 226, 47, 50, 236, 232, 155, 23, 184, 194, 45, 208, 217, 153, 120, 147, 13,
-  167, 83, 37, 51, 249, 169, 221, 255, 54, 129, 45, 40, 232, 188, 0, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 61, 198, 171, 10, 128, 48, 20, 0, 80, 116, 190, 63, 75, 193, 102, 50, 152, 199, 48,
+  12, 47, 19, 220, 6, 214, 253, 193, 30, 162, 213, 102, 19, 63, 81, 45, 183, 29, 226, 221, 113, 86, 206, 60, 53, 80, 54,
+  213, 243, 218, 106, 193, 26, 10, 96, 238, 78, 131, 226, 61, 163, 64, 151, 143, 91, 48, 215, 192, 149, 24, 165, 140,
+  80, 49, 138, 120, 100, 130, 74, 81, 89, 200, 139, 114, 143, 98, 146, 164, 153, 253, 109, 237, 11, 181, 107, 246, 16,
+  122, 0, 0, 0,
 ]);
 export const initialWitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],
diff --git a/acvm-repo/acvm_js/test/shared/nested_acir_call.ts b/acvm-repo/acvm_js/test/shared/nested_acir_call.ts
index 560ead8e2c5..787ce50ef9f 100644
--- a/acvm-repo/acvm_js/test/shared/nested_acir_call.ts
+++ b/acvm-repo/acvm_js/test/shared/nested_acir_call.ts
@@ -2,13 +2,13 @@ import { WitnessMap, StackItem, WitnessStack } from '@noir-lang/acvm_js';
 
 // See `nested_acir_call_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, 181, 81, 59, 10, 131, 64, 16, 157, 15, 222, 35, 101, 210, 37, 228, 8, 33, 144, 42,
-  88, 218, 216, 121, 0, 177, 179, 244, 8, 226, 5, 60, 133, 232, 113, 236, 44, 109, 236, 85, 88, 101, 92, 23, 119, 45,
-  124, 240, 96, 216, 125, 204, 188, 55, 195, 176, 5, 43, 206, 240, 38, 226, 68, 18, 255, 168, 8, 203, 187, 77, 196, 218,
-  128, 85, 120, 3, 39, 32, 9, 237, 51, 250, 39, 237, 171, 124, 212, 254, 183, 202, 178, 32, 188, 191, 187, 95, 218, 196,
-  249, 167, 29, 138, 94, 13, 115, 236, 187, 26, 148, 53, 30, 232, 25, 182, 33, 23, 156, 205, 35, 181, 182, 60, 228, 222,
-  151, 60, 165, 39, 225, 107, 119, 8, 253, 74, 122, 205, 96, 118, 108, 90, 204, 149, 193, 209, 189, 175, 53, 147, 9, 35,
-  191, 119, 205, 214, 247, 2, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 181, 144, 161, 10, 2, 65, 20, 69, 223, 123, 243, 35, 70, 109, 138, 95, 32, 139, 96,
+  18, 163, 8, 6, 193, 109, 11, 202, 172, 197, 56, 127, 240, 222, 27, 193, 186, 193, 228, 7, 136, 182, 13, 254, 200, 54,
+  163, 197, 238, 40, 6, 147, 227, 134, 189, 237, 194, 229, 114, 56, 70, 253, 190, 48, 222, 29, 146, 69, 150, 237, 80, 1,
+  133, 202, 239, 102, 74, 119, 28, 228, 121, 106, 55, 179, 212, 174, 60, 171, 94, 91, 240, 59, 72, 97, 211, 93, 142,
+  109, 213, 43, 58, 231, 201, 240, 228, 220, 116, 222, 238, 223, 70, 219, 203, 90, 146, 234, 225, 239, 97, 100, 162, 55,
+  32, 32, 200, 28, 240, 180, 62, 2, 252, 129, 64, 209, 27, 250, 152, 32, 165, 151, 137, 224, 131, 197, 4, 34, 148, 102,
+  136, 48, 46, 229, 205, 0, 204, 79, 117, 204, 11, 148, 185, 1, 0, 0,
 ]);
 
 export const initialWitnessMap: WitnessMap = new Map([
@@ -53,7 +53,7 @@ export const expectedWitnessStack: WitnessStack = [
 ];
 
 export const expectedCompressedWitnessStack = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 2, 255, 237, 144, 49, 10, 0, 32, 12, 3, 99, 85, 16, 95, 225, 255, 95, 233, 160, 142, 66,
-  111, 44, 244, 160, 219, 209, 132, 116, 29, 236, 222, 99, 201, 197, 44, 208, 109, 60, 99, 144, 12, 3, 110, 133, 127,
-  115, 159, 191, 171, 192, 221, 55, 110, 127, 96, 15, 4, 3, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 2, 255, 221, 143, 193, 13, 0, 32, 8, 3, 11, 124, 140, 83, 56, 171, 113, 1, 73, 220, 200,
+  193, 220, 192, 242, 36, 244, 125, 185, 92, 109, 31, 215, 137, 59, 240, 95, 23, 142, 184, 44, 46, 106, 1, 145, 114,
+  196, 2, 57, 85, 127, 33, 85, 206, 3, 228, 187, 103, 149, 66, 2, 0, 0,
 ]);
diff --git a/acvm-repo/acvm_js/test/shared/witness_compression.ts b/acvm-repo/acvm_js/test/shared/witness_compression.ts
index 441be1ba872..732cc3fe45f 100644
--- a/acvm-repo/acvm_js/test/shared/witness_compression.ts
+++ b/acvm-repo/acvm_js/test/shared/witness_compression.ts
@@ -9,8 +9,9 @@
 // after recompiling Noir to print the witness byte array to be written to file after execution
 
 export const expectedCompressedWitnessMap = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 2, 255, 149, 204, 185, 17, 0, 0, 8, 2, 65, 240, 171, 195, 254, 171, 52, 212, 16, 47, 34,
-  216, 129, 216, 234, 236, 134, 20, 169, 91, 179, 199, 175, 63, 108, 232, 22, 169, 91, 31, 143, 90, 63, 92, 28, 1, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 2, 255, 133, 204, 65, 17, 0, 32, 12, 196, 192, 107, 15, 124, 160, 150, 127, 209, 132, 176,
+  58, 104, 242, 222, 137, 171, 158, 174, 254, 209, 92, 4, 146, 76, 190, 152, 201, 66, 162, 141, 196, 13, 57, 211, 99,
+  86, 216, 0, 0, 0,
 ]);
 
 export const expectedWitnessMap = new Map([
diff --git a/examples/prove_and_verify/prove_and_verify.sh b/examples/prove_and_verify/prove_and_verify.sh
index 12e779c4d98..521ec1319fa 100755
--- a/examples/prove_and_verify/prove_and_verify.sh
+++ b/examples/prove_and_verify/prove_and_verify.sh
@@ -3,7 +3,7 @@ set -eu
 
 BACKEND=${BACKEND:-bb}
 
-nargo execute --pedantic-solving witness
+nargo execute --force --pedantic-solving witness
 
 $BACKEND write_vk -b ./target/hello_world.json -o ./target
 $BACKEND prove -b ./target/hello_world.json -w ./target/witness.gz -o ./proofs
diff --git a/test_programs/gates_report.sh b/test_programs/gates_report.sh
index 8a6cc70a8cc..689592583a4 100755
--- a/test_programs/gates_report.sh
+++ b/test_programs/gates_report.sh
@@ -7,13 +7,12 @@ BACKEND=${BACKEND:-bb}
 excluded_dirs=(
     "workspace"
     "workspace_default_member"
+    # UltraCircuitBuilder (standalone Noir application) does not support CallData/ReturnData block constraints. Use MegaCircuitBuilder (Aztec app) or fall back to RAM and ROM operations.
     "databus"
     "databus_composite_calldata"
     "databus_two_calldata"
     "databus_two_calldata_simple"
-    "double_verify_honk_proof"
-    "verify_honk_proof"
-    "verify_rollup_honk_proof"
+    # For circuits which use #[fold]: circuit_buf_to_acir_format: expected single function in ACIR program
     "fold_2_to_17"
     "fold_after_inlined_calls"
     "fold_basic"
@@ -59,5 +58,3 @@ for pathname in $test_dirs; do
 done
 
 echo "]}" >> gates_report.json
-
-