diff --git a/.gitignore b/.gitignore index 3987d09d2ca..601fe73677d 100644 --- a/.gitignore +++ b/.gitignore @@ -63,3 +63,6 @@ codegen mutants.out mutants.out.old + +# Artifacts created by `noir/bootstrap.sh build_packages` in aztec-packages +**/package.tgz diff --git a/Cargo.lock b/Cargo.lock index a69d344f55a..2131193a6fb 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -18,13 +18,16 @@ dependencies = [ "insta", "noir_protobuf", "num-bigint", + "num_enum", "pprof", "proptest", "proptest-derive", "prost", "prost-build", "protoc-prebuilt", + "regex", "rmp-serde", + "rmpv", "serde", "serde-big-array", "serde-generate", @@ -3915,6 +3918,27 @@ dependencies = [ "autocfg", ] +[[package]] +name = "num_enum" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e613fc340b2220f734a8595782c551f1250e969d87d3be1ae0579e8d4065179" +dependencies = [ + "num_enum_derive", +] + +[[package]] +name = "num_enum_derive" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af1844ef2428cc3e1cb900be36181049ef3d3193c63e43026cfe202983b27a56" +dependencies = [ + "proc-macro-crate", + "proc-macro2", + "quote", + "syn 2.0.101", +] + [[package]] name = "numtoa" version = "0.1.0" @@ -4786,6 +4810,16 @@ dependencies = [ "serde", ] +[[package]] +name = "rmpv" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "58450723cd9ee93273ce44a20b6ec4efe17f8ed2e3631474387bfdecf18bb2a9" +dependencies = [ + "num-traits", + "rmp", +] + [[package]] name = "route-recognizer" version = "0.3.1" diff --git a/Cargo.toml b/Cargo.toml index ebda8cc45d3..dd77b000f90 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -153,6 +153,7 @@ protoc-prebuilt = "0.3" # MessagePack rmp = "0.8.14" rmp-serde = "1.3.0" +rmpv = "1.3.0" arbitrary = "1.4.1" arbtest = "0.3.2" @@ -176,6 +177,7 @@ lazy_static = "1.4" libfuzzer-sys = "0.4" num-bigint = "0.4" num-traits = "0.2" +num_enum = "0.7.3" num-integer = "0.1" regex = "1.11" similar = "2.7.0" diff --git a/acvm-repo/acir/Cargo.toml b/acvm-repo/acir/Cargo.toml index e8e6e6232f9..2dd8c502bad 100644 --- a/acvm-repo/acir/Cargo.toml +++ b/acvm-repo/acir/Cargo.toml @@ -26,6 +26,7 @@ thiserror.workspace = true flate2.workspace = true bincode.workspace = true base64.workspace = true +num_enum.workspace = true prost.workspace = true rmp-serde.workspace = true serde-big-array = "0.5.1" @@ -47,6 +48,8 @@ fxhash.workspace = true criterion.workspace = true pprof.workspace = true num-bigint.workspace = true +regex.workspace = true +rmpv.workspace = true insta.workspace = true acir = { path = ".", features = ["arb"] } # Self to turn on `arb`. diff --git a/acvm-repo/acir/codegen/acir.cpp b/acvm-repo/acir/codegen/acir.cpp index 2ae15f9f5a3..ffb51576a66 100644 --- a/acvm-repo/acir/codegen/acir.cpp +++ b/acvm-repo/acir/codegen/acir.cpp @@ -1,9 +1,57 @@ #pragma once #include "serde.hpp" +#include "msgpack.hpp" #include "bincode.hpp" -namespace Program { +namespace Acir { + struct Helpers { + static std::map make_kvmap( + msgpack::object const& o, + std::string const& name + ) { + if(o.type != msgpack::type::MAP) { + std::cerr << o << std::endl; + throw_or_abort("expected MAP for " + name); + } + std::map kvmap; + for (uint32_t i = 0; i < o.via.map.size; ++i) { + if (o.via.map.ptr[i].key.type != msgpack::type::STR) { + std::cerr << o << std::endl; + throw_or_abort("expected STR for keys of " + name); + } + kvmap.emplace( + std::string( + o.via.map.ptr[i].key.via.str.ptr, + o.via.map.ptr[i].key.via.str.size), + &o.via.map.ptr[i].val); + } + return kvmap; + } + template + static void conv_fld_from_kvmap( + std::map const& kvmap, + std::string const& struct_name, + std::string const& field_name, + T& field, + bool is_optional + ) { + auto it = kvmap.find(field_name); + if (it != kvmap.end()) { + try { + it->second->convert(field); + } catch (const msgpack::type_error&) { + std::cerr << *it->second << std::endl; + throw_or_abort("error converting into field " + struct_name + "::" + field_name); + } + } else if (!is_optional) { + throw_or_abort("missing field: " + struct_name + "::" + field_name); + } + } + }; + } + +namespace Acir { struct BinaryFieldOp { @@ -11,48 +59,72 @@ namespace Program { friend bool operator==(const Add&, const Add&); std::vector bincodeSerialize() const; static Add bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct Sub { friend bool operator==(const Sub&, const Sub&); std::vector bincodeSerialize() const; static Sub bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct Mul { friend bool operator==(const Mul&, const Mul&); std::vector bincodeSerialize() const; static Mul bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct Div { friend bool operator==(const Div&, const Div&); std::vector bincodeSerialize() const; static Div bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct IntegerDiv { friend bool operator==(const IntegerDiv&, const IntegerDiv&); std::vector bincodeSerialize() const; static IntegerDiv bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct Equals { friend bool operator==(const Equals&, const Equals&); std::vector bincodeSerialize() const; static Equals bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct LessThan { friend bool operator==(const LessThan&, const LessThan&); std::vector bincodeSerialize() const; static LessThan bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct LessThanEquals { friend bool operator==(const LessThanEquals&, const LessThanEquals&); std::vector bincodeSerialize() const; static LessThanEquals bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; std::variant value; @@ -60,6 +132,115 @@ namespace Program { friend bool operator==(const BinaryFieldOp&, const BinaryFieldOp&); std::vector bincodeSerialize() const; static BinaryFieldOp bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + std::string tag; + bool is_unit; + switch (value.index()) { + + case 0: + tag = "Add"; + is_unit = true; + break; + case 1: + tag = "Sub"; + is_unit = true; + break; + case 2: + tag = "Mul"; + is_unit = true; + break; + case 3: + tag = "Div"; + is_unit = true; + break; + case 4: + tag = "IntegerDiv"; + is_unit = true; + break; + case 5: + tag = "Equals"; + is_unit = true; + break; + case 6: + tag = "LessThan"; + is_unit = true; + break; + case 7: + tag = "LessThanEquals"; + is_unit = true; + break; + default: + throw_or_abort("unknown enum 'BinaryFieldOp' variant index: " + std::to_string(value.index())); + } + if (is_unit) { + packer.pack(tag); + } else { + std::visit([&packer, tag](const auto& arg) { + std::map data; + data[tag] = msgpack::object(arg); + packer.pack(data); + }, value); + } + } + + void msgpack_unpack(msgpack::object const& o) { + + if (o.type != msgpack::type::object_type::MAP && o.type != msgpack::type::object_type::STR) { + std::cerr << o << std::endl; + throw_or_abort("expected MAP or STR for enum 'BinaryFieldOp'; got type " + std::to_string(o.type)); + } + if (o.type == msgpack::type::object_type::MAP && o.via.map.size != 1) { + throw_or_abort("expected 1 entry for enum 'BinaryFieldOp'; got " + std::to_string(o.via.map.size)); + } + std::string tag; + try { + if (o.type == msgpack::type::object_type::MAP) { + o.via.map.ptr[0].key.convert(tag); + } else { + o.convert(tag); + } + } catch(const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting tag to string for enum 'BinaryFieldOp'"); + } + if (tag == "Add") { + Add v; + value = v; + } + else if (tag == "Sub") { + Sub v; + value = v; + } + else if (tag == "Mul") { + Mul v; + value = v; + } + else if (tag == "Div") { + Div v; + value = v; + } + else if (tag == "IntegerDiv") { + IntegerDiv v; + value = v; + } + else if (tag == "Equals") { + Equals v; + value = v; + } + else if (tag == "LessThan") { + LessThan v; + value = v; + } + else if (tag == "LessThanEquals") { + LessThanEquals v; + value = v; + } + else { + std::cerr << o << std::endl; + throw_or_abort("unknown 'BinaryFieldOp' enum variant: " + tag); + } + } }; struct BinaryIntOp { @@ -68,72 +249,108 @@ namespace Program { friend bool operator==(const Add&, const Add&); std::vector bincodeSerialize() const; static Add bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct Sub { friend bool operator==(const Sub&, const Sub&); std::vector bincodeSerialize() const; static Sub bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct Mul { friend bool operator==(const Mul&, const Mul&); std::vector bincodeSerialize() const; static Mul bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct Div { friend bool operator==(const Div&, const Div&); std::vector bincodeSerialize() const; static Div bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct Equals { friend bool operator==(const Equals&, const Equals&); std::vector bincodeSerialize() const; static Equals bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct LessThan { friend bool operator==(const LessThan&, const LessThan&); std::vector bincodeSerialize() const; static LessThan bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct LessThanEquals { friend bool operator==(const LessThanEquals&, const LessThanEquals&); std::vector bincodeSerialize() const; static LessThanEquals bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct And { friend bool operator==(const And&, const And&); std::vector bincodeSerialize() const; static And bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct Or { friend bool operator==(const Or&, const Or&); std::vector bincodeSerialize() const; static Or bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct Xor { friend bool operator==(const Xor&, const Xor&); std::vector bincodeSerialize() const; static Xor bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct Shl { friend bool operator==(const Shl&, const Shl&); std::vector bincodeSerialize() const; static Shl bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct Shr { friend bool operator==(const Shr&, const Shr&); std::vector bincodeSerialize() const; static Shr bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; std::variant value; @@ -141,6 +358,147 @@ namespace Program { friend bool operator==(const BinaryIntOp&, const BinaryIntOp&); std::vector bincodeSerialize() const; static BinaryIntOp bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + std::string tag; + bool is_unit; + switch (value.index()) { + + case 0: + tag = "Add"; + is_unit = true; + break; + case 1: + tag = "Sub"; + is_unit = true; + break; + case 2: + tag = "Mul"; + is_unit = true; + break; + case 3: + tag = "Div"; + is_unit = true; + break; + case 4: + tag = "Equals"; + is_unit = true; + break; + case 5: + tag = "LessThan"; + is_unit = true; + break; + case 6: + tag = "LessThanEquals"; + is_unit = true; + break; + case 7: + tag = "And"; + is_unit = true; + break; + case 8: + tag = "Or"; + is_unit = true; + break; + case 9: + tag = "Xor"; + is_unit = true; + break; + case 10: + tag = "Shl"; + is_unit = true; + break; + case 11: + tag = "Shr"; + is_unit = true; + break; + default: + throw_or_abort("unknown enum 'BinaryIntOp' variant index: " + std::to_string(value.index())); + } + if (is_unit) { + packer.pack(tag); + } else { + std::visit([&packer, tag](const auto& arg) { + std::map data; + data[tag] = msgpack::object(arg); + packer.pack(data); + }, value); + } + } + + void msgpack_unpack(msgpack::object const& o) { + + if (o.type != msgpack::type::object_type::MAP && o.type != msgpack::type::object_type::STR) { + std::cerr << o << std::endl; + throw_or_abort("expected MAP or STR for enum 'BinaryIntOp'; got type " + std::to_string(o.type)); + } + if (o.type == msgpack::type::object_type::MAP && o.via.map.size != 1) { + throw_or_abort("expected 1 entry for enum 'BinaryIntOp'; got " + std::to_string(o.via.map.size)); + } + std::string tag; + try { + if (o.type == msgpack::type::object_type::MAP) { + o.via.map.ptr[0].key.convert(tag); + } else { + o.convert(tag); + } + } catch(const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting tag to string for enum 'BinaryIntOp'"); + } + if (tag == "Add") { + Add v; + value = v; + } + else if (tag == "Sub") { + Sub v; + value = v; + } + else if (tag == "Mul") { + Mul v; + value = v; + } + else if (tag == "Div") { + Div v; + value = v; + } + else if (tag == "Equals") { + Equals v; + value = v; + } + else if (tag == "LessThan") { + LessThan v; + value = v; + } + else if (tag == "LessThanEquals") { + LessThanEquals v; + value = v; + } + else if (tag == "And") { + And v; + value = v; + } + else if (tag == "Or") { + Or v; + value = v; + } + else if (tag == "Xor") { + Xor v; + value = v; + } + else if (tag == "Shl") { + Shl v; + value = v; + } + else if (tag == "Shr") { + Shr v; + value = v; + } + else { + std::cerr << o << std::endl; + throw_or_abort("unknown 'BinaryIntOp' enum variant: " + tag); + } + } }; struct IntegerBitSize { @@ -149,36 +507,54 @@ namespace Program { friend bool operator==(const U1&, const U1&); std::vector bincodeSerialize() const; static U1 bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct U8 { friend bool operator==(const U8&, const U8&); std::vector bincodeSerialize() const; static U8 bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct U16 { friend bool operator==(const U16&, const U16&); std::vector bincodeSerialize() const; static U16 bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct U32 { friend bool operator==(const U32&, const U32&); std::vector bincodeSerialize() const; static U32 bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct U64 { friend bool operator==(const U64&, const U64&); std::vector bincodeSerialize() const; static U64 bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct U128 { friend bool operator==(const U128&, const U128&); std::vector bincodeSerialize() const; static U128 bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; std::variant value; @@ -186,6 +562,99 @@ namespace Program { friend bool operator==(const IntegerBitSize&, const IntegerBitSize&); std::vector bincodeSerialize() const; static IntegerBitSize bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + std::string tag; + bool is_unit; + switch (value.index()) { + + case 0: + tag = "U1"; + is_unit = true; + break; + case 1: + tag = "U8"; + is_unit = true; + break; + case 2: + tag = "U16"; + is_unit = true; + break; + case 3: + tag = "U32"; + is_unit = true; + break; + case 4: + tag = "U64"; + is_unit = true; + break; + case 5: + tag = "U128"; + is_unit = true; + break; + default: + throw_or_abort("unknown enum 'IntegerBitSize' variant index: " + std::to_string(value.index())); + } + if (is_unit) { + packer.pack(tag); + } else { + std::visit([&packer, tag](const auto& arg) { + std::map data; + data[tag] = msgpack::object(arg); + packer.pack(data); + }, value); + } + } + + void msgpack_unpack(msgpack::object const& o) { + + if (o.type != msgpack::type::object_type::MAP && o.type != msgpack::type::object_type::STR) { + std::cerr << o << std::endl; + throw_or_abort("expected MAP or STR for enum 'IntegerBitSize'; got type " + std::to_string(o.type)); + } + if (o.type == msgpack::type::object_type::MAP && o.via.map.size != 1) { + throw_or_abort("expected 1 entry for enum 'IntegerBitSize'; got " + std::to_string(o.via.map.size)); + } + std::string tag; + try { + if (o.type == msgpack::type::object_type::MAP) { + o.via.map.ptr[0].key.convert(tag); + } else { + o.convert(tag); + } + } catch(const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting tag to string for enum 'IntegerBitSize'"); + } + if (tag == "U1") { + U1 v; + value = v; + } + else if (tag == "U8") { + U8 v; + value = v; + } + else if (tag == "U16") { + U16 v; + value = v; + } + else if (tag == "U32") { + U32 v; + value = v; + } + else if (tag == "U64") { + U64 v; + value = v; + } + else if (tag == "U128") { + U128 v; + value = v; + } + else { + std::cerr << o << std::endl; + throw_or_abort("unknown 'IntegerBitSize' enum variant: " + tag); + } + } }; struct BitSize { @@ -194,14 +663,28 @@ namespace Program { friend bool operator==(const Field&, const Field&); std::vector bincodeSerialize() const; static Field bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct Integer { - Program::IntegerBitSize value; + Acir::IntegerBitSize value; friend bool operator==(const Integer&, const Integer&); std::vector bincodeSerialize() const; static Integer bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'Integer'"); + } + } }; std::variant value; @@ -209,6 +692,74 @@ namespace Program { friend bool operator==(const BitSize&, const BitSize&); std::vector bincodeSerialize() const; static BitSize bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + std::string tag; + bool is_unit; + switch (value.index()) { + + case 0: + tag = "Field"; + is_unit = true; + break; + case 1: + tag = "Integer"; + is_unit = false; + break; + default: + throw_or_abort("unknown enum 'BitSize' variant index: " + std::to_string(value.index())); + } + if (is_unit) { + packer.pack(tag); + } else { + std::visit([&packer, tag](const auto& arg) { + std::map data; + data[tag] = msgpack::object(arg); + packer.pack(data); + }, value); + } + } + + void msgpack_unpack(msgpack::object const& o) { + + if (o.type != msgpack::type::object_type::MAP && o.type != msgpack::type::object_type::STR) { + std::cerr << o << std::endl; + throw_or_abort("expected MAP or STR for enum 'BitSize'; got type " + std::to_string(o.type)); + } + if (o.type == msgpack::type::object_type::MAP && o.via.map.size != 1) { + throw_or_abort("expected 1 entry for enum 'BitSize'; got " + std::to_string(o.via.map.size)); + } + std::string tag; + try { + if (o.type == msgpack::type::object_type::MAP) { + o.via.map.ptr[0].key.convert(tag); + } else { + o.convert(tag); + } + } catch(const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting tag to string for enum 'BitSize'"); + } + if (tag == "Field") { + Field v; + value = v; + } + else if (tag == "Integer") { + Integer v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BitSize::Integer'"); + } + + value = v; + } + else { + std::cerr << o << std::endl; + throw_or_abort("unknown 'BitSize' enum variant: " + tag); + } + } }; struct MemoryAddress { @@ -219,6 +770,17 @@ namespace Program { friend bool operator==(const Direct&, const Direct&); std::vector bincodeSerialize() const; static Direct bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'Direct'"); + } + } }; struct Relative { @@ -227,6 +789,17 @@ namespace Program { friend bool operator==(const Relative&, const Relative&); std::vector bincodeSerialize() const; static Relative bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'Relative'"); + } + } }; std::variant value; @@ -234,203 +807,573 @@ namespace Program { friend bool operator==(const MemoryAddress&, const MemoryAddress&); std::vector bincodeSerialize() const; static MemoryAddress bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + std::string tag; + bool is_unit; + switch (value.index()) { + + case 0: + tag = "Direct"; + is_unit = false; + break; + case 1: + tag = "Relative"; + is_unit = false; + break; + default: + throw_or_abort("unknown enum 'MemoryAddress' variant index: " + std::to_string(value.index())); + } + if (is_unit) { + packer.pack(tag); + } else { + std::visit([&packer, tag](const auto& arg) { + std::map data; + data[tag] = msgpack::object(arg); + packer.pack(data); + }, value); + } + } + + void msgpack_unpack(msgpack::object const& o) { + + if (o.type != msgpack::type::object_type::MAP && o.type != msgpack::type::object_type::STR) { + std::cerr << o << std::endl; + throw_or_abort("expected MAP or STR for enum 'MemoryAddress'; got type " + std::to_string(o.type)); + } + if (o.type == msgpack::type::object_type::MAP && o.via.map.size != 1) { + throw_or_abort("expected 1 entry for enum 'MemoryAddress'; got " + std::to_string(o.via.map.size)); + } + std::string tag; + try { + if (o.type == msgpack::type::object_type::MAP) { + o.via.map.ptr[0].key.convert(tag); + } else { + o.convert(tag); + } + } catch(const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting tag to string for enum 'MemoryAddress'"); + } + if (tag == "Direct") { + Direct v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'MemoryAddress::Direct'"); + } + + value = v; + } + else if (tag == "Relative") { + Relative v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'MemoryAddress::Relative'"); + } + + value = v; + } + else { + std::cerr << o << std::endl; + throw_or_abort("unknown 'MemoryAddress' enum variant: " + tag); + } + } }; struct HeapArray { - Program::MemoryAddress pointer; + Acir::MemoryAddress pointer; uint64_t size; friend bool operator==(const HeapArray&, const HeapArray&); std::vector bincodeSerialize() const; static HeapArray bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(2); + packer.pack(std::make_pair("pointer", pointer)); + packer.pack(std::make_pair("size", size)); + } + + 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); + } }; struct HeapVector { - Program::MemoryAddress pointer; - Program::MemoryAddress size; + Acir::MemoryAddress pointer; + Acir::MemoryAddress size; friend bool operator==(const HeapVector&, const HeapVector&); std::vector bincodeSerialize() const; static HeapVector bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(2); + packer.pack(std::make_pair("pointer", pointer)); + packer.pack(std::make_pair("size", size)); + } + + 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); + } }; struct BlackBoxOp { struct AES128Encrypt { - Program::HeapVector inputs; - Program::HeapArray iv; - Program::HeapArray key; - Program::HeapVector outputs; + Acir::HeapVector inputs; + Acir::HeapArray iv; + Acir::HeapArray key; + Acir::HeapVector outputs; friend bool operator==(const AES128Encrypt&, const AES128Encrypt&); std::vector bincodeSerialize() const; static AES128Encrypt bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(4); + packer.pack(std::make_pair("inputs", inputs)); + packer.pack(std::make_pair("iv", iv)); + packer.pack(std::make_pair("key", key)); + packer.pack(std::make_pair("outputs", outputs)); + } + + 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); + } }; struct Blake2s { - Program::HeapVector message; - Program::HeapArray output; + Acir::HeapVector message; + Acir::HeapArray output; friend bool operator==(const Blake2s&, const Blake2s&); std::vector bincodeSerialize() const; static Blake2s bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(2); + packer.pack(std::make_pair("message", message)); + packer.pack(std::make_pair("output", output)); + } + + 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); + } }; struct Blake3 { - Program::HeapVector message; - Program::HeapArray output; + Acir::HeapVector message; + Acir::HeapArray output; friend bool operator==(const Blake3&, const Blake3&); std::vector bincodeSerialize() const; static Blake3 bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(2); + packer.pack(std::make_pair("message", message)); + packer.pack(std::make_pair("output", output)); + } + + 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); + } }; struct Keccakf1600 { - Program::HeapArray input; - Program::HeapArray output; + Acir::HeapArray input; + Acir::HeapArray output; friend bool operator==(const Keccakf1600&, const Keccakf1600&); std::vector bincodeSerialize() const; static Keccakf1600 bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(2); + packer.pack(std::make_pair("input", input)); + packer.pack(std::make_pair("output", output)); + } + + 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); + } }; struct EcdsaSecp256k1 { - Program::HeapVector hashed_msg; - Program::HeapArray public_key_x; - Program::HeapArray public_key_y; - Program::HeapArray signature; - Program::MemoryAddress result; + Acir::HeapVector hashed_msg; + Acir::HeapArray public_key_x; + Acir::HeapArray public_key_y; + Acir::HeapArray signature; + Acir::MemoryAddress result; friend bool operator==(const EcdsaSecp256k1&, const EcdsaSecp256k1&); std::vector bincodeSerialize() const; static EcdsaSecp256k1 bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(5); + packer.pack(std::make_pair("hashed_msg", hashed_msg)); + packer.pack(std::make_pair("public_key_x", public_key_x)); + packer.pack(std::make_pair("public_key_y", public_key_y)); + packer.pack(std::make_pair("signature", signature)); + packer.pack(std::make_pair("result", result)); + } + + 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); + } }; struct EcdsaSecp256r1 { - Program::HeapVector hashed_msg; - Program::HeapArray public_key_x; - Program::HeapArray public_key_y; - Program::HeapArray signature; - Program::MemoryAddress result; + Acir::HeapVector hashed_msg; + Acir::HeapArray public_key_x; + Acir::HeapArray public_key_y; + Acir::HeapArray signature; + Acir::MemoryAddress result; friend bool operator==(const EcdsaSecp256r1&, const EcdsaSecp256r1&); std::vector bincodeSerialize() const; static EcdsaSecp256r1 bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(5); + packer.pack(std::make_pair("hashed_msg", hashed_msg)); + packer.pack(std::make_pair("public_key_x", public_key_x)); + packer.pack(std::make_pair("public_key_y", public_key_y)); + packer.pack(std::make_pair("signature", signature)); + packer.pack(std::make_pair("result", result)); + } + + 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); + } }; struct MultiScalarMul { - Program::HeapVector points; - Program::HeapVector scalars; - Program::HeapArray outputs; + Acir::HeapVector points; + Acir::HeapVector scalars; + Acir::HeapArray outputs; friend bool operator==(const MultiScalarMul&, const MultiScalarMul&); std::vector bincodeSerialize() const; static MultiScalarMul bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("points", points)); + packer.pack(std::make_pair("scalars", scalars)); + packer.pack(std::make_pair("outputs", outputs)); + } + + 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); + } }; struct EmbeddedCurveAdd { - Program::MemoryAddress input1_x; - Program::MemoryAddress input1_y; - Program::MemoryAddress input1_infinite; - Program::MemoryAddress input2_x; - Program::MemoryAddress input2_y; - Program::MemoryAddress input2_infinite; - Program::HeapArray result; + Acir::MemoryAddress input1_x; + Acir::MemoryAddress input1_y; + Acir::MemoryAddress input1_infinite; + Acir::MemoryAddress input2_x; + Acir::MemoryAddress input2_y; + Acir::MemoryAddress input2_infinite; + Acir::HeapArray result; friend bool operator==(const EmbeddedCurveAdd&, const EmbeddedCurveAdd&); std::vector bincodeSerialize() const; static EmbeddedCurveAdd bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(7); + packer.pack(std::make_pair("input1_x", input1_x)); + packer.pack(std::make_pair("input1_y", input1_y)); + packer.pack(std::make_pair("input1_infinite", input1_infinite)); + packer.pack(std::make_pair("input2_x", input2_x)); + packer.pack(std::make_pair("input2_y", input2_y)); + packer.pack(std::make_pair("input2_infinite", input2_infinite)); + packer.pack(std::make_pair("result", result)); + } + + 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); + } }; struct BigIntAdd { - Program::MemoryAddress lhs; - Program::MemoryAddress rhs; - Program::MemoryAddress output; + Acir::MemoryAddress lhs; + Acir::MemoryAddress rhs; + Acir::MemoryAddress output; friend bool operator==(const BigIntAdd&, const BigIntAdd&); std::vector bincodeSerialize() const; static BigIntAdd bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("lhs", lhs)); + packer.pack(std::make_pair("rhs", rhs)); + packer.pack(std::make_pair("output", output)); + } + + void msgpack_unpack(msgpack::object const& o) { + auto name = "BigIntAdd"; + 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, "output", output, false); + } }; struct BigIntSub { - Program::MemoryAddress lhs; - Program::MemoryAddress rhs; - Program::MemoryAddress output; + Acir::MemoryAddress lhs; + Acir::MemoryAddress rhs; + Acir::MemoryAddress output; friend bool operator==(const BigIntSub&, const BigIntSub&); std::vector bincodeSerialize() const; static BigIntSub bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("lhs", lhs)); + packer.pack(std::make_pair("rhs", rhs)); + packer.pack(std::make_pair("output", output)); + } + + void msgpack_unpack(msgpack::object const& o) { + auto name = "BigIntSub"; + 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, "output", output, false); + } }; struct BigIntMul { - Program::MemoryAddress lhs; - Program::MemoryAddress rhs; - Program::MemoryAddress output; + Acir::MemoryAddress lhs; + Acir::MemoryAddress rhs; + Acir::MemoryAddress output; friend bool operator==(const BigIntMul&, const BigIntMul&); std::vector bincodeSerialize() const; static BigIntMul bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("lhs", lhs)); + packer.pack(std::make_pair("rhs", rhs)); + packer.pack(std::make_pair("output", output)); + } + + void msgpack_unpack(msgpack::object const& o) { + auto name = "BigIntMul"; + 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, "output", output, false); + } }; struct BigIntDiv { - Program::MemoryAddress lhs; - Program::MemoryAddress rhs; - Program::MemoryAddress output; + Acir::MemoryAddress lhs; + Acir::MemoryAddress rhs; + Acir::MemoryAddress output; friend bool operator==(const BigIntDiv&, const BigIntDiv&); std::vector bincodeSerialize() const; static BigIntDiv bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("lhs", lhs)); + packer.pack(std::make_pair("rhs", rhs)); + packer.pack(std::make_pair("output", output)); + } + + void msgpack_unpack(msgpack::object const& o) { + auto name = "BigIntDiv"; + 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, "output", output, false); + } }; struct BigIntFromLeBytes { - Program::HeapVector inputs; - Program::HeapVector modulus; - Program::MemoryAddress output; + Acir::HeapVector inputs; + Acir::HeapVector modulus; + Acir::MemoryAddress output; friend bool operator==(const BigIntFromLeBytes&, const BigIntFromLeBytes&); std::vector bincodeSerialize() const; static BigIntFromLeBytes bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("inputs", inputs)); + packer.pack(std::make_pair("modulus", modulus)); + packer.pack(std::make_pair("output", output)); + } + + void msgpack_unpack(msgpack::object const& o) { + auto name = "BigIntFromLeBytes"; + auto kvmap = Helpers::make_kvmap(o, name); + Helpers::conv_fld_from_kvmap(kvmap, name, "inputs", inputs, false); + Helpers::conv_fld_from_kvmap(kvmap, name, "modulus", modulus, false); + Helpers::conv_fld_from_kvmap(kvmap, name, "output", output, false); + } }; struct BigIntToLeBytes { - Program::MemoryAddress input; - Program::HeapVector output; + Acir::MemoryAddress input; + Acir::HeapVector output; friend bool operator==(const BigIntToLeBytes&, const BigIntToLeBytes&); std::vector bincodeSerialize() const; static BigIntToLeBytes bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(2); + packer.pack(std::make_pair("input", input)); + packer.pack(std::make_pair("output", output)); + } + + void msgpack_unpack(msgpack::object const& o) { + auto name = "BigIntToLeBytes"; + 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); + } }; struct Poseidon2Permutation { - Program::HeapVector message; - Program::HeapArray output; - Program::MemoryAddress len; + Acir::HeapVector message; + Acir::HeapArray output; + Acir::MemoryAddress len; friend bool operator==(const Poseidon2Permutation&, const Poseidon2Permutation&); std::vector bincodeSerialize() const; static Poseidon2Permutation bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("message", message)); + packer.pack(std::make_pair("output", output)); + packer.pack(std::make_pair("len", len)); + } + + 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); + Helpers::conv_fld_from_kvmap(kvmap, name, "len", len, false); + } }; struct Sha256Compression { - Program::HeapArray input; - Program::HeapArray hash_values; - Program::HeapArray output; + Acir::HeapArray input; + Acir::HeapArray hash_values; + Acir::HeapArray output; friend bool operator==(const Sha256Compression&, const Sha256Compression&); std::vector bincodeSerialize() const; static Sha256Compression bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("input", input)); + packer.pack(std::make_pair("hash_values", hash_values)); + packer.pack(std::make_pair("output", output)); + } + + 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); + } }; struct ToRadix { - Program::MemoryAddress input; - Program::MemoryAddress radix; - Program::MemoryAddress output_pointer; - Program::MemoryAddress num_limbs; - Program::MemoryAddress output_bits; + Acir::MemoryAddress input; + Acir::MemoryAddress radix; + Acir::MemoryAddress output_pointer; + Acir::MemoryAddress num_limbs; + Acir::MemoryAddress output_bits; friend bool operator==(const ToRadix&, const ToRadix&); std::vector bincodeSerialize() const; static ToRadix bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(5); + packer.pack(std::make_pair("input", input)); + packer.pack(std::make_pair("radix", radix)); + packer.pack(std::make_pair("output_pointer", output_pointer)); + packer.pack(std::make_pair("num_limbs", num_limbs)); + packer.pack(std::make_pair("output_bits", output_bits)); + } + + 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::variant value; @@ -438,6 +1381,306 @@ namespace Program { friend bool operator==(const BlackBoxOp&, const BlackBoxOp&); std::vector bincodeSerialize() const; static BlackBoxOp bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + std::string tag; + bool is_unit; + switch (value.index()) { + + case 0: + tag = "AES128Encrypt"; + is_unit = false; + break; + case 1: + tag = "Blake2s"; + is_unit = false; + break; + case 2: + tag = "Blake3"; + is_unit = false; + break; + case 3: + tag = "Keccakf1600"; + is_unit = false; + break; + case 4: + tag = "EcdsaSecp256k1"; + is_unit = false; + break; + case 5: + tag = "EcdsaSecp256r1"; + is_unit = false; + break; + case 6: + tag = "MultiScalarMul"; + is_unit = false; + break; + case 7: + tag = "EmbeddedCurveAdd"; + is_unit = false; + break; + case 8: + tag = "BigIntAdd"; + is_unit = false; + break; + case 9: + tag = "BigIntSub"; + is_unit = false; + break; + case 10: + tag = "BigIntMul"; + is_unit = false; + break; + case 11: + tag = "BigIntDiv"; + is_unit = false; + break; + case 12: + tag = "BigIntFromLeBytes"; + is_unit = false; + break; + case 13: + tag = "BigIntToLeBytes"; + is_unit = false; + break; + case 14: + tag = "Poseidon2Permutation"; + is_unit = false; + break; + case 15: + tag = "Sha256Compression"; + is_unit = false; + break; + case 16: + tag = "ToRadix"; + is_unit = false; + break; + default: + throw_or_abort("unknown enum 'BlackBoxOp' variant index: " + std::to_string(value.index())); + } + if (is_unit) { + packer.pack(tag); + } else { + std::visit([&packer, tag](const auto& arg) { + std::map data; + data[tag] = msgpack::object(arg); + packer.pack(data); + }, value); + } + } + + void msgpack_unpack(msgpack::object const& o) { + + if (o.type != msgpack::type::object_type::MAP && o.type != msgpack::type::object_type::STR) { + std::cerr << o << std::endl; + throw_or_abort("expected MAP or STR for enum 'BlackBoxOp'; got type " + std::to_string(o.type)); + } + if (o.type == msgpack::type::object_type::MAP && o.via.map.size != 1) { + throw_or_abort("expected 1 entry for enum 'BlackBoxOp'; got " + std::to_string(o.via.map.size)); + } + std::string tag; + try { + if (o.type == msgpack::type::object_type::MAP) { + o.via.map.ptr[0].key.convert(tag); + } else { + o.convert(tag); + } + } catch(const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting tag to string for enum 'BlackBoxOp'"); + } + if (tag == "AES128Encrypt") { + AES128Encrypt v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxOp::AES128Encrypt'"); + } + + value = v; + } + else if (tag == "Blake2s") { + Blake2s v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxOp::Blake2s'"); + } + + value = v; + } + else if (tag == "Blake3") { + Blake3 v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxOp::Blake3'"); + } + + value = v; + } + else if (tag == "Keccakf1600") { + Keccakf1600 v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxOp::Keccakf1600'"); + } + + value = v; + } + else if (tag == "EcdsaSecp256k1") { + EcdsaSecp256k1 v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxOp::EcdsaSecp256k1'"); + } + + value = v; + } + else if (tag == "EcdsaSecp256r1") { + EcdsaSecp256r1 v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxOp::EcdsaSecp256r1'"); + } + + value = v; + } + else if (tag == "MultiScalarMul") { + MultiScalarMul v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxOp::MultiScalarMul'"); + } + + value = v; + } + else if (tag == "EmbeddedCurveAdd") { + EmbeddedCurveAdd v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxOp::EmbeddedCurveAdd'"); + } + + value = v; + } + else if (tag == "BigIntAdd") { + BigIntAdd v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxOp::BigIntAdd'"); + } + + value = v; + } + else if (tag == "BigIntSub") { + BigIntSub v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxOp::BigIntSub'"); + } + + value = v; + } + else if (tag == "BigIntMul") { + BigIntMul v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxOp::BigIntMul'"); + } + + value = v; + } + else if (tag == "BigIntDiv") { + BigIntDiv v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxOp::BigIntDiv'"); + } + + value = v; + } + else if (tag == "BigIntFromLeBytes") { + BigIntFromLeBytes v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxOp::BigIntFromLeBytes'"); + } + + value = v; + } + else if (tag == "BigIntToLeBytes") { + BigIntToLeBytes v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxOp::BigIntToLeBytes'"); + } + + value = v; + } + else if (tag == "Poseidon2Permutation") { + Poseidon2Permutation v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxOp::Poseidon2Permutation'"); + } + + value = v; + } + else if (tag == "Sha256Compression") { + Sha256Compression v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxOp::Sha256Compression'"); + } + + value = v; + } + else if (tag == "ToRadix") { + ToRadix v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxOp::ToRadix'"); + } + + value = v; + } + else { + std::cerr << o << std::endl; + throw_or_abort("unknown 'BlackBoxOp' enum variant: " + tag); + } + } }; struct HeapValueType; @@ -445,28 +1688,63 @@ namespace Program { struct HeapValueType { struct Simple { - Program::BitSize value; + Acir::BitSize value; friend bool operator==(const Simple&, const Simple&); std::vector bincodeSerialize() const; static Simple bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'Simple'"); + } + } }; struct Array { - std::vector value_types; + std::vector value_types; uint64_t size; friend bool operator==(const Array&, const Array&); std::vector bincodeSerialize() const; static Array bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(2); + packer.pack(std::make_pair("value_types", value_types)); + packer.pack(std::make_pair("size", size)); + } + + 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); + } }; struct Vector { - std::vector value_types; + std::vector value_types; friend bool operator==(const Vector&, const Vector&); std::vector bincodeSerialize() const; static Vector bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(1); + packer.pack(std::make_pair("value_types", value_types)); + } + + 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::variant value; @@ -474,32 +1752,155 @@ namespace Program { friend bool operator==(const HeapValueType&, const HeapValueType&); std::vector bincodeSerialize() const; static HeapValueType bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + std::string tag; + bool is_unit; + switch (value.index()) { + + case 0: + tag = "Simple"; + is_unit = false; + break; + case 1: + tag = "Array"; + is_unit = false; + break; + case 2: + tag = "Vector"; + is_unit = false; + break; + default: + throw_or_abort("unknown enum 'HeapValueType' variant index: " + std::to_string(value.index())); + } + if (is_unit) { + packer.pack(tag); + } else { + std::visit([&packer, tag](const auto& arg) { + std::map data; + data[tag] = msgpack::object(arg); + packer.pack(data); + }, value); + } + } + + void msgpack_unpack(msgpack::object const& o) { + + if (o.type != msgpack::type::object_type::MAP && o.type != msgpack::type::object_type::STR) { + std::cerr << o << std::endl; + throw_or_abort("expected MAP or STR for enum 'HeapValueType'; got type " + std::to_string(o.type)); + } + if (o.type == msgpack::type::object_type::MAP && o.via.map.size != 1) { + throw_or_abort("expected 1 entry for enum 'HeapValueType'; got " + std::to_string(o.via.map.size)); + } + std::string tag; + try { + if (o.type == msgpack::type::object_type::MAP) { + o.via.map.ptr[0].key.convert(tag); + } else { + o.convert(tag); + } + } catch(const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting tag to string for enum 'HeapValueType'"); + } + if (tag == "Simple") { + Simple v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'HeapValueType::Simple'"); + } + + value = v; + } + else if (tag == "Array") { + Array v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'HeapValueType::Array'"); + } + + value = v; + } + else if (tag == "Vector") { + Vector v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'HeapValueType::Vector'"); + } + + value = v; + } + else { + std::cerr << o << std::endl; + throw_or_abort("unknown 'HeapValueType' enum variant: " + tag); + } + } }; struct ValueOrArray { struct MemoryAddress { - Program::MemoryAddress value; + Acir::MemoryAddress value; friend bool operator==(const MemoryAddress&, const MemoryAddress&); std::vector bincodeSerialize() const; static MemoryAddress bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'MemoryAddress'"); + } + } }; struct HeapArray { - Program::HeapArray value; + Acir::HeapArray value; friend bool operator==(const HeapArray&, const HeapArray&); std::vector bincodeSerialize() const; static HeapArray bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'HeapArray'"); + } + } }; struct HeapVector { - Program::HeapVector value; + Acir::HeapVector value; friend bool operator==(const HeapVector&, const HeapVector&); std::vector bincodeSerialize() const; static HeapVector bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'HeapVector'"); + } + } }; std::variant value; @@ -507,69 +1908,251 @@ namespace Program { friend bool operator==(const ValueOrArray&, const ValueOrArray&); std::vector bincodeSerialize() const; static ValueOrArray bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + std::string tag; + bool is_unit; + switch (value.index()) { + + case 0: + tag = "MemoryAddress"; + is_unit = false; + break; + case 1: + tag = "HeapArray"; + is_unit = false; + break; + case 2: + tag = "HeapVector"; + is_unit = false; + break; + default: + throw_or_abort("unknown enum 'ValueOrArray' variant index: " + std::to_string(value.index())); + } + if (is_unit) { + packer.pack(tag); + } else { + std::visit([&packer, tag](const auto& arg) { + std::map data; + data[tag] = msgpack::object(arg); + packer.pack(data); + }, value); + } + } + + void msgpack_unpack(msgpack::object const& o) { + + if (o.type != msgpack::type::object_type::MAP && o.type != msgpack::type::object_type::STR) { + std::cerr << o << std::endl; + throw_or_abort("expected MAP or STR for enum 'ValueOrArray'; got type " + std::to_string(o.type)); + } + if (o.type == msgpack::type::object_type::MAP && o.via.map.size != 1) { + throw_or_abort("expected 1 entry for enum 'ValueOrArray'; got " + std::to_string(o.via.map.size)); + } + std::string tag; + try { + if (o.type == msgpack::type::object_type::MAP) { + o.via.map.ptr[0].key.convert(tag); + } else { + o.convert(tag); + } + } catch(const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting tag to string for enum 'ValueOrArray'"); + } + if (tag == "MemoryAddress") { + MemoryAddress v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'ValueOrArray::MemoryAddress'"); + } + + value = v; + } + else if (tag == "HeapArray") { + HeapArray v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'ValueOrArray::HeapArray'"); + } + + value = v; + } + else if (tag == "HeapVector") { + HeapVector v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'ValueOrArray::HeapVector'"); + } + + value = v; + } + else { + std::cerr << o << std::endl; + throw_or_abort("unknown 'ValueOrArray' enum variant: " + tag); + } + } }; struct BrilligOpcode { struct BinaryFieldOp { - Program::MemoryAddress destination; - Program::BinaryFieldOp op; - Program::MemoryAddress lhs; - Program::MemoryAddress rhs; + Acir::MemoryAddress destination; + Acir::BinaryFieldOp op; + Acir::MemoryAddress lhs; + Acir::MemoryAddress rhs; friend bool operator==(const BinaryFieldOp&, const BinaryFieldOp&); std::vector bincodeSerialize() const; static BinaryFieldOp bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(4); + packer.pack(std::make_pair("destination", destination)); + packer.pack(std::make_pair("op", op)); + packer.pack(std::make_pair("lhs", lhs)); + packer.pack(std::make_pair("rhs", rhs)); + } + + 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); + } }; struct BinaryIntOp { - Program::MemoryAddress destination; - Program::BinaryIntOp op; - Program::IntegerBitSize bit_size; - Program::MemoryAddress lhs; - Program::MemoryAddress rhs; + Acir::MemoryAddress destination; + Acir::BinaryIntOp op; + Acir::IntegerBitSize bit_size; + Acir::MemoryAddress lhs; + Acir::MemoryAddress rhs; friend bool operator==(const BinaryIntOp&, const BinaryIntOp&); std::vector bincodeSerialize() const; static BinaryIntOp bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(5); + packer.pack(std::make_pair("destination", destination)); + packer.pack(std::make_pair("op", op)); + packer.pack(std::make_pair("bit_size", bit_size)); + packer.pack(std::make_pair("lhs", lhs)); + packer.pack(std::make_pair("rhs", rhs)); + } + + 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); + } }; struct Not { - Program::MemoryAddress destination; - Program::MemoryAddress source; - Program::IntegerBitSize bit_size; + Acir::MemoryAddress destination; + Acir::MemoryAddress source; + Acir::IntegerBitSize bit_size; friend bool operator==(const Not&, const Not&); std::vector bincodeSerialize() const; static Not bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("destination", destination)); + packer.pack(std::make_pair("source", source)); + packer.pack(std::make_pair("bit_size", bit_size)); + } + + 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); + } }; struct Cast { - Program::MemoryAddress destination; - Program::MemoryAddress source; - Program::BitSize bit_size; + Acir::MemoryAddress destination; + Acir::MemoryAddress source; + Acir::BitSize bit_size; friend bool operator==(const Cast&, const Cast&); std::vector bincodeSerialize() const; static Cast bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("destination", destination)); + packer.pack(std::make_pair("source", source)); + packer.pack(std::make_pair("bit_size", bit_size)); + } + + 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); + } }; struct JumpIfNot { - Program::MemoryAddress condition; + Acir::MemoryAddress condition; uint64_t location; friend bool operator==(const JumpIfNot&, const JumpIfNot&); std::vector bincodeSerialize() const; static JumpIfNot bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(2); + packer.pack(std::make_pair("condition", condition)); + packer.pack(std::make_pair("location", location)); + } + + void msgpack_unpack(msgpack::object const& o) { + auto name = "JumpIfNot"; + 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); + } }; struct JumpIf { - Program::MemoryAddress condition; + Acir::MemoryAddress condition; uint64_t location; friend bool operator==(const JumpIf&, const JumpIf&); std::vector bincodeSerialize() const; static JumpIf bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(2); + packer.pack(std::make_pair("condition", condition)); + packer.pack(std::make_pair("location", location)); + } + + 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); + } }; struct Jump { @@ -578,16 +2161,42 @@ namespace Program { friend bool operator==(const Jump&, const Jump&); std::vector bincodeSerialize() const; static Jump bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(1); + packer.pack(std::make_pair("location", location)); + } + + 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); + } }; struct CalldataCopy { - Program::MemoryAddress destination_address; - Program::MemoryAddress size_address; - Program::MemoryAddress offset_address; + Acir::MemoryAddress destination_address; + Acir::MemoryAddress size_address; + Acir::MemoryAddress offset_address; friend bool operator==(const CalldataCopy&, const CalldataCopy&); std::vector bincodeSerialize() const; static CalldataCopy bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("destination_address", destination_address)); + packer.pack(std::make_pair("size_address", size_address)); + packer.pack(std::make_pair("offset_address", offset_address)); + } + + 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); + } }; struct Call { @@ -596,106 +2205,258 @@ namespace Program { friend bool operator==(const Call&, const Call&); std::vector bincodeSerialize() const; static Call bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(1); + packer.pack(std::make_pair("location", location)); + } + + 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); + } }; struct Const { - Program::MemoryAddress destination; - Program::BitSize bit_size; + Acir::MemoryAddress destination; + Acir::BitSize bit_size; std::string value; friend bool operator==(const Const&, const Const&); std::vector bincodeSerialize() const; static Const bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("destination", destination)); + packer.pack(std::make_pair("bit_size", bit_size)); + packer.pack(std::make_pair("value", value)); + } + + 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); + } }; struct IndirectConst { - Program::MemoryAddress destination_pointer; - Program::BitSize bit_size; + Acir::MemoryAddress destination_pointer; + Acir::BitSize bit_size; std::string value; friend bool operator==(const IndirectConst&, const IndirectConst&); std::vector bincodeSerialize() const; static IndirectConst bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("destination_pointer", destination_pointer)); + packer.pack(std::make_pair("bit_size", bit_size)); + packer.pack(std::make_pair("value", value)); + } + + 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); + } }; struct Return { friend bool operator==(const Return&, const Return&); std::vector bincodeSerialize() const; static Return bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct ForeignCall { std::string function; - std::vector destinations; - std::vector destination_value_types; - std::vector inputs; - std::vector input_value_types; + std::vector destinations; + std::vector destination_value_types; + std::vector inputs; + std::vector input_value_types; friend bool operator==(const ForeignCall&, const ForeignCall&); std::vector bincodeSerialize() const; static ForeignCall bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(5); + packer.pack(std::make_pair("function", function)); + packer.pack(std::make_pair("destinations", destinations)); + packer.pack(std::make_pair("destination_value_types", destination_value_types)); + packer.pack(std::make_pair("inputs", inputs)); + packer.pack(std::make_pair("input_value_types", input_value_types)); + } + + 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); + } }; struct Mov { - Program::MemoryAddress destination; - Program::MemoryAddress source; + Acir::MemoryAddress destination; + Acir::MemoryAddress source; friend bool operator==(const Mov&, const Mov&); std::vector bincodeSerialize() const; static Mov bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(2); + packer.pack(std::make_pair("destination", destination)); + packer.pack(std::make_pair("source", source)); + } + + 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); + } }; struct ConditionalMov { - Program::MemoryAddress destination; - Program::MemoryAddress source_a; - Program::MemoryAddress source_b; - Program::MemoryAddress condition; + Acir::MemoryAddress destination; + Acir::MemoryAddress source_a; + Acir::MemoryAddress source_b; + Acir::MemoryAddress condition; friend bool operator==(const ConditionalMov&, const ConditionalMov&); std::vector bincodeSerialize() const; static ConditionalMov bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(4); + packer.pack(std::make_pair("destination", destination)); + packer.pack(std::make_pair("source_a", source_a)); + packer.pack(std::make_pair("source_b", source_b)); + packer.pack(std::make_pair("condition", condition)); + } + + 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); + } }; struct Load { - Program::MemoryAddress destination; - Program::MemoryAddress source_pointer; + Acir::MemoryAddress destination; + Acir::MemoryAddress source_pointer; friend bool operator==(const Load&, const Load&); std::vector bincodeSerialize() const; static Load bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(2); + packer.pack(std::make_pair("destination", destination)); + packer.pack(std::make_pair("source_pointer", source_pointer)); + } + + 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); + } }; struct Store { - Program::MemoryAddress destination_pointer; - Program::MemoryAddress source; + Acir::MemoryAddress destination_pointer; + Acir::MemoryAddress source; friend bool operator==(const Store&, const Store&); std::vector bincodeSerialize() const; static Store bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(2); + packer.pack(std::make_pair("destination_pointer", destination_pointer)); + packer.pack(std::make_pair("source", source)); + } + + 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); + } }; struct BlackBox { - Program::BlackBoxOp value; + Acir::BlackBoxOp value; friend bool operator==(const BlackBox&, const BlackBox&); std::vector bincodeSerialize() const; static BlackBox bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'BlackBox'"); + } + } }; struct Trap { - Program::HeapVector revert_data; + Acir::HeapVector revert_data; friend bool operator==(const Trap&, const Trap&); std::vector bincodeSerialize() const; static Trap bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(1); + packer.pack(std::make_pair("revert_data", revert_data)); + } + + 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); + } }; struct Stop { - Program::HeapVector return_data; + Acir::HeapVector return_data; friend bool operator==(const Stop&, const Stop&); std::vector bincodeSerialize() const; static Stop bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(1); + packer.pack(std::make_pair("return_data", return_data)); + } + + 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::variant value; @@ -703,6 +2464,344 @@ namespace Program { friend bool operator==(const BrilligOpcode&, const BrilligOpcode&); std::vector bincodeSerialize() const; static BrilligOpcode bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + std::string tag; + bool is_unit; + switch (value.index()) { + + case 0: + tag = "BinaryFieldOp"; + is_unit = false; + break; + case 1: + tag = "BinaryIntOp"; + is_unit = false; + break; + case 2: + tag = "Not"; + is_unit = false; + break; + case 3: + tag = "Cast"; + is_unit = false; + break; + case 4: + tag = "JumpIfNot"; + is_unit = false; + break; + case 5: + tag = "JumpIf"; + is_unit = false; + break; + case 6: + tag = "Jump"; + is_unit = false; + break; + case 7: + tag = "CalldataCopy"; + is_unit = false; + break; + case 8: + tag = "Call"; + is_unit = false; + break; + case 9: + tag = "Const"; + is_unit = false; + break; + case 10: + tag = "IndirectConst"; + is_unit = false; + break; + case 11: + tag = "Return"; + is_unit = true; + break; + case 12: + tag = "ForeignCall"; + is_unit = false; + break; + case 13: + tag = "Mov"; + is_unit = false; + break; + case 14: + tag = "ConditionalMov"; + is_unit = false; + break; + case 15: + tag = "Load"; + is_unit = false; + break; + case 16: + tag = "Store"; + is_unit = false; + break; + case 17: + tag = "BlackBox"; + is_unit = false; + break; + case 18: + tag = "Trap"; + is_unit = false; + break; + case 19: + tag = "Stop"; + is_unit = false; + break; + default: + throw_or_abort("unknown enum 'BrilligOpcode' variant index: " + std::to_string(value.index())); + } + if (is_unit) { + packer.pack(tag); + } else { + std::visit([&packer, tag](const auto& arg) { + std::map data; + data[tag] = msgpack::object(arg); + packer.pack(data); + }, value); + } + } + + void msgpack_unpack(msgpack::object const& o) { + + if (o.type != msgpack::type::object_type::MAP && o.type != msgpack::type::object_type::STR) { + std::cerr << o << std::endl; + throw_or_abort("expected MAP or STR for enum 'BrilligOpcode'; got type " + std::to_string(o.type)); + } + if (o.type == msgpack::type::object_type::MAP && o.via.map.size != 1) { + throw_or_abort("expected 1 entry for enum 'BrilligOpcode'; got " + std::to_string(o.via.map.size)); + } + std::string tag; + try { + if (o.type == msgpack::type::object_type::MAP) { + o.via.map.ptr[0].key.convert(tag); + } else { + o.convert(tag); + } + } catch(const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting tag to string for enum 'BrilligOpcode'"); + } + if (tag == "BinaryFieldOp") { + BinaryFieldOp v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligOpcode::BinaryFieldOp'"); + } + + value = v; + } + else if (tag == "BinaryIntOp") { + BinaryIntOp v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligOpcode::BinaryIntOp'"); + } + + value = v; + } + else if (tag == "Not") { + Not v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligOpcode::Not'"); + } + + value = v; + } + else if (tag == "Cast") { + Cast v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligOpcode::Cast'"); + } + + value = v; + } + else if (tag == "JumpIfNot") { + JumpIfNot v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligOpcode::JumpIfNot'"); + } + + value = v; + } + else if (tag == "JumpIf") { + JumpIf v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligOpcode::JumpIf'"); + } + + value = v; + } + else if (tag == "Jump") { + Jump v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligOpcode::Jump'"); + } + + value = v; + } + else if (tag == "CalldataCopy") { + CalldataCopy v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligOpcode::CalldataCopy'"); + } + + value = v; + } + else if (tag == "Call") { + Call v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligOpcode::Call'"); + } + + value = v; + } + else if (tag == "Const") { + Const v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligOpcode::Const'"); + } + + value = v; + } + else if (tag == "IndirectConst") { + IndirectConst v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligOpcode::IndirectConst'"); + } + + value = v; + } + else if (tag == "Return") { + Return v; + value = v; + } + else if (tag == "ForeignCall") { + ForeignCall v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligOpcode::ForeignCall'"); + } + + value = v; + } + else if (tag == "Mov") { + Mov v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligOpcode::Mov'"); + } + + value = v; + } + else if (tag == "ConditionalMov") { + ConditionalMov v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligOpcode::ConditionalMov'"); + } + + value = v; + } + else if (tag == "Load") { + Load v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligOpcode::Load'"); + } + + value = v; + } + else if (tag == "Store") { + Store v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligOpcode::Store'"); + } + + value = v; + } + else if (tag == "BlackBox") { + BlackBox v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligOpcode::BlackBox'"); + } + + value = v; + } + else if (tag == "Trap") { + Trap v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligOpcode::Trap'"); + } + + value = v; + } + else if (tag == "Stop") { + Stop v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligOpcode::Stop'"); + } + + value = v; + } + else { + std::cerr << o << std::endl; + throw_or_abort("unknown 'BrilligOpcode' enum variant: " + tag); + } + } }; struct Witness { @@ -711,6 +2810,17 @@ namespace Program { friend bool operator==(const Witness&, const Witness&); std::vector bincodeSerialize() const; static Witness bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'Witness'"); + } + } }; struct ConstantOrWitnessEnum { @@ -721,14 +2831,36 @@ namespace Program { friend bool operator==(const Constant&, const Constant&); std::vector bincodeSerialize() const; static Constant bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'Constant'"); + } + } }; struct Witness { - Program::Witness value; + Acir::Witness value; friend bool operator==(const Witness&, const Witness&); std::vector bincodeSerialize() const; static Witness bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'Witness'"); + } + } }; std::variant value; @@ -736,139 +2868,411 @@ namespace Program { friend bool operator==(const ConstantOrWitnessEnum&, const ConstantOrWitnessEnum&); std::vector bincodeSerialize() const; static ConstantOrWitnessEnum bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + std::string tag; + bool is_unit; + switch (value.index()) { + + case 0: + tag = "Constant"; + is_unit = false; + break; + case 1: + tag = "Witness"; + is_unit = false; + break; + default: + throw_or_abort("unknown enum 'ConstantOrWitnessEnum' variant index: " + std::to_string(value.index())); + } + if (is_unit) { + packer.pack(tag); + } else { + std::visit([&packer, tag](const auto& arg) { + std::map data; + data[tag] = msgpack::object(arg); + packer.pack(data); + }, value); + } + } + + void msgpack_unpack(msgpack::object const& o) { + + if (o.type != msgpack::type::object_type::MAP && o.type != msgpack::type::object_type::STR) { + std::cerr << o << std::endl; + throw_or_abort("expected MAP or STR for enum 'ConstantOrWitnessEnum'; got type " + std::to_string(o.type)); + } + if (o.type == msgpack::type::object_type::MAP && o.via.map.size != 1) { + throw_or_abort("expected 1 entry for enum 'ConstantOrWitnessEnum'; got " + std::to_string(o.via.map.size)); + } + std::string tag; + try { + if (o.type == msgpack::type::object_type::MAP) { + o.via.map.ptr[0].key.convert(tag); + } else { + o.convert(tag); + } + } catch(const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting tag to string for enum 'ConstantOrWitnessEnum'"); + } + if (tag == "Constant") { + Constant v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'ConstantOrWitnessEnum::Constant'"); + } + + value = v; + } + else if (tag == "Witness") { + Witness v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'ConstantOrWitnessEnum::Witness'"); + } + + value = v; + } + else { + std::cerr << o << std::endl; + throw_or_abort("unknown 'ConstantOrWitnessEnum' enum variant: " + tag); + } + } }; struct FunctionInput { - Program::ConstantOrWitnessEnum input; + Acir::ConstantOrWitnessEnum input; uint32_t num_bits; friend bool operator==(const FunctionInput&, const FunctionInput&); std::vector bincodeSerialize() const; static FunctionInput bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(2); + packer.pack(std::make_pair("input", input)); + packer.pack(std::make_pair("num_bits", num_bits)); + } + + void msgpack_unpack(msgpack::object const& o) { + auto name = "FunctionInput"; + 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); + } }; struct BlackBoxFuncCall { struct AES128Encrypt { - std::vector inputs; - std::array iv; - std::array key; - std::vector outputs; + std::vector inputs; + std::shared_ptr> iv; + std::shared_ptr> key; + std::vector outputs; friend bool operator==(const AES128Encrypt&, const AES128Encrypt&); std::vector bincodeSerialize() const; static AES128Encrypt bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(4); + packer.pack(std::make_pair("inputs", inputs)); + packer.pack(std::make_pair("iv", iv)); + packer.pack(std::make_pair("key", key)); + packer.pack(std::make_pair("outputs", outputs)); + } + + 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); + } }; struct AND { - Program::FunctionInput lhs; - Program::FunctionInput rhs; - Program::Witness output; + Acir::FunctionInput lhs; + Acir::FunctionInput rhs; + Acir::Witness output; friend bool operator==(const AND&, const AND&); std::vector bincodeSerialize() const; static AND bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("lhs", lhs)); + packer.pack(std::make_pair("rhs", rhs)); + packer.pack(std::make_pair("output", output)); + } + + 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, "output", output, false); + } }; struct XOR { - Program::FunctionInput lhs; - Program::FunctionInput rhs; - Program::Witness output; + Acir::FunctionInput lhs; + Acir::FunctionInput rhs; + Acir::Witness output; friend bool operator==(const XOR&, const XOR&); std::vector bincodeSerialize() const; static XOR bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("lhs", lhs)); + packer.pack(std::make_pair("rhs", rhs)); + packer.pack(std::make_pair("output", output)); + } + + 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, "output", output, false); + } }; struct RANGE { - Program::FunctionInput input; + Acir::FunctionInput input; friend bool operator==(const RANGE&, const RANGE&); std::vector bincodeSerialize() const; static RANGE bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(1); + packer.pack(std::make_pair("input", input)); + } + + 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); + } }; struct Blake2s { - std::vector inputs; - std::array outputs; + std::vector inputs; + std::shared_ptr> outputs; friend bool operator==(const Blake2s&, const Blake2s&); std::vector bincodeSerialize() const; static Blake2s bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(2); + packer.pack(std::make_pair("inputs", inputs)); + packer.pack(std::make_pair("outputs", outputs)); + } + + 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); + } }; struct Blake3 { - std::vector inputs; - std::array outputs; + std::vector inputs; + std::shared_ptr> outputs; friend bool operator==(const Blake3&, const Blake3&); std::vector bincodeSerialize() const; static Blake3 bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(2); + packer.pack(std::make_pair("inputs", inputs)); + packer.pack(std::make_pair("outputs", outputs)); + } + + 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); + } }; struct EcdsaSecp256k1 { - std::array public_key_x; - std::array public_key_y; - std::array signature; - std::array hashed_message; - Program::Witness output; + std::shared_ptr> public_key_x; + std::shared_ptr> public_key_y; + std::shared_ptr> signature; + std::shared_ptr> hashed_message; + Acir::Witness output; friend bool operator==(const EcdsaSecp256k1&, const EcdsaSecp256k1&); std::vector bincodeSerialize() const; static EcdsaSecp256k1 bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(5); + packer.pack(std::make_pair("public_key_x", public_key_x)); + packer.pack(std::make_pair("public_key_y", public_key_y)); + packer.pack(std::make_pair("signature", signature)); + packer.pack(std::make_pair("hashed_message", hashed_message)); + packer.pack(std::make_pair("output", output)); + } + + 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, "output", output, false); + } }; struct EcdsaSecp256r1 { - std::array public_key_x; - std::array public_key_y; - std::array signature; - std::array hashed_message; - Program::Witness output; + std::shared_ptr> public_key_x; + std::shared_ptr> public_key_y; + std::shared_ptr> signature; + std::shared_ptr> hashed_message; + Acir::Witness output; friend bool operator==(const EcdsaSecp256r1&, const EcdsaSecp256r1&); std::vector bincodeSerialize() const; static EcdsaSecp256r1 bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(5); + packer.pack(std::make_pair("public_key_x", public_key_x)); + packer.pack(std::make_pair("public_key_y", public_key_y)); + packer.pack(std::make_pair("signature", signature)); + packer.pack(std::make_pair("hashed_message", hashed_message)); + packer.pack(std::make_pair("output", output)); + } + + 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, "output", output, false); + } }; struct MultiScalarMul { - std::vector points; - std::vector scalars; - std::array outputs; + std::vector points; + std::vector scalars; + std::shared_ptr> outputs; friend bool operator==(const MultiScalarMul&, const MultiScalarMul&); std::vector bincodeSerialize() const; static MultiScalarMul bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("points", points)); + packer.pack(std::make_pair("scalars", scalars)); + packer.pack(std::make_pair("outputs", outputs)); + } + + 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); + } }; struct EmbeddedCurveAdd { - std::array input1; - std::array input2; - std::array outputs; + std::shared_ptr> input1; + std::shared_ptr> input2; + std::shared_ptr> outputs; friend bool operator==(const EmbeddedCurveAdd&, const EmbeddedCurveAdd&); std::vector bincodeSerialize() const; static EmbeddedCurveAdd bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("input1", input1)); + packer.pack(std::make_pair("input2", input2)); + packer.pack(std::make_pair("outputs", outputs)); + } + + 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, "outputs", outputs, false); + } }; struct Keccakf1600 { - std::array inputs; - std::array outputs; + std::shared_ptr> inputs; + std::shared_ptr> outputs; friend bool operator==(const Keccakf1600&, const Keccakf1600&); std::vector bincodeSerialize() const; static Keccakf1600 bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(2); + packer.pack(std::make_pair("inputs", inputs)); + packer.pack(std::make_pair("outputs", outputs)); + } + + 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); + } }; struct RecursiveAggregation { - std::vector verification_key; - std::vector proof; - std::vector public_inputs; - Program::FunctionInput key_hash; + std::vector verification_key; + std::vector proof; + std::vector public_inputs; + Acir::FunctionInput key_hash; uint32_t proof_type; friend bool operator==(const RecursiveAggregation&, const RecursiveAggregation&); std::vector bincodeSerialize() const; static RecursiveAggregation bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(5); + packer.pack(std::make_pair("verification_key", verification_key)); + packer.pack(std::make_pair("proof", proof)); + packer.pack(std::make_pair("public_inputs", public_inputs)); + packer.pack(std::make_pair("key_hash", key_hash)); + packer.pack(std::make_pair("proof_type", proof_type)); + } + + 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); + } }; struct BigIntAdd { @@ -879,6 +3283,21 @@ namespace Program { friend bool operator==(const BigIntAdd&, const BigIntAdd&); std::vector bincodeSerialize() const; static BigIntAdd bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("lhs", lhs)); + packer.pack(std::make_pair("rhs", rhs)); + packer.pack(std::make_pair("output", output)); + } + + void msgpack_unpack(msgpack::object const& o) { + auto name = "BigIntAdd"; + 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, "output", output, false); + } }; struct BigIntSub { @@ -889,6 +3308,21 @@ namespace Program { friend bool operator==(const BigIntSub&, const BigIntSub&); std::vector bincodeSerialize() const; static BigIntSub bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("lhs", lhs)); + packer.pack(std::make_pair("rhs", rhs)); + packer.pack(std::make_pair("output", output)); + } + + void msgpack_unpack(msgpack::object const& o) { + auto name = "BigIntSub"; + 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, "output", output, false); + } }; struct BigIntMul { @@ -899,6 +3333,21 @@ namespace Program { friend bool operator==(const BigIntMul&, const BigIntMul&); std::vector bincodeSerialize() const; static BigIntMul bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("lhs", lhs)); + packer.pack(std::make_pair("rhs", rhs)); + packer.pack(std::make_pair("output", output)); + } + + void msgpack_unpack(msgpack::object const& o) { + auto name = "BigIntMul"; + 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, "output", output, false); + } }; struct BigIntDiv { @@ -909,45 +3358,118 @@ namespace Program { friend bool operator==(const BigIntDiv&, const BigIntDiv&); std::vector bincodeSerialize() const; static BigIntDiv bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("lhs", lhs)); + packer.pack(std::make_pair("rhs", rhs)); + packer.pack(std::make_pair("output", output)); + } + + void msgpack_unpack(msgpack::object const& o) { + auto name = "BigIntDiv"; + 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, "output", output, false); + } }; struct BigIntFromLeBytes { - std::vector inputs; + std::vector inputs; std::vector modulus; uint32_t output; friend bool operator==(const BigIntFromLeBytes&, const BigIntFromLeBytes&); std::vector bincodeSerialize() const; static BigIntFromLeBytes bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("inputs", inputs)); + packer.pack(std::make_pair("modulus", modulus)); + packer.pack(std::make_pair("output", output)); + } + + void msgpack_unpack(msgpack::object const& o) { + auto name = "BigIntFromLeBytes"; + auto kvmap = Helpers::make_kvmap(o, name); + Helpers::conv_fld_from_kvmap(kvmap, name, "inputs", inputs, false); + Helpers::conv_fld_from_kvmap(kvmap, name, "modulus", modulus, false); + Helpers::conv_fld_from_kvmap(kvmap, name, "output", output, false); + } }; struct BigIntToLeBytes { uint32_t input; - std::vector outputs; + std::vector outputs; friend bool operator==(const BigIntToLeBytes&, const BigIntToLeBytes&); std::vector bincodeSerialize() const; static BigIntToLeBytes bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(2); + packer.pack(std::make_pair("input", input)); + packer.pack(std::make_pair("outputs", outputs)); + } + + void msgpack_unpack(msgpack::object const& o) { + auto name = "BigIntToLeBytes"; + auto kvmap = Helpers::make_kvmap(o, name); + Helpers::conv_fld_from_kvmap(kvmap, name, "input", input, false); + Helpers::conv_fld_from_kvmap(kvmap, name, "outputs", outputs, false); + } }; struct Poseidon2Permutation { - std::vector inputs; - std::vector outputs; + std::vector inputs; + std::vector outputs; uint32_t len; friend bool operator==(const Poseidon2Permutation&, const Poseidon2Permutation&); std::vector bincodeSerialize() const; static Poseidon2Permutation bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("inputs", inputs)); + packer.pack(std::make_pair("outputs", outputs)); + packer.pack(std::make_pair("len", len)); + } + + 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); + Helpers::conv_fld_from_kvmap(kvmap, name, "len", len, false); + } }; struct Sha256Compression { - std::array inputs; - std::array hash_values; - std::array outputs; + std::shared_ptr> inputs; + std::shared_ptr> hash_values; + std::shared_ptr> outputs; friend bool operator==(const Sha256Compression&, const Sha256Compression&); std::vector bincodeSerialize() const; static Sha256Compression bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("inputs", inputs)); + packer.pack(std::make_pair("hash_values", hash_values)); + packer.pack(std::make_pair("outputs", outputs)); + } + + 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::variant value; @@ -955,6 +3477,351 @@ namespace Program { friend bool operator==(const BlackBoxFuncCall&, const BlackBoxFuncCall&); std::vector bincodeSerialize() const; static BlackBoxFuncCall bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + std::string tag; + bool is_unit; + switch (value.index()) { + + case 0: + tag = "AES128Encrypt"; + is_unit = false; + break; + case 1: + tag = "AND"; + is_unit = false; + break; + case 2: + tag = "XOR"; + is_unit = false; + break; + case 3: + tag = "RANGE"; + is_unit = false; + break; + case 4: + tag = "Blake2s"; + is_unit = false; + break; + case 5: + tag = "Blake3"; + is_unit = false; + break; + case 6: + tag = "EcdsaSecp256k1"; + is_unit = false; + break; + case 7: + tag = "EcdsaSecp256r1"; + is_unit = false; + break; + case 8: + tag = "MultiScalarMul"; + is_unit = false; + break; + case 9: + tag = "EmbeddedCurveAdd"; + is_unit = false; + break; + case 10: + tag = "Keccakf1600"; + is_unit = false; + break; + case 11: + tag = "RecursiveAggregation"; + is_unit = false; + break; + case 12: + tag = "BigIntAdd"; + is_unit = false; + break; + case 13: + tag = "BigIntSub"; + is_unit = false; + break; + case 14: + tag = "BigIntMul"; + is_unit = false; + break; + case 15: + tag = "BigIntDiv"; + is_unit = false; + break; + case 16: + tag = "BigIntFromLeBytes"; + is_unit = false; + break; + case 17: + tag = "BigIntToLeBytes"; + is_unit = false; + break; + case 18: + tag = "Poseidon2Permutation"; + is_unit = false; + break; + case 19: + tag = "Sha256Compression"; + is_unit = false; + break; + default: + throw_or_abort("unknown enum 'BlackBoxFuncCall' variant index: " + std::to_string(value.index())); + } + if (is_unit) { + packer.pack(tag); + } else { + std::visit([&packer, tag](const auto& arg) { + std::map data; + data[tag] = msgpack::object(arg); + packer.pack(data); + }, value); + } + } + + void msgpack_unpack(msgpack::object const& o) { + + if (o.type != msgpack::type::object_type::MAP && o.type != msgpack::type::object_type::STR) { + std::cerr << o << std::endl; + throw_or_abort("expected MAP or STR for enum 'BlackBoxFuncCall'; got type " + std::to_string(o.type)); + } + if (o.type == msgpack::type::object_type::MAP && o.via.map.size != 1) { + throw_or_abort("expected 1 entry for enum 'BlackBoxFuncCall'; got " + std::to_string(o.via.map.size)); + } + std::string tag; + try { + if (o.type == msgpack::type::object_type::MAP) { + o.via.map.ptr[0].key.convert(tag); + } else { + o.convert(tag); + } + } catch(const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting tag to string for enum 'BlackBoxFuncCall'"); + } + if (tag == "AES128Encrypt") { + AES128Encrypt v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxFuncCall::AES128Encrypt'"); + } + + value = v; + } + else if (tag == "AND") { + AND v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxFuncCall::AND'"); + } + + value = v; + } + else if (tag == "XOR") { + XOR v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxFuncCall::XOR'"); + } + + value = v; + } + else if (tag == "RANGE") { + RANGE v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxFuncCall::RANGE'"); + } + + value = v; + } + else if (tag == "Blake2s") { + Blake2s v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxFuncCall::Blake2s'"); + } + + value = v; + } + else if (tag == "Blake3") { + Blake3 v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxFuncCall::Blake3'"); + } + + value = v; + } + else if (tag == "EcdsaSecp256k1") { + EcdsaSecp256k1 v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxFuncCall::EcdsaSecp256k1'"); + } + + value = v; + } + else if (tag == "EcdsaSecp256r1") { + EcdsaSecp256r1 v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxFuncCall::EcdsaSecp256r1'"); + } + + value = v; + } + else if (tag == "MultiScalarMul") { + MultiScalarMul v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxFuncCall::MultiScalarMul'"); + } + + value = v; + } + else if (tag == "EmbeddedCurveAdd") { + EmbeddedCurveAdd v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxFuncCall::EmbeddedCurveAdd'"); + } + + value = v; + } + else if (tag == "Keccakf1600") { + Keccakf1600 v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxFuncCall::Keccakf1600'"); + } + + value = v; + } + else if (tag == "RecursiveAggregation") { + RecursiveAggregation v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxFuncCall::RecursiveAggregation'"); + } + + value = v; + } + else if (tag == "BigIntAdd") { + BigIntAdd v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxFuncCall::BigIntAdd'"); + } + + value = v; + } + else if (tag == "BigIntSub") { + BigIntSub v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxFuncCall::BigIntSub'"); + } + + value = v; + } + else if (tag == "BigIntMul") { + BigIntMul v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxFuncCall::BigIntMul'"); + } + + value = v; + } + else if (tag == "BigIntDiv") { + BigIntDiv v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxFuncCall::BigIntDiv'"); + } + + value = v; + } + else if (tag == "BigIntFromLeBytes") { + BigIntFromLeBytes v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxFuncCall::BigIntFromLeBytes'"); + } + + value = v; + } + else if (tag == "BigIntToLeBytes") { + BigIntToLeBytes v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxFuncCall::BigIntToLeBytes'"); + } + + value = v; + } + else if (tag == "Poseidon2Permutation") { + Poseidon2Permutation v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxFuncCall::Poseidon2Permutation'"); + } + + value = v; + } + else if (tag == "Sha256Compression") { + Sha256Compression v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlackBoxFuncCall::Sha256Compression'"); + } + + value = v; + } + else { + std::cerr << o << std::endl; + throw_or_abort("unknown 'BlackBoxFuncCall' enum variant: " + tag); + } + } }; struct BlockId { @@ -963,6 +3830,17 @@ namespace Program { friend bool operator==(const BlockId&, const BlockId&); std::vector bincodeSerialize() const; static BlockId bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'BlockId'"); + } + } }; struct BlockType { @@ -971,6 +3849,9 @@ namespace Program { friend bool operator==(const Memory&, const Memory&); std::vector bincodeSerialize() const; static Memory bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct CallData { @@ -979,12 +3860,26 @@ namespace Program { friend bool operator==(const CallData&, const CallData&); std::vector bincodeSerialize() const; static CallData bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'CallData'"); + } + } }; struct ReturnData { friend bool operator==(const ReturnData&, const ReturnData&); std::vector bincodeSerialize() const; static ReturnData bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; std::variant value; @@ -992,42 +3887,166 @@ namespace Program { friend bool operator==(const BlockType&, const BlockType&); std::vector bincodeSerialize() const; static BlockType bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + std::string tag; + bool is_unit; + switch (value.index()) { + + case 0: + tag = "Memory"; + is_unit = true; + break; + case 1: + tag = "CallData"; + is_unit = false; + break; + case 2: + tag = "ReturnData"; + is_unit = true; + break; + default: + throw_or_abort("unknown enum 'BlockType' variant index: " + std::to_string(value.index())); + } + if (is_unit) { + packer.pack(tag); + } else { + std::visit([&packer, tag](const auto& arg) { + std::map data; + data[tag] = msgpack::object(arg); + packer.pack(data); + }, value); + } + } + + void msgpack_unpack(msgpack::object const& o) { + + if (o.type != msgpack::type::object_type::MAP && o.type != msgpack::type::object_type::STR) { + std::cerr << o << std::endl; + throw_or_abort("expected MAP or STR for enum 'BlockType'; got type " + std::to_string(o.type)); + } + if (o.type == msgpack::type::object_type::MAP && o.via.map.size != 1) { + throw_or_abort("expected 1 entry for enum 'BlockType'; got " + std::to_string(o.via.map.size)); + } + std::string tag; + try { + if (o.type == msgpack::type::object_type::MAP) { + o.via.map.ptr[0].key.convert(tag); + } else { + o.convert(tag); + } + } catch(const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting tag to string for enum 'BlockType'"); + } + if (tag == "Memory") { + Memory v; + value = v; + } + else if (tag == "CallData") { + CallData v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BlockType::CallData'"); + } + + value = v; + } + else if (tag == "ReturnData") { + ReturnData v; + value = v; + } + else { + std::cerr << o << std::endl; + throw_or_abort("unknown 'BlockType' enum variant: " + tag); + } + } }; struct Expression { - std::vector> mul_terms; - std::vector> linear_combinations; + std::vector> mul_terms; + std::vector> linear_combinations; std::string q_c; friend bool operator==(const Expression&, const Expression&); std::vector bincodeSerialize() const; static Expression bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("mul_terms", mul_terms)); + packer.pack(std::make_pair("linear_combinations", linear_combinations)); + packer.pack(std::make_pair("q_c", q_c)); + } + + 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); + } }; struct BrilligInputs { struct Single { - Program::Expression value; + Acir::Expression value; friend bool operator==(const Single&, const Single&); std::vector bincodeSerialize() const; static Single bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'Single'"); + } + } }; struct Array { - std::vector value; + std::vector value; friend bool operator==(const Array&, const Array&); std::vector bincodeSerialize() const; static Array bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'Array'"); + } + } }; struct MemoryArray { - Program::BlockId value; + Acir::BlockId value; friend bool operator==(const MemoryArray&, const MemoryArray&); std::vector bincodeSerialize() const; static MemoryArray bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'MemoryArray'"); + } + } }; std::variant value; @@ -1035,24 +4054,136 @@ namespace Program { friend bool operator==(const BrilligInputs&, const BrilligInputs&); std::vector bincodeSerialize() const; static BrilligInputs bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + std::string tag; + bool is_unit; + switch (value.index()) { + + case 0: + tag = "Single"; + is_unit = false; + break; + case 1: + tag = "Array"; + is_unit = false; + break; + case 2: + tag = "MemoryArray"; + is_unit = false; + break; + default: + throw_or_abort("unknown enum 'BrilligInputs' variant index: " + std::to_string(value.index())); + } + if (is_unit) { + packer.pack(tag); + } else { + std::visit([&packer, tag](const auto& arg) { + std::map data; + data[tag] = msgpack::object(arg); + packer.pack(data); + }, value); + } + } + + void msgpack_unpack(msgpack::object const& o) { + + if (o.type != msgpack::type::object_type::MAP && o.type != msgpack::type::object_type::STR) { + std::cerr << o << std::endl; + throw_or_abort("expected MAP or STR for enum 'BrilligInputs'; got type " + std::to_string(o.type)); + } + if (o.type == msgpack::type::object_type::MAP && o.via.map.size != 1) { + throw_or_abort("expected 1 entry for enum 'BrilligInputs'; got " + std::to_string(o.via.map.size)); + } + std::string tag; + try { + if (o.type == msgpack::type::object_type::MAP) { + o.via.map.ptr[0].key.convert(tag); + } else { + o.convert(tag); + } + } catch(const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting tag to string for enum 'BrilligInputs'"); + } + if (tag == "Single") { + Single v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligInputs::Single'"); + } + + value = v; + } + else if (tag == "Array") { + Array v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligInputs::Array'"); + } + + value = v; + } + else if (tag == "MemoryArray") { + MemoryArray v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligInputs::MemoryArray'"); + } + + value = v; + } + else { + std::cerr << o << std::endl; + throw_or_abort("unknown 'BrilligInputs' enum variant: " + tag); + } + } }; struct BrilligOutputs { struct Simple { - Program::Witness value; + Acir::Witness value; friend bool operator==(const Simple&, const Simple&); std::vector bincodeSerialize() const; static Simple bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'Simple'"); + } + } }; struct Array { - std::vector value; + std::vector value; friend bool operator==(const Array&, const Array&); std::vector bincodeSerialize() const; static Array bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'Array'"); + } + } }; std::variant value; @@ -1060,76 +4191,252 @@ namespace Program { friend bool operator==(const BrilligOutputs&, const BrilligOutputs&); std::vector bincodeSerialize() const; static BrilligOutputs bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + std::string tag; + bool is_unit; + switch (value.index()) { + + case 0: + tag = "Simple"; + is_unit = false; + break; + case 1: + tag = "Array"; + is_unit = false; + break; + default: + throw_or_abort("unknown enum 'BrilligOutputs' variant index: " + std::to_string(value.index())); + } + if (is_unit) { + packer.pack(tag); + } else { + std::visit([&packer, tag](const auto& arg) { + std::map data; + data[tag] = msgpack::object(arg); + packer.pack(data); + }, value); + } + } + + void msgpack_unpack(msgpack::object const& o) { + + if (o.type != msgpack::type::object_type::MAP && o.type != msgpack::type::object_type::STR) { + std::cerr << o << std::endl; + throw_or_abort("expected MAP or STR for enum 'BrilligOutputs'; got type " + std::to_string(o.type)); + } + if (o.type == msgpack::type::object_type::MAP && o.via.map.size != 1) { + throw_or_abort("expected 1 entry for enum 'BrilligOutputs'; got " + std::to_string(o.via.map.size)); + } + std::string tag; + try { + if (o.type == msgpack::type::object_type::MAP) { + o.via.map.ptr[0].key.convert(tag); + } else { + o.convert(tag); + } + } catch(const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting tag to string for enum 'BrilligOutputs'"); + } + if (tag == "Simple") { + Simple v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligOutputs::Simple'"); + } + + value = v; + } + else if (tag == "Array") { + Array v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'BrilligOutputs::Array'"); + } + + value = v; + } + else { + std::cerr << o << std::endl; + throw_or_abort("unknown 'BrilligOutputs' enum variant: " + tag); + } + } }; struct MemOp { - Program::Expression operation; - Program::Expression index; - Program::Expression value; + Acir::Expression operation; + Acir::Expression index; + Acir::Expression value; friend bool operator==(const MemOp&, const MemOp&); std::vector bincodeSerialize() const; static MemOp bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("operation", operation)); + packer.pack(std::make_pair("index", index)); + packer.pack(std::make_pair("value", value)); + } + + 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); + } }; struct Opcode { struct AssertZero { - Program::Expression value; + Acir::Expression value; friend bool operator==(const AssertZero&, const AssertZero&); std::vector bincodeSerialize() const; static AssertZero bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'AssertZero'"); + } + } }; struct BlackBoxFuncCall { - Program::BlackBoxFuncCall value; + Acir::BlackBoxFuncCall value; friend bool operator==(const BlackBoxFuncCall&, const BlackBoxFuncCall&); std::vector bincodeSerialize() const; static BlackBoxFuncCall bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'BlackBoxFuncCall'"); + } + } }; struct MemoryOp { - Program::BlockId block_id; - Program::MemOp op; - std::optional predicate; + Acir::BlockId block_id; + Acir::MemOp op; + std::optional predicate; friend bool operator==(const MemoryOp&, const MemoryOp&); std::vector bincodeSerialize() const; static MemoryOp bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("block_id", block_id)); + packer.pack(std::make_pair("op", op)); + packer.pack(std::make_pair("predicate", predicate)); + } + + 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); + Helpers::conv_fld_from_kvmap(kvmap, name, "predicate", predicate, true); + } }; struct MemoryInit { - Program::BlockId block_id; - std::vector init; - Program::BlockType block_type; + Acir::BlockId block_id; + std::vector init; + Acir::BlockType block_type; friend bool operator==(const MemoryInit&, const MemoryInit&); std::vector bincodeSerialize() const; static MemoryInit bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(3); + packer.pack(std::make_pair("block_id", block_id)); + packer.pack(std::make_pair("init", init)); + packer.pack(std::make_pair("block_type", block_type)); + } + + 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); + } }; struct BrilligCall { uint32_t id; - std::vector inputs; - std::vector outputs; - std::optional predicate; + std::vector inputs; + std::vector outputs; + std::optional predicate; friend bool operator==(const BrilligCall&, const BrilligCall&); std::vector bincodeSerialize() const; static BrilligCall bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(4); + packer.pack(std::make_pair("id", id)); + packer.pack(std::make_pair("inputs", inputs)); + packer.pack(std::make_pair("outputs", outputs)); + packer.pack(std::make_pair("predicate", predicate)); + } + + 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); + } }; struct Call { uint32_t id; - std::vector inputs; - std::vector outputs; - std::optional predicate; + std::vector inputs; + std::vector outputs; + std::optional predicate; friend bool operator==(const Call&, const Call&); std::vector bincodeSerialize() const; static Call bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(4); + packer.pack(std::make_pair("id", id)); + packer.pack(std::make_pair("inputs", inputs)); + packer.pack(std::make_pair("outputs", outputs)); + packer.pack(std::make_pair("predicate", predicate)); + } + + 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::variant value; @@ -1137,24 +4444,181 @@ namespace Program { friend bool operator==(const Opcode&, const Opcode&); std::vector bincodeSerialize() const; static Opcode bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + std::string tag; + bool is_unit; + switch (value.index()) { + + case 0: + tag = "AssertZero"; + is_unit = false; + break; + case 1: + tag = "BlackBoxFuncCall"; + is_unit = false; + break; + case 2: + tag = "MemoryOp"; + is_unit = false; + break; + case 3: + tag = "MemoryInit"; + is_unit = false; + break; + case 4: + tag = "BrilligCall"; + is_unit = false; + break; + case 5: + tag = "Call"; + is_unit = false; + break; + default: + throw_or_abort("unknown enum 'Opcode' variant index: " + std::to_string(value.index())); + } + if (is_unit) { + packer.pack(tag); + } else { + std::visit([&packer, tag](const auto& arg) { + std::map data; + data[tag] = msgpack::object(arg); + packer.pack(data); + }, value); + } + } + + void msgpack_unpack(msgpack::object const& o) { + + if (o.type != msgpack::type::object_type::MAP && o.type != msgpack::type::object_type::STR) { + std::cerr << o << std::endl; + throw_or_abort("expected MAP or STR for enum 'Opcode'; got type " + std::to_string(o.type)); + } + if (o.type == msgpack::type::object_type::MAP && o.via.map.size != 1) { + throw_or_abort("expected 1 entry for enum 'Opcode'; got " + std::to_string(o.via.map.size)); + } + std::string tag; + try { + if (o.type == msgpack::type::object_type::MAP) { + o.via.map.ptr[0].key.convert(tag); + } else { + o.convert(tag); + } + } catch(const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting tag to string for enum 'Opcode'"); + } + if (tag == "AssertZero") { + AssertZero v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'Opcode::AssertZero'"); + } + + value = v; + } + else if (tag == "BlackBoxFuncCall") { + BlackBoxFuncCall v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'Opcode::BlackBoxFuncCall'"); + } + + value = v; + } + else if (tag == "MemoryOp") { + MemoryOp v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'Opcode::MemoryOp'"); + } + + value = v; + } + else if (tag == "MemoryInit") { + MemoryInit v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'Opcode::MemoryInit'"); + } + + value = v; + } + else if (tag == "BrilligCall") { + BrilligCall v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'Opcode::BrilligCall'"); + } + + value = v; + } + else if (tag == "Call") { + Call v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'Opcode::Call'"); + } + + value = v; + } + else { + std::cerr << o << std::endl; + throw_or_abort("unknown 'Opcode' enum variant: " + tag); + } + } }; struct ExpressionOrMemory { struct Expression { - Program::Expression value; + Acir::Expression value; friend bool operator==(const Expression&, const Expression&); std::vector bincodeSerialize() const; static Expression bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'Expression'"); + } + } }; struct Memory { - Program::BlockId value; + Acir::BlockId value; friend bool operator==(const Memory&, const Memory&); std::vector bincodeSerialize() const; static Memory bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'Memory'"); + } + } }; std::variant value; @@ -1162,15 +4626,103 @@ namespace Program { friend bool operator==(const ExpressionOrMemory&, const ExpressionOrMemory&); std::vector bincodeSerialize() const; static ExpressionOrMemory bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + std::string tag; + bool is_unit; + switch (value.index()) { + + case 0: + tag = "Expression"; + is_unit = false; + break; + case 1: + tag = "Memory"; + is_unit = false; + break; + default: + throw_or_abort("unknown enum 'ExpressionOrMemory' variant index: " + std::to_string(value.index())); + } + if (is_unit) { + packer.pack(tag); + } else { + std::visit([&packer, tag](const auto& arg) { + std::map data; + data[tag] = msgpack::object(arg); + packer.pack(data); + }, value); + } + } + + void msgpack_unpack(msgpack::object const& o) { + + if (o.type != msgpack::type::object_type::MAP && o.type != msgpack::type::object_type::STR) { + std::cerr << o << std::endl; + throw_or_abort("expected MAP or STR for enum 'ExpressionOrMemory'; got type " + std::to_string(o.type)); + } + if (o.type == msgpack::type::object_type::MAP && o.via.map.size != 1) { + throw_or_abort("expected 1 entry for enum 'ExpressionOrMemory'; got " + std::to_string(o.via.map.size)); + } + std::string tag; + try { + if (o.type == msgpack::type::object_type::MAP) { + o.via.map.ptr[0].key.convert(tag); + } else { + o.convert(tag); + } + } catch(const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting tag to string for enum 'ExpressionOrMemory'"); + } + if (tag == "Expression") { + Expression v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'ExpressionOrMemory::Expression'"); + } + + value = v; + } + else if (tag == "Memory") { + Memory v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'ExpressionOrMemory::Memory'"); + } + + value = v; + } + else { + std::cerr << o << std::endl; + throw_or_abort("unknown 'ExpressionOrMemory' enum variant: " + tag); + } + } }; struct AssertionPayload { uint64_t error_selector; - std::vector payload; + std::vector payload; friend bool operator==(const AssertionPayload&, const AssertionPayload&); std::vector bincodeSerialize() const; static AssertionPayload bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(2); + packer.pack(std::make_pair("error_selector", error_selector)); + packer.pack(std::make_pair("payload", payload)); + } + + 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); + } }; struct ExpressionWidth { @@ -1179,6 +4731,9 @@ namespace Program { friend bool operator==(const Unbounded&, const Unbounded&); std::vector bincodeSerialize() const; static Unbounded bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const {} + void msgpack_unpack(msgpack::object const& o) {} }; struct Bounded { @@ -1187,6 +4742,17 @@ namespace Program { friend bool operator==(const Bounded&, const Bounded&); std::vector bincodeSerialize() const; static Bounded bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(1); + packer.pack(std::make_pair("width", width)); + } + + 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::variant value; @@ -1194,6 +4760,74 @@ namespace Program { friend bool operator==(const ExpressionWidth&, const ExpressionWidth&); std::vector bincodeSerialize() const; static ExpressionWidth bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + std::string tag; + bool is_unit; + switch (value.index()) { + + case 0: + tag = "Unbounded"; + is_unit = true; + break; + case 1: + tag = "Bounded"; + is_unit = false; + break; + default: + throw_or_abort("unknown enum 'ExpressionWidth' variant index: " + std::to_string(value.index())); + } + if (is_unit) { + packer.pack(tag); + } else { + std::visit([&packer, tag](const auto& arg) { + std::map data; + data[tag] = msgpack::object(arg); + packer.pack(data); + }, value); + } + } + + void msgpack_unpack(msgpack::object const& o) { + + if (o.type != msgpack::type::object_type::MAP && o.type != msgpack::type::object_type::STR) { + std::cerr << o << std::endl; + throw_or_abort("expected MAP or STR for enum 'ExpressionWidth'; got type " + std::to_string(o.type)); + } + if (o.type == msgpack::type::object_type::MAP && o.via.map.size != 1) { + throw_or_abort("expected 1 entry for enum 'ExpressionWidth'; got " + std::to_string(o.via.map.size)); + } + std::string tag; + try { + if (o.type == msgpack::type::object_type::MAP) { + o.via.map.ptr[0].key.convert(tag); + } else { + o.convert(tag); + } + } catch(const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting tag to string for enum 'ExpressionWidth'"); + } + if (tag == "Unbounded") { + Unbounded v; + value = v; + } + else if (tag == "Bounded") { + Bounded v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'ExpressionWidth::Bounded'"); + } + + value = v; + } + else { + std::cerr << o << std::endl; + throw_or_abort("unknown 'ExpressionWidth' enum variant: " + tag); + } + } }; struct OpcodeLocation { @@ -1204,6 +4838,17 @@ namespace Program { friend bool operator==(const Acir&, const Acir&); std::vector bincodeSerialize() const; static Acir bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'Acir'"); + } + } }; struct Brillig { @@ -1213,6 +4858,19 @@ namespace Program { friend bool operator==(const Brillig&, const Brillig&); std::vector bincodeSerialize() const; static Brillig bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(2); + packer.pack(std::make_pair("acir_index", acir_index)); + packer.pack(std::make_pair("brillig_index", brillig_index)); + } + + 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::variant value; @@ -1220,51 +4878,203 @@ namespace Program { friend bool operator==(const OpcodeLocation&, const OpcodeLocation&); std::vector bincodeSerialize() const; static OpcodeLocation bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + std::string tag; + bool is_unit; + switch (value.index()) { + + case 0: + tag = "Acir"; + is_unit = false; + break; + case 1: + tag = "Brillig"; + is_unit = false; + break; + default: + throw_or_abort("unknown enum 'OpcodeLocation' variant index: " + std::to_string(value.index())); + } + if (is_unit) { + packer.pack(tag); + } else { + std::visit([&packer, tag](const auto& arg) { + std::map data; + data[tag] = msgpack::object(arg); + packer.pack(data); + }, value); + } + } + + void msgpack_unpack(msgpack::object const& o) { + + if (o.type != msgpack::type::object_type::MAP && o.type != msgpack::type::object_type::STR) { + std::cerr << o << std::endl; + throw_or_abort("expected MAP or STR for enum 'OpcodeLocation'; got type " + std::to_string(o.type)); + } + if (o.type == msgpack::type::object_type::MAP && o.via.map.size != 1) { + throw_or_abort("expected 1 entry for enum 'OpcodeLocation'; got " + std::to_string(o.via.map.size)); + } + std::string tag; + try { + if (o.type == msgpack::type::object_type::MAP) { + o.via.map.ptr[0].key.convert(tag); + } else { + o.convert(tag); + } + } catch(const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting tag to string for enum 'OpcodeLocation'"); + } + if (tag == "Acir") { + Acir v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'OpcodeLocation::Acir'"); + } + + value = v; + } + else if (tag == "Brillig") { + Brillig v; + try { + o.via.map.ptr[0].val.convert(v); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant 'OpcodeLocation::Brillig'"); + } + + value = v; + } + else { + std::cerr << o << std::endl; + throw_or_abort("unknown 'OpcodeLocation' enum variant: " + tag); + } + } }; struct PublicInputs { - std::vector value; + std::vector value; friend bool operator==(const PublicInputs&, const PublicInputs&); std::vector bincodeSerialize() const; static PublicInputs bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'PublicInputs'"); + } + } }; struct Circuit { uint32_t current_witness_index; - std::vector opcodes; - Program::ExpressionWidth expression_width; - std::vector private_parameters; - Program::PublicInputs public_parameters; - Program::PublicInputs return_values; - std::vector> assert_messages; + std::vector opcodes; + Acir::ExpressionWidth expression_width; + std::vector private_parameters; + Acir::PublicInputs public_parameters; + Acir::PublicInputs return_values; + std::vector> assert_messages; friend bool operator==(const Circuit&, const Circuit&); std::vector bincodeSerialize() const; static Circuit bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(7); + packer.pack(std::make_pair("current_witness_index", current_witness_index)); + packer.pack(std::make_pair("opcodes", opcodes)); + packer.pack(std::make_pair("expression_width", expression_width)); + packer.pack(std::make_pair("private_parameters", private_parameters)); + packer.pack(std::make_pair("public_parameters", public_parameters)); + packer.pack(std::make_pair("return_values", return_values)); + packer.pack(std::make_pair("assert_messages", assert_messages)); + } + + void msgpack_unpack(msgpack::object const& o) { + auto name = "Circuit"; + auto kvmap = Helpers::make_kvmap(o, name); + 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, "expression_width", expression_width, 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); + } }; struct BrilligBytecode { - std::vector bytecode; + std::vector bytecode; friend bool operator==(const BrilligBytecode&, const BrilligBytecode&); std::vector bincodeSerialize() const; static BrilligBytecode bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(1); + packer.pack(std::make_pair("bytecode", bytecode)); + } + + void msgpack_unpack(msgpack::object const& o) { + auto name = "BrilligBytecode"; + auto kvmap = Helpers::make_kvmap(o, name); + Helpers::conv_fld_from_kvmap(kvmap, name, "bytecode", bytecode, false); + } }; struct Program { - std::vector functions; - std::vector unconstrained_functions; + std::vector functions; + std::vector unconstrained_functions; friend bool operator==(const Program&, const Program&); std::vector bincodeSerialize() const; static Program bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(2); + packer.pack(std::make_pair("functions", functions)); + packer.pack(std::make_pair("unconstrained_functions", unconstrained_functions)); + } + + 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); + } + }; + + struct ProgramWithoutBrillig { + std::vector functions; + + friend bool operator==(const ProgramWithoutBrillig&, const ProgramWithoutBrillig&); + std::vector bincodeSerialize() const; + static ProgramWithoutBrillig bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(1); + packer.pack(std::make_pair("functions", functions)); + } + + 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); + } }; -} // end of namespace Program +} // end of namespace Acir -namespace Program { +namespace Acir { inline bool operator==(const AssertionPayload &lhs, const AssertionPayload &rhs) { if (!(lhs.error_selector == rhs.error_selector)) { return false; } @@ -1282,16 +5092,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::AssertionPayload &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::AssertionPayload &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.error_selector, serializer); serde::Serializable::serialize(obj.payload, serializer); @@ -1300,16 +5110,16 @@ void serde::Serializable::serialize(const Program::As template <> template -Program::AssertionPayload serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::AssertionPayload serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::AssertionPayload obj; + Acir::AssertionPayload obj; obj.error_selector = serde::Deserializable::deserialize(deserializer); obj.payload = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BinaryFieldOp &lhs, const BinaryFieldOp &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -1326,16 +5136,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BinaryFieldOp &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BinaryFieldOp &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -1343,15 +5153,15 @@ void serde::Serializable::serialize(const Program::Binar template <> template -Program::BinaryFieldOp serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::BinaryFieldOp serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::BinaryFieldOp obj; + Acir::BinaryFieldOp obj; obj.value = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BinaryFieldOp::Add &lhs, const BinaryFieldOp::Add &rhs) { return true; @@ -1367,26 +5177,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BinaryFieldOp::Add &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BinaryFieldOp::Add &obj, Serializer &serializer) { } template <> template -Program::BinaryFieldOp::Add serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BinaryFieldOp::Add obj; +Acir::BinaryFieldOp::Add serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BinaryFieldOp::Add obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BinaryFieldOp::Sub &lhs, const BinaryFieldOp::Sub &rhs) { return true; @@ -1402,26 +5212,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BinaryFieldOp::Sub &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BinaryFieldOp::Sub &obj, Serializer &serializer) { } template <> template -Program::BinaryFieldOp::Sub serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BinaryFieldOp::Sub obj; +Acir::BinaryFieldOp::Sub serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BinaryFieldOp::Sub obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BinaryFieldOp::Mul &lhs, const BinaryFieldOp::Mul &rhs) { return true; @@ -1437,26 +5247,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BinaryFieldOp::Mul &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BinaryFieldOp::Mul &obj, Serializer &serializer) { } template <> template -Program::BinaryFieldOp::Mul serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BinaryFieldOp::Mul obj; +Acir::BinaryFieldOp::Mul serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BinaryFieldOp::Mul obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BinaryFieldOp::Div &lhs, const BinaryFieldOp::Div &rhs) { return true; @@ -1472,26 +5282,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BinaryFieldOp::Div &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BinaryFieldOp::Div &obj, Serializer &serializer) { } template <> template -Program::BinaryFieldOp::Div serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BinaryFieldOp::Div obj; +Acir::BinaryFieldOp::Div serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BinaryFieldOp::Div obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BinaryFieldOp::IntegerDiv &lhs, const BinaryFieldOp::IntegerDiv &rhs) { return true; @@ -1507,26 +5317,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BinaryFieldOp::IntegerDiv &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BinaryFieldOp::IntegerDiv &obj, Serializer &serializer) { } template <> template -Program::BinaryFieldOp::IntegerDiv serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BinaryFieldOp::IntegerDiv obj; +Acir::BinaryFieldOp::IntegerDiv serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BinaryFieldOp::IntegerDiv obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BinaryFieldOp::Equals &lhs, const BinaryFieldOp::Equals &rhs) { return true; @@ -1542,26 +5352,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BinaryFieldOp::Equals &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BinaryFieldOp::Equals &obj, Serializer &serializer) { } template <> template -Program::BinaryFieldOp::Equals serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BinaryFieldOp::Equals obj; +Acir::BinaryFieldOp::Equals serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BinaryFieldOp::Equals obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BinaryFieldOp::LessThan &lhs, const BinaryFieldOp::LessThan &rhs) { return true; @@ -1577,26 +5387,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BinaryFieldOp::LessThan &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BinaryFieldOp::LessThan &obj, Serializer &serializer) { } template <> template -Program::BinaryFieldOp::LessThan serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BinaryFieldOp::LessThan obj; +Acir::BinaryFieldOp::LessThan serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BinaryFieldOp::LessThan obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BinaryFieldOp::LessThanEquals &lhs, const BinaryFieldOp::LessThanEquals &rhs) { return true; @@ -1612,26 +5422,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BinaryFieldOp::LessThanEquals &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BinaryFieldOp::LessThanEquals &obj, Serializer &serializer) { } template <> template -Program::BinaryFieldOp::LessThanEquals serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BinaryFieldOp::LessThanEquals obj; +Acir::BinaryFieldOp::LessThanEquals serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BinaryFieldOp::LessThanEquals obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BinaryIntOp &lhs, const BinaryIntOp &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -1648,16 +5458,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BinaryIntOp &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BinaryIntOp &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -1665,15 +5475,15 @@ void serde::Serializable::serialize(const Program::BinaryI template <> template -Program::BinaryIntOp serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::BinaryIntOp serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::BinaryIntOp obj; + Acir::BinaryIntOp obj; obj.value = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BinaryIntOp::Add &lhs, const BinaryIntOp::Add &rhs) { return true; @@ -1689,26 +5499,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BinaryIntOp::Add &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BinaryIntOp::Add &obj, Serializer &serializer) { } template <> template -Program::BinaryIntOp::Add serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BinaryIntOp::Add obj; +Acir::BinaryIntOp::Add serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BinaryIntOp::Add obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BinaryIntOp::Sub &lhs, const BinaryIntOp::Sub &rhs) { return true; @@ -1724,26 +5534,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BinaryIntOp::Sub &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BinaryIntOp::Sub &obj, Serializer &serializer) { } template <> template -Program::BinaryIntOp::Sub serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BinaryIntOp::Sub obj; +Acir::BinaryIntOp::Sub serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BinaryIntOp::Sub obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BinaryIntOp::Mul &lhs, const BinaryIntOp::Mul &rhs) { return true; @@ -1759,26 +5569,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BinaryIntOp::Mul &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BinaryIntOp::Mul &obj, Serializer &serializer) { } template <> template -Program::BinaryIntOp::Mul serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BinaryIntOp::Mul obj; +Acir::BinaryIntOp::Mul serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BinaryIntOp::Mul obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BinaryIntOp::Div &lhs, const BinaryIntOp::Div &rhs) { return true; @@ -1794,26 +5604,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BinaryIntOp::Div &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BinaryIntOp::Div &obj, Serializer &serializer) { } template <> template -Program::BinaryIntOp::Div serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BinaryIntOp::Div obj; +Acir::BinaryIntOp::Div serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BinaryIntOp::Div obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BinaryIntOp::Equals &lhs, const BinaryIntOp::Equals &rhs) { return true; @@ -1829,26 +5639,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BinaryIntOp::Equals &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BinaryIntOp::Equals &obj, Serializer &serializer) { } template <> template -Program::BinaryIntOp::Equals serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BinaryIntOp::Equals obj; +Acir::BinaryIntOp::Equals serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BinaryIntOp::Equals obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BinaryIntOp::LessThan &lhs, const BinaryIntOp::LessThan &rhs) { return true; @@ -1864,26 +5674,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BinaryIntOp::LessThan &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BinaryIntOp::LessThan &obj, Serializer &serializer) { } template <> template -Program::BinaryIntOp::LessThan serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BinaryIntOp::LessThan obj; +Acir::BinaryIntOp::LessThan serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BinaryIntOp::LessThan obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BinaryIntOp::LessThanEquals &lhs, const BinaryIntOp::LessThanEquals &rhs) { return true; @@ -1899,26 +5709,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BinaryIntOp::LessThanEquals &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BinaryIntOp::LessThanEquals &obj, Serializer &serializer) { } template <> template -Program::BinaryIntOp::LessThanEquals serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BinaryIntOp::LessThanEquals obj; +Acir::BinaryIntOp::LessThanEquals serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BinaryIntOp::LessThanEquals obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BinaryIntOp::And &lhs, const BinaryIntOp::And &rhs) { return true; @@ -1934,26 +5744,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BinaryIntOp::And &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BinaryIntOp::And &obj, Serializer &serializer) { } template <> template -Program::BinaryIntOp::And serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BinaryIntOp::And obj; +Acir::BinaryIntOp::And serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BinaryIntOp::And obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BinaryIntOp::Or &lhs, const BinaryIntOp::Or &rhs) { return true; @@ -1969,26 +5779,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BinaryIntOp::Or &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BinaryIntOp::Or &obj, Serializer &serializer) { } template <> template -Program::BinaryIntOp::Or serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BinaryIntOp::Or obj; +Acir::BinaryIntOp::Or serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BinaryIntOp::Or obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BinaryIntOp::Xor &lhs, const BinaryIntOp::Xor &rhs) { return true; @@ -2004,26 +5814,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BinaryIntOp::Xor &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BinaryIntOp::Xor &obj, Serializer &serializer) { } template <> template -Program::BinaryIntOp::Xor serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BinaryIntOp::Xor obj; +Acir::BinaryIntOp::Xor serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BinaryIntOp::Xor obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BinaryIntOp::Shl &lhs, const BinaryIntOp::Shl &rhs) { return true; @@ -2039,26 +5849,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BinaryIntOp::Shl &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BinaryIntOp::Shl &obj, Serializer &serializer) { } template <> template -Program::BinaryIntOp::Shl serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BinaryIntOp::Shl obj; +Acir::BinaryIntOp::Shl serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BinaryIntOp::Shl obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BinaryIntOp::Shr &lhs, const BinaryIntOp::Shr &rhs) { return true; @@ -2074,26 +5884,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BinaryIntOp::Shr &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BinaryIntOp::Shr &obj, Serializer &serializer) { } template <> template -Program::BinaryIntOp::Shr serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BinaryIntOp::Shr obj; +Acir::BinaryIntOp::Shr serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BinaryIntOp::Shr obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BitSize &lhs, const BitSize &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -2110,16 +5920,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BitSize &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BitSize &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -2127,15 +5937,15 @@ void serde::Serializable::serialize(const Program::BitSize &ob template <> template -Program::BitSize serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::BitSize serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::BitSize obj; + Acir::BitSize obj; obj.value = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BitSize::Field &lhs, const BitSize::Field &rhs) { return true; @@ -2151,26 +5961,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BitSize::Field &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BitSize::Field &obj, Serializer &serializer) { } template <> template -Program::BitSize::Field serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BitSize::Field obj; +Acir::BitSize::Field serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BitSize::Field obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BitSize::Integer &lhs, const BitSize::Integer &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -2187,28 +5997,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BitSize::Integer &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BitSize::Integer &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::BitSize::Integer serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BitSize::Integer obj; +Acir::BitSize::Integer serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BitSize::Integer obj; obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxFuncCall &lhs, const BlackBoxFuncCall &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -2225,16 +6035,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxFuncCall &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxFuncCall &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -2242,15 +6052,15 @@ void serde::Serializable::serialize(const Program::Bl template <> template -Program::BlackBoxFuncCall serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::BlackBoxFuncCall serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::BlackBoxFuncCall obj; + Acir::BlackBoxFuncCall obj; obj.value = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxFuncCall::AES128Encrypt &lhs, const BlackBoxFuncCall::AES128Encrypt &rhs) { if (!(lhs.inputs == rhs.inputs)) { return false; } @@ -2270,16 +6080,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxFuncCall::AES128Encrypt &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxFuncCall::AES128Encrypt &obj, Serializer &serializer) { serde::Serializable::serialize(obj.inputs, serializer); serde::Serializable::serialize(obj.iv, serializer); serde::Serializable::serialize(obj.key, serializer); @@ -2288,8 +6098,8 @@ void serde::Serializable::serialize(co template <> template -Program::BlackBoxFuncCall::AES128Encrypt serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::AES128Encrypt obj; +Acir::BlackBoxFuncCall::AES128Encrypt serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxFuncCall::AES128Encrypt obj; obj.inputs = serde::Deserializable::deserialize(deserializer); obj.iv = serde::Deserializable::deserialize(deserializer); obj.key = serde::Deserializable::deserialize(deserializer); @@ -2297,7 +6107,7 @@ Program::BlackBoxFuncCall::AES128Encrypt serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxFuncCall::AND &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxFuncCall::AND &obj, Serializer &serializer) { serde::Serializable::serialize(obj.lhs, serializer); serde::Serializable::serialize(obj.rhs, serializer); serde::Serializable::serialize(obj.output, serializer); @@ -2333,15 +6143,15 @@ void serde::Serializable::serialize(const Progra template <> template -Program::BlackBoxFuncCall::AND serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::AND obj; +Acir::BlackBoxFuncCall::AND serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxFuncCall::AND obj; obj.lhs = serde::Deserializable::deserialize(deserializer); obj.rhs = serde::Deserializable::deserialize(deserializer); obj.output = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxFuncCall::XOR &lhs, const BlackBoxFuncCall::XOR &rhs) { if (!(lhs.lhs == rhs.lhs)) { return false; } @@ -2360,16 +6170,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxFuncCall::XOR &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxFuncCall::XOR &obj, Serializer &serializer) { serde::Serializable::serialize(obj.lhs, serializer); serde::Serializable::serialize(obj.rhs, serializer); serde::Serializable::serialize(obj.output, serializer); @@ -2377,15 +6187,15 @@ void serde::Serializable::serialize(const Progra template <> template -Program::BlackBoxFuncCall::XOR serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::XOR obj; +Acir::BlackBoxFuncCall::XOR serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxFuncCall::XOR obj; obj.lhs = serde::Deserializable::deserialize(deserializer); obj.rhs = serde::Deserializable::deserialize(deserializer); obj.output = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxFuncCall::RANGE &lhs, const BlackBoxFuncCall::RANGE &rhs) { if (!(lhs.input == rhs.input)) { return false; } @@ -2402,28 +6212,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxFuncCall::RANGE &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxFuncCall::RANGE &obj, Serializer &serializer) { serde::Serializable::serialize(obj.input, serializer); } template <> template -Program::BlackBoxFuncCall::RANGE serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::RANGE obj; +Acir::BlackBoxFuncCall::RANGE serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxFuncCall::RANGE obj; obj.input = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxFuncCall::Blake2s &lhs, const BlackBoxFuncCall::Blake2s &rhs) { if (!(lhs.inputs == rhs.inputs)) { return false; } @@ -2441,30 +6251,30 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxFuncCall::Blake2s &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxFuncCall::Blake2s &obj, Serializer &serializer) { serde::Serializable::serialize(obj.inputs, serializer); serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::Blake2s serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::Blake2s obj; +Acir::BlackBoxFuncCall::Blake2s serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxFuncCall::Blake2s obj; obj.inputs = serde::Deserializable::deserialize(deserializer); obj.outputs = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxFuncCall::Blake3 &lhs, const BlackBoxFuncCall::Blake3 &rhs) { if (!(lhs.inputs == rhs.inputs)) { return false; } @@ -2482,30 +6292,30 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxFuncCall::Blake3 &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxFuncCall::Blake3 &obj, Serializer &serializer) { serde::Serializable::serialize(obj.inputs, serializer); serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::Blake3 serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::Blake3 obj; +Acir::BlackBoxFuncCall::Blake3 serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxFuncCall::Blake3 obj; obj.inputs = serde::Deserializable::deserialize(deserializer); obj.outputs = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxFuncCall::EcdsaSecp256k1 &lhs, const BlackBoxFuncCall::EcdsaSecp256k1 &rhs) { if (!(lhs.public_key_x == rhs.public_key_x)) { return false; } @@ -2526,16 +6336,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxFuncCall::EcdsaSecp256k1 &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxFuncCall::EcdsaSecp256k1 &obj, Serializer &serializer) { serde::Serializable::serialize(obj.public_key_x, serializer); serde::Serializable::serialize(obj.public_key_y, serializer); serde::Serializable::serialize(obj.signature, serializer); @@ -2545,8 +6355,8 @@ void serde::Serializable::serialize(c template <> template -Program::BlackBoxFuncCall::EcdsaSecp256k1 serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::EcdsaSecp256k1 obj; +Acir::BlackBoxFuncCall::EcdsaSecp256k1 serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxFuncCall::EcdsaSecp256k1 obj; obj.public_key_x = serde::Deserializable::deserialize(deserializer); obj.public_key_y = serde::Deserializable::deserialize(deserializer); obj.signature = serde::Deserializable::deserialize(deserializer); @@ -2555,7 +6365,7 @@ Program::BlackBoxFuncCall::EcdsaSecp256k1 serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxFuncCall::EcdsaSecp256r1 &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxFuncCall::EcdsaSecp256r1 &obj, Serializer &serializer) { serde::Serializable::serialize(obj.public_key_x, serializer); serde::Serializable::serialize(obj.public_key_y, serializer); serde::Serializable::serialize(obj.signature, serializer); @@ -2595,8 +6405,8 @@ void serde::Serializable::serialize(c template <> template -Program::BlackBoxFuncCall::EcdsaSecp256r1 serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::EcdsaSecp256r1 obj; +Acir::BlackBoxFuncCall::EcdsaSecp256r1 serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxFuncCall::EcdsaSecp256r1 obj; obj.public_key_x = serde::Deserializable::deserialize(deserializer); obj.public_key_y = serde::Deserializable::deserialize(deserializer); obj.signature = serde::Deserializable::deserialize(deserializer); @@ -2605,7 +6415,7 @@ Program::BlackBoxFuncCall::EcdsaSecp256r1 serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxFuncCall::MultiScalarMul &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxFuncCall::MultiScalarMul &obj, Serializer &serializer) { serde::Serializable::serialize(obj.points, serializer); serde::Serializable::serialize(obj.scalars, serializer); serde::Serializable::serialize(obj.outputs, serializer); @@ -2641,15 +6451,15 @@ void serde::Serializable::serialize(c template <> template -Program::BlackBoxFuncCall::MultiScalarMul serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::MultiScalarMul obj; +Acir::BlackBoxFuncCall::MultiScalarMul serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxFuncCall::MultiScalarMul obj; obj.points = serde::Deserializable::deserialize(deserializer); obj.scalars = serde::Deserializable::deserialize(deserializer); obj.outputs = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxFuncCall::EmbeddedCurveAdd &lhs, const BlackBoxFuncCall::EmbeddedCurveAdd &rhs) { if (!(lhs.input1 == rhs.input1)) { return false; } @@ -2668,16 +6478,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxFuncCall::EmbeddedCurveAdd &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxFuncCall::EmbeddedCurveAdd &obj, Serializer &serializer) { serde::Serializable::serialize(obj.input1, serializer); serde::Serializable::serialize(obj.input2, serializer); serde::Serializable::serialize(obj.outputs, serializer); @@ -2685,15 +6495,15 @@ void serde::Serializable::serialize template <> template -Program::BlackBoxFuncCall::EmbeddedCurveAdd serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::EmbeddedCurveAdd obj; +Acir::BlackBoxFuncCall::EmbeddedCurveAdd serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxFuncCall::EmbeddedCurveAdd obj; obj.input1 = serde::Deserializable::deserialize(deserializer); obj.input2 = serde::Deserializable::deserialize(deserializer); obj.outputs = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxFuncCall::Keccakf1600 &lhs, const BlackBoxFuncCall::Keccakf1600 &rhs) { if (!(lhs.inputs == rhs.inputs)) { return false; } @@ -2711,30 +6521,30 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxFuncCall::Keccakf1600 &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxFuncCall::Keccakf1600 &obj, Serializer &serializer) { serde::Serializable::serialize(obj.inputs, serializer); serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::Keccakf1600 serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::Keccakf1600 obj; +Acir::BlackBoxFuncCall::Keccakf1600 serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxFuncCall::Keccakf1600 obj; obj.inputs = serde::Deserializable::deserialize(deserializer); obj.outputs = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxFuncCall::RecursiveAggregation &lhs, const BlackBoxFuncCall::RecursiveAggregation &rhs) { if (!(lhs.verification_key == rhs.verification_key)) { return false; } @@ -2755,16 +6565,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxFuncCall::RecursiveAggregation &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxFuncCall::RecursiveAggregation &obj, Serializer &serializer) { serde::Serializable::serialize(obj.verification_key, serializer); serde::Serializable::serialize(obj.proof, serializer); serde::Serializable::serialize(obj.public_inputs, serializer); @@ -2774,8 +6584,8 @@ void serde::Serializable::seria template <> template -Program::BlackBoxFuncCall::RecursiveAggregation serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::RecursiveAggregation obj; +Acir::BlackBoxFuncCall::RecursiveAggregation serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxFuncCall::RecursiveAggregation obj; obj.verification_key = serde::Deserializable::deserialize(deserializer); obj.proof = serde::Deserializable::deserialize(deserializer); obj.public_inputs = serde::Deserializable::deserialize(deserializer); @@ -2784,7 +6594,7 @@ Program::BlackBoxFuncCall::RecursiveAggregation serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxFuncCall::BigIntAdd &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxFuncCall::BigIntAdd &obj, Serializer &serializer) { serde::Serializable::serialize(obj.lhs, serializer); serde::Serializable::serialize(obj.rhs, serializer); serde::Serializable::serialize(obj.output, serializer); @@ -2820,15 +6630,15 @@ void serde::Serializable::serialize(const template <> template -Program::BlackBoxFuncCall::BigIntAdd serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::BigIntAdd obj; +Acir::BlackBoxFuncCall::BigIntAdd serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxFuncCall::BigIntAdd obj; obj.lhs = serde::Deserializable::deserialize(deserializer); obj.rhs = serde::Deserializable::deserialize(deserializer); obj.output = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxFuncCall::BigIntSub &lhs, const BlackBoxFuncCall::BigIntSub &rhs) { if (!(lhs.lhs == rhs.lhs)) { return false; } @@ -2847,16 +6657,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxFuncCall::BigIntSub &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxFuncCall::BigIntSub &obj, Serializer &serializer) { serde::Serializable::serialize(obj.lhs, serializer); serde::Serializable::serialize(obj.rhs, serializer); serde::Serializable::serialize(obj.output, serializer); @@ -2864,15 +6674,15 @@ void serde::Serializable::serialize(const template <> template -Program::BlackBoxFuncCall::BigIntSub serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::BigIntSub obj; +Acir::BlackBoxFuncCall::BigIntSub serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxFuncCall::BigIntSub obj; obj.lhs = serde::Deserializable::deserialize(deserializer); obj.rhs = serde::Deserializable::deserialize(deserializer); obj.output = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxFuncCall::BigIntMul &lhs, const BlackBoxFuncCall::BigIntMul &rhs) { if (!(lhs.lhs == rhs.lhs)) { return false; } @@ -2891,16 +6701,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxFuncCall::BigIntMul &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxFuncCall::BigIntMul &obj, Serializer &serializer) { serde::Serializable::serialize(obj.lhs, serializer); serde::Serializable::serialize(obj.rhs, serializer); serde::Serializable::serialize(obj.output, serializer); @@ -2908,15 +6718,15 @@ void serde::Serializable::serialize(const template <> template -Program::BlackBoxFuncCall::BigIntMul serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::BigIntMul obj; +Acir::BlackBoxFuncCall::BigIntMul serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxFuncCall::BigIntMul obj; obj.lhs = serde::Deserializable::deserialize(deserializer); obj.rhs = serde::Deserializable::deserialize(deserializer); obj.output = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxFuncCall::BigIntDiv &lhs, const BlackBoxFuncCall::BigIntDiv &rhs) { if (!(lhs.lhs == rhs.lhs)) { return false; } @@ -2935,16 +6745,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxFuncCall::BigIntDiv &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxFuncCall::BigIntDiv &obj, Serializer &serializer) { serde::Serializable::serialize(obj.lhs, serializer); serde::Serializable::serialize(obj.rhs, serializer); serde::Serializable::serialize(obj.output, serializer); @@ -2952,15 +6762,15 @@ void serde::Serializable::serialize(const template <> template -Program::BlackBoxFuncCall::BigIntDiv serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::BigIntDiv obj; +Acir::BlackBoxFuncCall::BigIntDiv serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxFuncCall::BigIntDiv obj; obj.lhs = serde::Deserializable::deserialize(deserializer); obj.rhs = serde::Deserializable::deserialize(deserializer); obj.output = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxFuncCall::BigIntFromLeBytes &lhs, const BlackBoxFuncCall::BigIntFromLeBytes &rhs) { if (!(lhs.inputs == rhs.inputs)) { return false; } @@ -2979,16 +6789,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxFuncCall::BigIntFromLeBytes &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxFuncCall::BigIntFromLeBytes &obj, Serializer &serializer) { serde::Serializable::serialize(obj.inputs, serializer); serde::Serializable::serialize(obj.modulus, serializer); serde::Serializable::serialize(obj.output, serializer); @@ -2996,15 +6806,15 @@ void serde::Serializable::serializ template <> template -Program::BlackBoxFuncCall::BigIntFromLeBytes serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::BigIntFromLeBytes obj; +Acir::BlackBoxFuncCall::BigIntFromLeBytes serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxFuncCall::BigIntFromLeBytes obj; obj.inputs = serde::Deserializable::deserialize(deserializer); obj.modulus = serde::Deserializable::deserialize(deserializer); obj.output = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxFuncCall::BigIntToLeBytes &lhs, const BlackBoxFuncCall::BigIntToLeBytes &rhs) { if (!(lhs.input == rhs.input)) { return false; } @@ -3022,30 +6832,30 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxFuncCall::BigIntToLeBytes &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxFuncCall::BigIntToLeBytes &obj, Serializer &serializer) { serde::Serializable::serialize(obj.input, serializer); serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::BigIntToLeBytes serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::BigIntToLeBytes obj; +Acir::BlackBoxFuncCall::BigIntToLeBytes serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxFuncCall::BigIntToLeBytes obj; obj.input = serde::Deserializable::deserialize(deserializer); obj.outputs = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxFuncCall::Poseidon2Permutation &lhs, const BlackBoxFuncCall::Poseidon2Permutation &rhs) { if (!(lhs.inputs == rhs.inputs)) { return false; } @@ -3064,16 +6874,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxFuncCall::Poseidon2Permutation &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxFuncCall::Poseidon2Permutation &obj, Serializer &serializer) { serde::Serializable::serialize(obj.inputs, serializer); serde::Serializable::serialize(obj.outputs, serializer); serde::Serializable::serialize(obj.len, serializer); @@ -3081,15 +6891,15 @@ void serde::Serializable::seria template <> template -Program::BlackBoxFuncCall::Poseidon2Permutation serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::Poseidon2Permutation obj; +Acir::BlackBoxFuncCall::Poseidon2Permutation serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxFuncCall::Poseidon2Permutation obj; obj.inputs = serde::Deserializable::deserialize(deserializer); obj.outputs = serde::Deserializable::deserialize(deserializer); obj.len = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxFuncCall::Sha256Compression &lhs, const BlackBoxFuncCall::Sha256Compression &rhs) { if (!(lhs.inputs == rhs.inputs)) { return false; } @@ -3108,16 +6918,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxFuncCall::Sha256Compression &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxFuncCall::Sha256Compression &obj, Serializer &serializer) { serde::Serializable::serialize(obj.inputs, serializer); serde::Serializable::serialize(obj.hash_values, serializer); serde::Serializable::serialize(obj.outputs, serializer); @@ -3125,15 +6935,15 @@ void serde::Serializable::serializ template <> template -Program::BlackBoxFuncCall::Sha256Compression serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::Sha256Compression obj; +Acir::BlackBoxFuncCall::Sha256Compression serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxFuncCall::Sha256Compression obj; obj.inputs = serde::Deserializable::deserialize(deserializer); obj.hash_values = serde::Deserializable::deserialize(deserializer); obj.outputs = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxOp &lhs, const BlackBoxOp &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -3150,16 +6960,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxOp &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxOp &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -3167,15 +6977,15 @@ void serde::Serializable::serialize(const Program::BlackBox template <> template -Program::BlackBoxOp serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::BlackBoxOp serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::BlackBoxOp obj; + Acir::BlackBoxOp obj; obj.value = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxOp::AES128Encrypt &lhs, const BlackBoxOp::AES128Encrypt &rhs) { if (!(lhs.inputs == rhs.inputs)) { return false; } @@ -3195,16 +7005,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxOp::AES128Encrypt &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxOp::AES128Encrypt &obj, Serializer &serializer) { serde::Serializable::serialize(obj.inputs, serializer); serde::Serializable::serialize(obj.iv, serializer); serde::Serializable::serialize(obj.key, serializer); @@ -3213,8 +7023,8 @@ void serde::Serializable::serialize(const Pr template <> template -Program::BlackBoxOp::AES128Encrypt serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxOp::AES128Encrypt obj; +Acir::BlackBoxOp::AES128Encrypt serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxOp::AES128Encrypt obj; obj.inputs = serde::Deserializable::deserialize(deserializer); obj.iv = serde::Deserializable::deserialize(deserializer); obj.key = serde::Deserializable::deserialize(deserializer); @@ -3222,7 +7032,7 @@ Program::BlackBoxOp::AES128Encrypt serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxOp::Blake2s &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxOp::Blake2s &obj, Serializer &serializer) { serde::Serializable::serialize(obj.message, serializer); serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::Blake2s serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxOp::Blake2s obj; +Acir::BlackBoxOp::Blake2s serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxOp::Blake2s obj; obj.message = serde::Deserializable::deserialize(deserializer); obj.output = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxOp::Blake3 &lhs, const BlackBoxOp::Blake3 &rhs) { if (!(lhs.message == rhs.message)) { return false; } @@ -3281,30 +7091,30 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxOp::Blake3 &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxOp::Blake3 &obj, Serializer &serializer) { serde::Serializable::serialize(obj.message, serializer); serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::Blake3 serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxOp::Blake3 obj; +Acir::BlackBoxOp::Blake3 serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxOp::Blake3 obj; obj.message = serde::Deserializable::deserialize(deserializer); obj.output = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxOp::Keccakf1600 &lhs, const BlackBoxOp::Keccakf1600 &rhs) { if (!(lhs.input == rhs.input)) { return false; } @@ -3322,30 +7132,30 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxOp::Keccakf1600 &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxOp::Keccakf1600 &obj, Serializer &serializer) { serde::Serializable::serialize(obj.input, serializer); serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::Keccakf1600 serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxOp::Keccakf1600 obj; +Acir::BlackBoxOp::Keccakf1600 serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxOp::Keccakf1600 obj; obj.input = serde::Deserializable::deserialize(deserializer); obj.output = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxOp::EcdsaSecp256k1 &lhs, const BlackBoxOp::EcdsaSecp256k1 &rhs) { if (!(lhs.hashed_msg == rhs.hashed_msg)) { return false; } @@ -3366,16 +7176,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxOp::EcdsaSecp256k1 &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxOp::EcdsaSecp256k1 &obj, Serializer &serializer) { serde::Serializable::serialize(obj.hashed_msg, serializer); serde::Serializable::serialize(obj.public_key_x, serializer); serde::Serializable::serialize(obj.public_key_y, serializer); @@ -3385,8 +7195,8 @@ void serde::Serializable::serialize(const P template <> template -Program::BlackBoxOp::EcdsaSecp256k1 serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxOp::EcdsaSecp256k1 obj; +Acir::BlackBoxOp::EcdsaSecp256k1 serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxOp::EcdsaSecp256k1 obj; obj.hashed_msg = serde::Deserializable::deserialize(deserializer); obj.public_key_x = serde::Deserializable::deserialize(deserializer); obj.public_key_y = serde::Deserializable::deserialize(deserializer); @@ -3395,7 +7205,7 @@ Program::BlackBoxOp::EcdsaSecp256k1 serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxOp::EcdsaSecp256r1 &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxOp::EcdsaSecp256r1 &obj, Serializer &serializer) { serde::Serializable::serialize(obj.hashed_msg, serializer); serde::Serializable::serialize(obj.public_key_x, serializer); serde::Serializable::serialize(obj.public_key_y, serializer); @@ -3435,8 +7245,8 @@ void serde::Serializable::serialize(const P template <> template -Program::BlackBoxOp::EcdsaSecp256r1 serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxOp::EcdsaSecp256r1 obj; +Acir::BlackBoxOp::EcdsaSecp256r1 serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxOp::EcdsaSecp256r1 obj; obj.hashed_msg = serde::Deserializable::deserialize(deserializer); obj.public_key_x = serde::Deserializable::deserialize(deserializer); obj.public_key_y = serde::Deserializable::deserialize(deserializer); @@ -3445,7 +7255,7 @@ Program::BlackBoxOp::EcdsaSecp256r1 serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxOp::MultiScalarMul &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxOp::MultiScalarMul &obj, Serializer &serializer) { serde::Serializable::serialize(obj.points, serializer); serde::Serializable::serialize(obj.scalars, serializer); serde::Serializable::serialize(obj.outputs, serializer); @@ -3481,15 +7291,15 @@ void serde::Serializable::serialize(const P template <> template -Program::BlackBoxOp::MultiScalarMul serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxOp::MultiScalarMul obj; +Acir::BlackBoxOp::MultiScalarMul serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxOp::MultiScalarMul obj; obj.points = serde::Deserializable::deserialize(deserializer); obj.scalars = serde::Deserializable::deserialize(deserializer); obj.outputs = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxOp::EmbeddedCurveAdd &lhs, const BlackBoxOp::EmbeddedCurveAdd &rhs) { if (!(lhs.input1_x == rhs.input1_x)) { return false; } @@ -3512,16 +7322,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxOp::EmbeddedCurveAdd &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxOp::EmbeddedCurveAdd &obj, Serializer &serializer) { serde::Serializable::serialize(obj.input1_x, serializer); serde::Serializable::serialize(obj.input1_y, serializer); serde::Serializable::serialize(obj.input1_infinite, serializer); @@ -3533,8 +7343,8 @@ void serde::Serializable::serialize(const template <> template -Program::BlackBoxOp::EmbeddedCurveAdd serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxOp::EmbeddedCurveAdd obj; +Acir::BlackBoxOp::EmbeddedCurveAdd serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxOp::EmbeddedCurveAdd obj; obj.input1_x = serde::Deserializable::deserialize(deserializer); obj.input1_y = serde::Deserializable::deserialize(deserializer); obj.input1_infinite = serde::Deserializable::deserialize(deserializer); @@ -3545,7 +7355,7 @@ Program::BlackBoxOp::EmbeddedCurveAdd serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxOp::BigIntAdd &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxOp::BigIntAdd &obj, Serializer &serializer) { serde::Serializable::serialize(obj.lhs, serializer); serde::Serializable::serialize(obj.rhs, serializer); serde::Serializable::serialize(obj.output, serializer); @@ -3581,15 +7391,15 @@ void serde::Serializable::serialize(const Progra template <> template -Program::BlackBoxOp::BigIntAdd serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxOp::BigIntAdd obj; +Acir::BlackBoxOp::BigIntAdd serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxOp::BigIntAdd obj; obj.lhs = serde::Deserializable::deserialize(deserializer); obj.rhs = serde::Deserializable::deserialize(deserializer); obj.output = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxOp::BigIntSub &lhs, const BlackBoxOp::BigIntSub &rhs) { if (!(lhs.lhs == rhs.lhs)) { return false; } @@ -3608,16 +7418,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxOp::BigIntSub &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxOp::BigIntSub &obj, Serializer &serializer) { serde::Serializable::serialize(obj.lhs, serializer); serde::Serializable::serialize(obj.rhs, serializer); serde::Serializable::serialize(obj.output, serializer); @@ -3625,15 +7435,15 @@ void serde::Serializable::serialize(const Progra template <> template -Program::BlackBoxOp::BigIntSub serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxOp::BigIntSub obj; +Acir::BlackBoxOp::BigIntSub serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxOp::BigIntSub obj; obj.lhs = serde::Deserializable::deserialize(deserializer); obj.rhs = serde::Deserializable::deserialize(deserializer); obj.output = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxOp::BigIntMul &lhs, const BlackBoxOp::BigIntMul &rhs) { if (!(lhs.lhs == rhs.lhs)) { return false; } @@ -3652,16 +7462,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxOp::BigIntMul &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxOp::BigIntMul &obj, Serializer &serializer) { serde::Serializable::serialize(obj.lhs, serializer); serde::Serializable::serialize(obj.rhs, serializer); serde::Serializable::serialize(obj.output, serializer); @@ -3669,15 +7479,15 @@ void serde::Serializable::serialize(const Progra template <> template -Program::BlackBoxOp::BigIntMul serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxOp::BigIntMul obj; +Acir::BlackBoxOp::BigIntMul serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxOp::BigIntMul obj; obj.lhs = serde::Deserializable::deserialize(deserializer); obj.rhs = serde::Deserializable::deserialize(deserializer); obj.output = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxOp::BigIntDiv &lhs, const BlackBoxOp::BigIntDiv &rhs) { if (!(lhs.lhs == rhs.lhs)) { return false; } @@ -3696,16 +7506,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxOp::BigIntDiv &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxOp::BigIntDiv &obj, Serializer &serializer) { serde::Serializable::serialize(obj.lhs, serializer); serde::Serializable::serialize(obj.rhs, serializer); serde::Serializable::serialize(obj.output, serializer); @@ -3713,15 +7523,15 @@ void serde::Serializable::serialize(const Progra template <> template -Program::BlackBoxOp::BigIntDiv serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxOp::BigIntDiv obj; +Acir::BlackBoxOp::BigIntDiv serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxOp::BigIntDiv obj; obj.lhs = serde::Deserializable::deserialize(deserializer); obj.rhs = serde::Deserializable::deserialize(deserializer); obj.output = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxOp::BigIntFromLeBytes &lhs, const BlackBoxOp::BigIntFromLeBytes &rhs) { if (!(lhs.inputs == rhs.inputs)) { return false; } @@ -3740,16 +7550,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxOp::BigIntFromLeBytes &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxOp::BigIntFromLeBytes &obj, Serializer &serializer) { serde::Serializable::serialize(obj.inputs, serializer); serde::Serializable::serialize(obj.modulus, serializer); serde::Serializable::serialize(obj.output, serializer); @@ -3757,15 +7567,15 @@ void serde::Serializable::serialize(cons template <> template -Program::BlackBoxOp::BigIntFromLeBytes serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxOp::BigIntFromLeBytes obj; +Acir::BlackBoxOp::BigIntFromLeBytes serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxOp::BigIntFromLeBytes obj; obj.inputs = serde::Deserializable::deserialize(deserializer); obj.modulus = serde::Deserializable::deserialize(deserializer); obj.output = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxOp::BigIntToLeBytes &lhs, const BlackBoxOp::BigIntToLeBytes &rhs) { if (!(lhs.input == rhs.input)) { return false; } @@ -3783,30 +7593,30 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxOp::BigIntToLeBytes &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxOp::BigIntToLeBytes &obj, Serializer &serializer) { serde::Serializable::serialize(obj.input, serializer); serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::BigIntToLeBytes serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxOp::BigIntToLeBytes obj; +Acir::BlackBoxOp::BigIntToLeBytes serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxOp::BigIntToLeBytes obj; obj.input = serde::Deserializable::deserialize(deserializer); obj.output = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxOp::Poseidon2Permutation &lhs, const BlackBoxOp::Poseidon2Permutation &rhs) { if (!(lhs.message == rhs.message)) { return false; } @@ -3825,16 +7635,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxOp::Poseidon2Permutation &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxOp::Poseidon2Permutation &obj, Serializer &serializer) { serde::Serializable::serialize(obj.message, serializer); serde::Serializable::serialize(obj.output, serializer); serde::Serializable::serialize(obj.len, serializer); @@ -3842,15 +7652,15 @@ void serde::Serializable::serialize(c template <> template -Program::BlackBoxOp::Poseidon2Permutation serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxOp::Poseidon2Permutation obj; +Acir::BlackBoxOp::Poseidon2Permutation serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxOp::Poseidon2Permutation obj; obj.message = serde::Deserializable::deserialize(deserializer); obj.output = serde::Deserializable::deserialize(deserializer); obj.len = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxOp::Sha256Compression &lhs, const BlackBoxOp::Sha256Compression &rhs) { if (!(lhs.input == rhs.input)) { return false; } @@ -3869,16 +7679,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxOp::Sha256Compression &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxOp::Sha256Compression &obj, Serializer &serializer) { serde::Serializable::serialize(obj.input, serializer); serde::Serializable::serialize(obj.hash_values, serializer); serde::Serializable::serialize(obj.output, serializer); @@ -3886,15 +7696,15 @@ void serde::Serializable::serialize(cons template <> template -Program::BlackBoxOp::Sha256Compression serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxOp::Sha256Compression obj; +Acir::BlackBoxOp::Sha256Compression serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxOp::Sha256Compression obj; obj.input = serde::Deserializable::deserialize(deserializer); obj.hash_values = serde::Deserializable::deserialize(deserializer); obj.output = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlackBoxOp::ToRadix &lhs, const BlackBoxOp::ToRadix &rhs) { if (!(lhs.input == rhs.input)) { return false; } @@ -3915,16 +7725,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlackBoxOp::ToRadix &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlackBoxOp::ToRadix &obj, Serializer &serializer) { serde::Serializable::serialize(obj.input, serializer); serde::Serializable::serialize(obj.radix, serializer); serde::Serializable::serialize(obj.output_pointer, serializer); @@ -3934,8 +7744,8 @@ void serde::Serializable::serialize(const Program: template <> template -Program::BlackBoxOp::ToRadix serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlackBoxOp::ToRadix obj; +Acir::BlackBoxOp::ToRadix serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlackBoxOp::ToRadix obj; obj.input = serde::Deserializable::deserialize(deserializer); obj.radix = serde::Deserializable::deserialize(deserializer); obj.output_pointer = serde::Deserializable::deserialize(deserializer); @@ -3944,7 +7754,7 @@ Program::BlackBoxOp::ToRadix serde::Deserializable return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlockId &lhs, const BlockId &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -3961,16 +7771,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlockId &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlockId &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -3978,15 +7788,15 @@ void serde::Serializable::serialize(const Program::BlockId &ob template <> template -Program::BlockId serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::BlockId serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::BlockId obj; + Acir::BlockId obj; obj.value = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlockType &lhs, const BlockType &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -4003,16 +7813,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlockType &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlockType &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -4020,15 +7830,15 @@ void serde::Serializable::serialize(const Program::BlockType template <> template -Program::BlockType serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::BlockType serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::BlockType obj; + Acir::BlockType obj; obj.value = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlockType::Memory &lhs, const BlockType::Memory &rhs) { return true; @@ -4044,26 +7854,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlockType::Memory &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlockType::Memory &obj, Serializer &serializer) { } template <> template -Program::BlockType::Memory serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlockType::Memory obj; +Acir::BlockType::Memory serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlockType::Memory obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlockType::CallData &lhs, const BlockType::CallData &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -4080,28 +7890,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlockType::CallData &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlockType::CallData &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::BlockType::CallData serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlockType::CallData obj; +Acir::BlockType::CallData serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlockType::CallData obj; obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BlockType::ReturnData &lhs, const BlockType::ReturnData &rhs) { return true; @@ -4117,26 +7927,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BlockType::ReturnData &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BlockType::ReturnData &obj, Serializer &serializer) { } template <> template -Program::BlockType::ReturnData serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BlockType::ReturnData obj; +Acir::BlockType::ReturnData serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BlockType::ReturnData obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligBytecode &lhs, const BrilligBytecode &rhs) { if (!(lhs.bytecode == rhs.bytecode)) { return false; } @@ -4153,16 +7963,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligBytecode &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligBytecode &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.bytecode, serializer); serializer.decrease_container_depth(); @@ -4170,15 +7980,15 @@ void serde::Serializable::serialize(const Program::Bri template <> template -Program::BrilligBytecode serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::BrilligBytecode serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::BrilligBytecode obj; + Acir::BrilligBytecode obj; obj.bytecode = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligInputs &lhs, const BrilligInputs &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -4195,16 +8005,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligInputs &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligInputs &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -4212,15 +8022,15 @@ void serde::Serializable::serialize(const Program::Brill template <> template -Program::BrilligInputs serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::BrilligInputs serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::BrilligInputs obj; + Acir::BrilligInputs obj; obj.value = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligInputs::Single &lhs, const BrilligInputs::Single &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -4237,28 +8047,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligInputs::Single &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligInputs::Single &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::BrilligInputs::Single serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligInputs::Single obj; +Acir::BrilligInputs::Single serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligInputs::Single obj; obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligInputs::Array &lhs, const BrilligInputs::Array &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -4275,28 +8085,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligInputs::Array &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligInputs::Array &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::BrilligInputs::Array serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligInputs::Array obj; +Acir::BrilligInputs::Array serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligInputs::Array obj; obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligInputs::MemoryArray &lhs, const BrilligInputs::MemoryArray &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -4313,28 +8123,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligInputs::MemoryArray &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligInputs::MemoryArray &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::BrilligInputs::MemoryArray serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligInputs::MemoryArray obj; +Acir::BrilligInputs::MemoryArray serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligInputs::MemoryArray obj; obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligOpcode &lhs, const BrilligOpcode &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -4351,16 +8161,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOpcode &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOpcode &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -4368,15 +8178,15 @@ void serde::Serializable::serialize(const Program::Brill template <> template -Program::BrilligOpcode serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::BrilligOpcode serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::BrilligOpcode obj; + Acir::BrilligOpcode obj; obj.value = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligOpcode::BinaryFieldOp &lhs, const BrilligOpcode::BinaryFieldOp &rhs) { if (!(lhs.destination == rhs.destination)) { return false; } @@ -4396,16 +8206,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOpcode::BinaryFieldOp &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOpcode::BinaryFieldOp &obj, Serializer &serializer) { serde::Serializable::serialize(obj.destination, serializer); serde::Serializable::serialize(obj.op, serializer); serde::Serializable::serialize(obj.lhs, serializer); @@ -4414,8 +8224,8 @@ void serde::Serializable::serialize(const template <> template -Program::BrilligOpcode::BinaryFieldOp serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligOpcode::BinaryFieldOp obj; +Acir::BrilligOpcode::BinaryFieldOp serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligOpcode::BinaryFieldOp obj; obj.destination = serde::Deserializable::deserialize(deserializer); obj.op = serde::Deserializable::deserialize(deserializer); obj.lhs = serde::Deserializable::deserialize(deserializer); @@ -4423,7 +8233,7 @@ Program::BrilligOpcode::BinaryFieldOp serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOpcode::BinaryIntOp &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOpcode::BinaryIntOp &obj, Serializer &serializer) { serde::Serializable::serialize(obj.destination, serializer); serde::Serializable::serialize(obj.op, serializer); serde::Serializable::serialize(obj.bit_size, serializer); @@ -4463,8 +8273,8 @@ void serde::Serializable::serialize(const P template <> template -Program::BrilligOpcode::BinaryIntOp serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligOpcode::BinaryIntOp obj; +Acir::BrilligOpcode::BinaryIntOp serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligOpcode::BinaryIntOp obj; obj.destination = serde::Deserializable::deserialize(deserializer); obj.op = serde::Deserializable::deserialize(deserializer); obj.bit_size = serde::Deserializable::deserialize(deserializer); @@ -4473,7 +8283,7 @@ Program::BrilligOpcode::BinaryIntOp serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOpcode::Not &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOpcode::Not &obj, Serializer &serializer) { serde::Serializable::serialize(obj.destination, serializer); serde::Serializable::serialize(obj.source, serializer); serde::Serializable::serialize(obj.bit_size, serializer); @@ -4509,15 +8319,15 @@ void serde::Serializable::serialize(const Program:: template <> template -Program::BrilligOpcode::Not serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligOpcode::Not obj; +Acir::BrilligOpcode::Not serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligOpcode::Not obj; obj.destination = serde::Deserializable::deserialize(deserializer); obj.source = serde::Deserializable::deserialize(deserializer); obj.bit_size = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligOpcode::Cast &lhs, const BrilligOpcode::Cast &rhs) { if (!(lhs.destination == rhs.destination)) { return false; } @@ -4536,16 +8346,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOpcode::Cast &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOpcode::Cast &obj, Serializer &serializer) { serde::Serializable::serialize(obj.destination, serializer); serde::Serializable::serialize(obj.source, serializer); serde::Serializable::serialize(obj.bit_size, serializer); @@ -4553,15 +8363,15 @@ void serde::Serializable::serialize(const Program: template <> template -Program::BrilligOpcode::Cast serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligOpcode::Cast obj; +Acir::BrilligOpcode::Cast serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligOpcode::Cast obj; obj.destination = serde::Deserializable::deserialize(deserializer); obj.source = serde::Deserializable::deserialize(deserializer); obj.bit_size = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligOpcode::JumpIfNot &lhs, const BrilligOpcode::JumpIfNot &rhs) { if (!(lhs.condition == rhs.condition)) { return false; } @@ -4579,30 +8389,30 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOpcode::JumpIfNot &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOpcode::JumpIfNot &obj, Serializer &serializer) { serde::Serializable::serialize(obj.condition, serializer); serde::Serializable::serialize(obj.location, serializer); } template <> template -Program::BrilligOpcode::JumpIfNot serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligOpcode::JumpIfNot obj; +Acir::BrilligOpcode::JumpIfNot serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligOpcode::JumpIfNot obj; obj.condition = serde::Deserializable::deserialize(deserializer); obj.location = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligOpcode::JumpIf &lhs, const BrilligOpcode::JumpIf &rhs) { if (!(lhs.condition == rhs.condition)) { return false; } @@ -4620,30 +8430,30 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOpcode::JumpIf &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOpcode::JumpIf &obj, Serializer &serializer) { serde::Serializable::serialize(obj.condition, serializer); serde::Serializable::serialize(obj.location, serializer); } template <> template -Program::BrilligOpcode::JumpIf serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligOpcode::JumpIf obj; +Acir::BrilligOpcode::JumpIf serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligOpcode::JumpIf obj; obj.condition = serde::Deserializable::deserialize(deserializer); obj.location = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligOpcode::Jump &lhs, const BrilligOpcode::Jump &rhs) { if (!(lhs.location == rhs.location)) { return false; } @@ -4660,28 +8470,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOpcode::Jump &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOpcode::Jump &obj, Serializer &serializer) { serde::Serializable::serialize(obj.location, serializer); } template <> template -Program::BrilligOpcode::Jump serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligOpcode::Jump obj; +Acir::BrilligOpcode::Jump serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligOpcode::Jump obj; obj.location = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligOpcode::CalldataCopy &lhs, const BrilligOpcode::CalldataCopy &rhs) { if (!(lhs.destination_address == rhs.destination_address)) { return false; } @@ -4700,16 +8510,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOpcode::CalldataCopy &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOpcode::CalldataCopy &obj, Serializer &serializer) { serde::Serializable::serialize(obj.destination_address, serializer); serde::Serializable::serialize(obj.size_address, serializer); serde::Serializable::serialize(obj.offset_address, serializer); @@ -4717,15 +8527,15 @@ void serde::Serializable::serialize(const template <> template -Program::BrilligOpcode::CalldataCopy serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligOpcode::CalldataCopy obj; +Acir::BrilligOpcode::CalldataCopy serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligOpcode::CalldataCopy obj; obj.destination_address = serde::Deserializable::deserialize(deserializer); obj.size_address = serde::Deserializable::deserialize(deserializer); obj.offset_address = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligOpcode::Call &lhs, const BrilligOpcode::Call &rhs) { if (!(lhs.location == rhs.location)) { return false; } @@ -4742,28 +8552,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOpcode::Call &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOpcode::Call &obj, Serializer &serializer) { serde::Serializable::serialize(obj.location, serializer); } template <> template -Program::BrilligOpcode::Call serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligOpcode::Call obj; +Acir::BrilligOpcode::Call serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligOpcode::Call obj; obj.location = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligOpcode::Const &lhs, const BrilligOpcode::Const &rhs) { if (!(lhs.destination == rhs.destination)) { return false; } @@ -4782,16 +8592,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOpcode::Const &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOpcode::Const &obj, Serializer &serializer) { serde::Serializable::serialize(obj.destination, serializer); serde::Serializable::serialize(obj.bit_size, serializer); serde::Serializable::serialize(obj.value, serializer); @@ -4799,15 +8609,15 @@ void serde::Serializable::serialize(const Program template <> template -Program::BrilligOpcode::Const serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligOpcode::Const obj; +Acir::BrilligOpcode::Const serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligOpcode::Const obj; obj.destination = serde::Deserializable::deserialize(deserializer); obj.bit_size = serde::Deserializable::deserialize(deserializer); obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligOpcode::IndirectConst &lhs, const BrilligOpcode::IndirectConst &rhs) { if (!(lhs.destination_pointer == rhs.destination_pointer)) { return false; } @@ -4826,16 +8636,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOpcode::IndirectConst &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOpcode::IndirectConst &obj, Serializer &serializer) { serde::Serializable::serialize(obj.destination_pointer, serializer); serde::Serializable::serialize(obj.bit_size, serializer); serde::Serializable::serialize(obj.value, serializer); @@ -4843,15 +8653,15 @@ void serde::Serializable::serialize(const template <> template -Program::BrilligOpcode::IndirectConst serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligOpcode::IndirectConst obj; +Acir::BrilligOpcode::IndirectConst serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligOpcode::IndirectConst obj; obj.destination_pointer = serde::Deserializable::deserialize(deserializer); obj.bit_size = serde::Deserializable::deserialize(deserializer); obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligOpcode::Return &lhs, const BrilligOpcode::Return &rhs) { return true; @@ -4867,26 +8677,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOpcode::Return &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOpcode::Return &obj, Serializer &serializer) { } template <> template -Program::BrilligOpcode::Return serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligOpcode::Return obj; +Acir::BrilligOpcode::Return serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligOpcode::Return obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligOpcode::ForeignCall &lhs, const BrilligOpcode::ForeignCall &rhs) { if (!(lhs.function == rhs.function)) { return false; } @@ -4907,16 +8717,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOpcode::ForeignCall &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOpcode::ForeignCall &obj, Serializer &serializer) { serde::Serializable::serialize(obj.function, serializer); serde::Serializable::serialize(obj.destinations, serializer); serde::Serializable::serialize(obj.destination_value_types, serializer); @@ -4926,8 +8736,8 @@ void serde::Serializable::serialize(const P template <> template -Program::BrilligOpcode::ForeignCall serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligOpcode::ForeignCall obj; +Acir::BrilligOpcode::ForeignCall serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligOpcode::ForeignCall obj; obj.function = serde::Deserializable::deserialize(deserializer); obj.destinations = serde::Deserializable::deserialize(deserializer); obj.destination_value_types = serde::Deserializable::deserialize(deserializer); @@ -4936,7 +8746,7 @@ Program::BrilligOpcode::ForeignCall serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOpcode::Mov &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOpcode::Mov &obj, Serializer &serializer) { serde::Serializable::serialize(obj.destination, serializer); serde::Serializable::serialize(obj.source, serializer); } template <> template -Program::BrilligOpcode::Mov serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligOpcode::Mov obj; +Acir::BrilligOpcode::Mov serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligOpcode::Mov obj; obj.destination = serde::Deserializable::deserialize(deserializer); obj.source = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligOpcode::ConditionalMov &lhs, const BrilligOpcode::ConditionalMov &rhs) { if (!(lhs.destination == rhs.destination)) { return false; } @@ -4997,16 +8807,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOpcode::ConditionalMov &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOpcode::ConditionalMov &obj, Serializer &serializer) { serde::Serializable::serialize(obj.destination, serializer); serde::Serializable::serialize(obj.source_a, serializer); serde::Serializable::serialize(obj.source_b, serializer); @@ -5015,8 +8825,8 @@ void serde::Serializable::serialize(cons template <> template -Program::BrilligOpcode::ConditionalMov serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligOpcode::ConditionalMov obj; +Acir::BrilligOpcode::ConditionalMov serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligOpcode::ConditionalMov obj; obj.destination = serde::Deserializable::deserialize(deserializer); obj.source_a = serde::Deserializable::deserialize(deserializer); obj.source_b = serde::Deserializable::deserialize(deserializer); @@ -5024,7 +8834,7 @@ Program::BrilligOpcode::ConditionalMov serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOpcode::Load &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOpcode::Load &obj, Serializer &serializer) { serde::Serializable::serialize(obj.destination, serializer); serde::Serializable::serialize(obj.source_pointer, serializer); } template <> template -Program::BrilligOpcode::Load serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligOpcode::Load obj; +Acir::BrilligOpcode::Load serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligOpcode::Load obj; obj.destination = serde::Deserializable::deserialize(deserializer); obj.source_pointer = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligOpcode::Store &lhs, const BrilligOpcode::Store &rhs) { if (!(lhs.destination_pointer == rhs.destination_pointer)) { return false; } @@ -5083,30 +8893,30 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOpcode::Store &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOpcode::Store &obj, Serializer &serializer) { serde::Serializable::serialize(obj.destination_pointer, serializer); serde::Serializable::serialize(obj.source, serializer); } template <> template -Program::BrilligOpcode::Store serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligOpcode::Store obj; +Acir::BrilligOpcode::Store serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligOpcode::Store obj; obj.destination_pointer = serde::Deserializable::deserialize(deserializer); obj.source = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligOpcode::BlackBox &lhs, const BrilligOpcode::BlackBox &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -5123,28 +8933,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOpcode::BlackBox &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOpcode::BlackBox &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::BrilligOpcode::BlackBox serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligOpcode::BlackBox obj; +Acir::BrilligOpcode::BlackBox serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligOpcode::BlackBox obj; obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligOpcode::Trap &lhs, const BrilligOpcode::Trap &rhs) { if (!(lhs.revert_data == rhs.revert_data)) { return false; } @@ -5161,28 +8971,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOpcode::Trap &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOpcode::Trap &obj, Serializer &serializer) { serde::Serializable::serialize(obj.revert_data, serializer); } template <> template -Program::BrilligOpcode::Trap serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligOpcode::Trap obj; +Acir::BrilligOpcode::Trap serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligOpcode::Trap obj; obj.revert_data = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligOpcode::Stop &lhs, const BrilligOpcode::Stop &rhs) { if (!(lhs.return_data == rhs.return_data)) { return false; } @@ -5199,28 +9009,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOpcode::Stop &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOpcode::Stop &obj, Serializer &serializer) { serde::Serializable::serialize(obj.return_data, serializer); } template <> template -Program::BrilligOpcode::Stop serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligOpcode::Stop obj; +Acir::BrilligOpcode::Stop serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligOpcode::Stop obj; obj.return_data = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligOutputs &lhs, const BrilligOutputs &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -5237,16 +9047,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOutputs &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOutputs &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -5254,15 +9064,15 @@ void serde::Serializable::serialize(const Program::Bril template <> template -Program::BrilligOutputs serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::BrilligOutputs serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::BrilligOutputs obj; + Acir::BrilligOutputs obj; obj.value = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligOutputs::Simple &lhs, const BrilligOutputs::Simple &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -5279,28 +9089,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOutputs::Simple &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOutputs::Simple &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::BrilligOutputs::Simple serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligOutputs::Simple obj; +Acir::BrilligOutputs::Simple serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligOutputs::Simple obj; obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const BrilligOutputs::Array &lhs, const BrilligOutputs::Array &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -5317,28 +9127,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::BrilligOutputs::Array &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::BrilligOutputs::Array &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::BrilligOutputs::Array serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::BrilligOutputs::Array obj; +Acir::BrilligOutputs::Array serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::BrilligOutputs::Array obj; obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const Circuit &lhs, const Circuit &rhs) { if (!(lhs.current_witness_index == rhs.current_witness_index)) { return false; } @@ -5361,16 +9171,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::Circuit &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::Circuit &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.current_witness_index, serializer); serde::Serializable::serialize(obj.opcodes, serializer); @@ -5384,9 +9194,9 @@ void serde::Serializable::serialize(const Program::Circuit &ob template <> template -Program::Circuit serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::Circuit serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::Circuit obj; + Acir::Circuit obj; obj.current_witness_index = serde::Deserializable::deserialize(deserializer); obj.opcodes = serde::Deserializable::deserialize(deserializer); obj.expression_width = serde::Deserializable::deserialize(deserializer); @@ -5398,7 +9208,7 @@ Program::Circuit serde::Deserializable::deserialize(Deserializ return obj; } -namespace Program { +namespace Acir { inline bool operator==(const ConstantOrWitnessEnum &lhs, const ConstantOrWitnessEnum &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -5415,16 +9225,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::ConstantOrWitnessEnum &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::ConstantOrWitnessEnum &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -5432,15 +9242,15 @@ void serde::Serializable::serialize(const Progra template <> template -Program::ConstantOrWitnessEnum serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::ConstantOrWitnessEnum serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::ConstantOrWitnessEnum obj; + Acir::ConstantOrWitnessEnum obj; obj.value = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const ConstantOrWitnessEnum::Constant &lhs, const ConstantOrWitnessEnum::Constant &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -5457,28 +9267,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::ConstantOrWitnessEnum::Constant &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::ConstantOrWitnessEnum::Constant &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::ConstantOrWitnessEnum::Constant serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::ConstantOrWitnessEnum::Constant obj; +Acir::ConstantOrWitnessEnum::Constant serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::ConstantOrWitnessEnum::Constant obj; obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const ConstantOrWitnessEnum::Witness &lhs, const ConstantOrWitnessEnum::Witness &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -5495,28 +9305,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::ConstantOrWitnessEnum::Witness &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::ConstantOrWitnessEnum::Witness &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::ConstantOrWitnessEnum::Witness serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::ConstantOrWitnessEnum::Witness obj; +Acir::ConstantOrWitnessEnum::Witness serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::ConstantOrWitnessEnum::Witness obj; obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const Expression &lhs, const Expression &rhs) { if (!(lhs.mul_terms == rhs.mul_terms)) { return false; } @@ -5535,16 +9345,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::Expression &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::Expression &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.mul_terms, serializer); serde::Serializable::serialize(obj.linear_combinations, serializer); @@ -5554,9 +9364,9 @@ void serde::Serializable::serialize(const Program::Expressi template <> template -Program::Expression serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::Expression serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::Expression obj; + Acir::Expression obj; obj.mul_terms = serde::Deserializable::deserialize(deserializer); obj.linear_combinations = serde::Deserializable::deserialize(deserializer); obj.q_c = serde::Deserializable::deserialize(deserializer); @@ -5564,7 +9374,7 @@ Program::Expression serde::Deserializable::deserialize(Dese return obj; } -namespace Program { +namespace Acir { inline bool operator==(const ExpressionOrMemory &lhs, const ExpressionOrMemory &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -5581,16 +9391,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::ExpressionOrMemory &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::ExpressionOrMemory &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -5598,15 +9408,15 @@ void serde::Serializable::serialize(const Program:: template <> template -Program::ExpressionOrMemory serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::ExpressionOrMemory serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::ExpressionOrMemory obj; + Acir::ExpressionOrMemory obj; obj.value = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const ExpressionOrMemory::Expression &lhs, const ExpressionOrMemory::Expression &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -5623,28 +9433,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::ExpressionOrMemory::Expression &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::ExpressionOrMemory::Expression &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::ExpressionOrMemory::Expression serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::ExpressionOrMemory::Expression obj; +Acir::ExpressionOrMemory::Expression serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::ExpressionOrMemory::Expression obj; obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const ExpressionOrMemory::Memory &lhs, const ExpressionOrMemory::Memory &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -5661,28 +9471,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::ExpressionOrMemory::Memory &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::ExpressionOrMemory::Memory &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::ExpressionOrMemory::Memory serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::ExpressionOrMemory::Memory obj; +Acir::ExpressionOrMemory::Memory serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::ExpressionOrMemory::Memory obj; obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const ExpressionWidth &lhs, const ExpressionWidth &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -5699,16 +9509,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::ExpressionWidth &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::ExpressionWidth &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -5716,15 +9526,15 @@ void serde::Serializable::serialize(const Program::Exp template <> template -Program::ExpressionWidth serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::ExpressionWidth serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::ExpressionWidth obj; + Acir::ExpressionWidth obj; obj.value = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const ExpressionWidth::Unbounded &lhs, const ExpressionWidth::Unbounded &rhs) { return true; @@ -5740,26 +9550,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::ExpressionWidth::Unbounded &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::ExpressionWidth::Unbounded &obj, Serializer &serializer) { } template <> template -Program::ExpressionWidth::Unbounded serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::ExpressionWidth::Unbounded obj; +Acir::ExpressionWidth::Unbounded serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::ExpressionWidth::Unbounded obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const ExpressionWidth::Bounded &lhs, const ExpressionWidth::Bounded &rhs) { if (!(lhs.width == rhs.width)) { return false; } @@ -5776,28 +9586,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::ExpressionWidth::Bounded &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::ExpressionWidth::Bounded &obj, Serializer &serializer) { serde::Serializable::serialize(obj.width, serializer); } template <> template -Program::ExpressionWidth::Bounded serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::ExpressionWidth::Bounded obj; +Acir::ExpressionWidth::Bounded serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::ExpressionWidth::Bounded obj; obj.width = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const FunctionInput &lhs, const FunctionInput &rhs) { if (!(lhs.input == rhs.input)) { return false; } @@ -5815,16 +9625,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::FunctionInput &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::FunctionInput &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.input, serializer); serde::Serializable::serialize(obj.num_bits, serializer); @@ -5833,16 +9643,16 @@ void serde::Serializable::serialize(const Program::Funct template <> template -Program::FunctionInput serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::FunctionInput serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::FunctionInput obj; + Acir::FunctionInput obj; obj.input = serde::Deserializable::deserialize(deserializer); obj.num_bits = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const HeapArray &lhs, const HeapArray &rhs) { if (!(lhs.pointer == rhs.pointer)) { return false; } @@ -5860,16 +9670,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::HeapArray &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::HeapArray &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.pointer, serializer); serde::Serializable::serialize(obj.size, serializer); @@ -5878,16 +9688,16 @@ void serde::Serializable::serialize(const Program::HeapArray template <> template -Program::HeapArray serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::HeapArray serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::HeapArray obj; + Acir::HeapArray obj; obj.pointer = serde::Deserializable::deserialize(deserializer); obj.size = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const HeapValueType &lhs, const HeapValueType &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -5904,16 +9714,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::HeapValueType &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::HeapValueType &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -5921,15 +9731,15 @@ void serde::Serializable::serialize(const Program::HeapV template <> template -Program::HeapValueType serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::HeapValueType serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::HeapValueType obj; + Acir::HeapValueType obj; obj.value = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const HeapValueType::Simple &lhs, const HeapValueType::Simple &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -5946,28 +9756,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::HeapValueType::Simple &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::HeapValueType::Simple &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::HeapValueType::Simple serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::HeapValueType::Simple obj; +Acir::HeapValueType::Simple serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::HeapValueType::Simple obj; obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const HeapValueType::Array &lhs, const HeapValueType::Array &rhs) { if (!(lhs.value_types == rhs.value_types)) { return false; } @@ -5985,30 +9795,30 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::HeapValueType::Array &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::HeapValueType::Array &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value_types, serializer); serde::Serializable::serialize(obj.size, serializer); } template <> template -Program::HeapValueType::Array serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::HeapValueType::Array obj; +Acir::HeapValueType::Array serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::HeapValueType::Array obj; obj.value_types = serde::Deserializable::deserialize(deserializer); obj.size = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const HeapValueType::Vector &lhs, const HeapValueType::Vector &rhs) { if (!(lhs.value_types == rhs.value_types)) { return false; } @@ -6025,28 +9835,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::HeapValueType::Vector &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::HeapValueType::Vector &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value_types, serializer); } template <> template -Program::HeapValueType::Vector serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::HeapValueType::Vector obj; +Acir::HeapValueType::Vector serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::HeapValueType::Vector obj; obj.value_types = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const HeapVector &lhs, const HeapVector &rhs) { if (!(lhs.pointer == rhs.pointer)) { return false; } @@ -6064,16 +9874,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::HeapVector &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::HeapVector &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.pointer, serializer); serde::Serializable::serialize(obj.size, serializer); @@ -6082,16 +9892,16 @@ void serde::Serializable::serialize(const Program::HeapVect template <> template -Program::HeapVector serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::HeapVector serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::HeapVector obj; + Acir::HeapVector obj; obj.pointer = serde::Deserializable::deserialize(deserializer); obj.size = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const IntegerBitSize &lhs, const IntegerBitSize &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -6108,16 +9918,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::IntegerBitSize &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::IntegerBitSize &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -6125,15 +9935,15 @@ void serde::Serializable::serialize(const Program::Inte template <> template -Program::IntegerBitSize serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::IntegerBitSize serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::IntegerBitSize obj; + Acir::IntegerBitSize obj; obj.value = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const IntegerBitSize::U1 &lhs, const IntegerBitSize::U1 &rhs) { return true; @@ -6149,26 +9959,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::IntegerBitSize::U1 &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::IntegerBitSize::U1 &obj, Serializer &serializer) { } template <> template -Program::IntegerBitSize::U1 serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::IntegerBitSize::U1 obj; +Acir::IntegerBitSize::U1 serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::IntegerBitSize::U1 obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const IntegerBitSize::U8 &lhs, const IntegerBitSize::U8 &rhs) { return true; @@ -6184,26 +9994,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::IntegerBitSize::U8 &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::IntegerBitSize::U8 &obj, Serializer &serializer) { } template <> template -Program::IntegerBitSize::U8 serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::IntegerBitSize::U8 obj; +Acir::IntegerBitSize::U8 serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::IntegerBitSize::U8 obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const IntegerBitSize::U16 &lhs, const IntegerBitSize::U16 &rhs) { return true; @@ -6219,26 +10029,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::IntegerBitSize::U16 &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::IntegerBitSize::U16 &obj, Serializer &serializer) { } template <> template -Program::IntegerBitSize::U16 serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::IntegerBitSize::U16 obj; +Acir::IntegerBitSize::U16 serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::IntegerBitSize::U16 obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const IntegerBitSize::U32 &lhs, const IntegerBitSize::U32 &rhs) { return true; @@ -6254,26 +10064,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::IntegerBitSize::U32 &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::IntegerBitSize::U32 &obj, Serializer &serializer) { } template <> template -Program::IntegerBitSize::U32 serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::IntegerBitSize::U32 obj; +Acir::IntegerBitSize::U32 serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::IntegerBitSize::U32 obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const IntegerBitSize::U64 &lhs, const IntegerBitSize::U64 &rhs) { return true; @@ -6289,26 +10099,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::IntegerBitSize::U64 &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::IntegerBitSize::U64 &obj, Serializer &serializer) { } template <> template -Program::IntegerBitSize::U64 serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::IntegerBitSize::U64 obj; +Acir::IntegerBitSize::U64 serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::IntegerBitSize::U64 obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const IntegerBitSize::U128 &lhs, const IntegerBitSize::U128 &rhs) { return true; @@ -6324,26 +10134,26 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::IntegerBitSize::U128 &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::IntegerBitSize::U128 &obj, Serializer &serializer) { } template <> template -Program::IntegerBitSize::U128 serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::IntegerBitSize::U128 obj; +Acir::IntegerBitSize::U128 serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::IntegerBitSize::U128 obj; return obj; } -namespace Program { +namespace Acir { inline bool operator==(const MemOp &lhs, const MemOp &rhs) { if (!(lhs.operation == rhs.operation)) { return false; } @@ -6362,16 +10172,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::MemOp &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::MemOp &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.operation, serializer); serde::Serializable::serialize(obj.index, serializer); @@ -6381,9 +10191,9 @@ void serde::Serializable::serialize(const Program::MemOp &obj, S template <> template -Program::MemOp serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::MemOp serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::MemOp obj; + Acir::MemOp obj; obj.operation = serde::Deserializable::deserialize(deserializer); obj.index = serde::Deserializable::deserialize(deserializer); obj.value = serde::Deserializable::deserialize(deserializer); @@ -6391,7 +10201,7 @@ Program::MemOp serde::Deserializable::deserialize(Deserializer & return obj; } -namespace Program { +namespace Acir { inline bool operator==(const MemoryAddress &lhs, const MemoryAddress &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -6408,16 +10218,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::MemoryAddress &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::MemoryAddress &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -6425,15 +10235,15 @@ void serde::Serializable::serialize(const Program::Memor template <> template -Program::MemoryAddress serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::MemoryAddress serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::MemoryAddress obj; + Acir::MemoryAddress obj; obj.value = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const MemoryAddress::Direct &lhs, const MemoryAddress::Direct &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -6450,28 +10260,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::MemoryAddress::Direct &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::MemoryAddress::Direct &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::MemoryAddress::Direct serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::MemoryAddress::Direct obj; +Acir::MemoryAddress::Direct serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::MemoryAddress::Direct obj; obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const MemoryAddress::Relative &lhs, const MemoryAddress::Relative &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -6488,28 +10298,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::MemoryAddress::Relative &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::MemoryAddress::Relative &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::MemoryAddress::Relative serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::MemoryAddress::Relative obj; +Acir::MemoryAddress::Relative serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::MemoryAddress::Relative obj; obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const Opcode &lhs, const Opcode &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -6526,16 +10336,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::Opcode &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::Opcode &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -6543,15 +10353,15 @@ void serde::Serializable::serialize(const Program::Opcode &obj, template <> template -Program::Opcode serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::Opcode serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::Opcode obj; + Acir::Opcode obj; obj.value = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const Opcode::AssertZero &lhs, const Opcode::AssertZero &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -6568,28 +10378,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::Opcode::AssertZero &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::Opcode::AssertZero &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::Opcode::AssertZero serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::Opcode::AssertZero obj; +Acir::Opcode::AssertZero serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::Opcode::AssertZero obj; obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const Opcode::BlackBoxFuncCall &lhs, const Opcode::BlackBoxFuncCall &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -6606,28 +10416,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::Opcode::BlackBoxFuncCall &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::Opcode::BlackBoxFuncCall &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::Opcode::BlackBoxFuncCall serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::Opcode::BlackBoxFuncCall obj; +Acir::Opcode::BlackBoxFuncCall serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::Opcode::BlackBoxFuncCall obj; obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const Opcode::MemoryOp &lhs, const Opcode::MemoryOp &rhs) { if (!(lhs.block_id == rhs.block_id)) { return false; } @@ -6646,16 +10456,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::Opcode::MemoryOp &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::Opcode::MemoryOp &obj, Serializer &serializer) { serde::Serializable::serialize(obj.block_id, serializer); serde::Serializable::serialize(obj.op, serializer); serde::Serializable::serialize(obj.predicate, serializer); @@ -6663,15 +10473,15 @@ void serde::Serializable::serialize(const Program::Op template <> template -Program::Opcode::MemoryOp serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::Opcode::MemoryOp obj; +Acir::Opcode::MemoryOp serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::Opcode::MemoryOp obj; obj.block_id = serde::Deserializable::deserialize(deserializer); obj.op = serde::Deserializable::deserialize(deserializer); obj.predicate = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const Opcode::MemoryInit &lhs, const Opcode::MemoryInit &rhs) { if (!(lhs.block_id == rhs.block_id)) { return false; } @@ -6690,16 +10500,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::Opcode::MemoryInit &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::Opcode::MemoryInit &obj, Serializer &serializer) { serde::Serializable::serialize(obj.block_id, serializer); serde::Serializable::serialize(obj.init, serializer); serde::Serializable::serialize(obj.block_type, serializer); @@ -6707,15 +10517,15 @@ void serde::Serializable::serialize(const Program:: template <> template -Program::Opcode::MemoryInit serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::Opcode::MemoryInit obj; +Acir::Opcode::MemoryInit serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::Opcode::MemoryInit obj; obj.block_id = serde::Deserializable::deserialize(deserializer); obj.init = serde::Deserializable::deserialize(deserializer); obj.block_type = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const Opcode::BrilligCall &lhs, const Opcode::BrilligCall &rhs) { if (!(lhs.id == rhs.id)) { return false; } @@ -6735,16 +10545,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::Opcode::BrilligCall &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::Opcode::BrilligCall &obj, Serializer &serializer) { serde::Serializable::serialize(obj.id, serializer); serde::Serializable::serialize(obj.inputs, serializer); serde::Serializable::serialize(obj.outputs, serializer); @@ -6753,8 +10563,8 @@ void serde::Serializable::serialize(const Program: template <> template -Program::Opcode::BrilligCall serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::Opcode::BrilligCall obj; +Acir::Opcode::BrilligCall serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::Opcode::BrilligCall obj; obj.id = serde::Deserializable::deserialize(deserializer); obj.inputs = serde::Deserializable::deserialize(deserializer); obj.outputs = serde::Deserializable::deserialize(deserializer); @@ -6762,7 +10572,7 @@ Program::Opcode::BrilligCall serde::Deserializable return obj; } -namespace Program { +namespace Acir { inline bool operator==(const Opcode::Call &lhs, const Opcode::Call &rhs) { if (!(lhs.id == rhs.id)) { return false; } @@ -6782,16 +10592,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::Opcode::Call &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::Opcode::Call &obj, Serializer &serializer) { serde::Serializable::serialize(obj.id, serializer); serde::Serializable::serialize(obj.inputs, serializer); serde::Serializable::serialize(obj.outputs, serializer); @@ -6800,8 +10610,8 @@ void serde::Serializable::serialize(const Program::Opcode template <> template -Program::Opcode::Call serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::Opcode::Call obj; +Acir::Opcode::Call serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::Opcode::Call obj; obj.id = serde::Deserializable::deserialize(deserializer); obj.inputs = serde::Deserializable::deserialize(deserializer); obj.outputs = serde::Deserializable::deserialize(deserializer); @@ -6809,7 +10619,7 @@ Program::Opcode::Call serde::Deserializable::deserialize( return obj; } -namespace Program { +namespace Acir { inline bool operator==(const OpcodeLocation &lhs, const OpcodeLocation &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -6826,16 +10636,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::OpcodeLocation &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::OpcodeLocation &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -6843,15 +10653,15 @@ void serde::Serializable::serialize(const Program::Opco template <> template -Program::OpcodeLocation serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::OpcodeLocation serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::OpcodeLocation obj; + Acir::OpcodeLocation obj; obj.value = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const OpcodeLocation::Acir &lhs, const OpcodeLocation::Acir &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -6868,28 +10678,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::OpcodeLocation::Acir &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::OpcodeLocation::Acir &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::OpcodeLocation::Acir serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::OpcodeLocation::Acir obj; +Acir::OpcodeLocation::Acir serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::OpcodeLocation::Acir obj; obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const OpcodeLocation::Brillig &lhs, const OpcodeLocation::Brillig &rhs) { if (!(lhs.acir_index == rhs.acir_index)) { return false; } @@ -6907,30 +10717,30 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::OpcodeLocation::Brillig &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::OpcodeLocation::Brillig &obj, Serializer &serializer) { serde::Serializable::serialize(obj.acir_index, serializer); serde::Serializable::serialize(obj.brillig_index, serializer); } template <> template -Program::OpcodeLocation::Brillig serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::OpcodeLocation::Brillig obj; +Acir::OpcodeLocation::Brillig serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::OpcodeLocation::Brillig obj; obj.acir_index = serde::Deserializable::deserialize(deserializer); obj.brillig_index = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const Program &lhs, const Program &rhs) { if (!(lhs.functions == rhs.functions)) { return false; } @@ -6948,16 +10758,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::Program &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::Program &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.functions, serializer); serde::Serializable::serialize(obj.unconstrained_functions, serializer); @@ -6966,16 +10776,58 @@ void serde::Serializable::serialize(const Program::Program &ob template <> template -Program::Program serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::Program serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::Program obj; + Acir::Program obj; obj.functions = serde::Deserializable::deserialize(deserializer); obj.unconstrained_functions = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { + + inline bool operator==(const ProgramWithoutBrillig &lhs, const ProgramWithoutBrillig &rhs) { + if (!(lhs.functions == rhs.functions)) { return false; } + return true; + } + + inline std::vector ProgramWithoutBrillig::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline ProgramWithoutBrillig ProgramWithoutBrillig::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::deserialize(deserializer); + if (deserializer.get_buffer_offset() < input.size()) { + throw_or_abort("Some input bytes were not read"); + } + return value; + } + +} // end of namespace Acir + +template <> +template +void serde::Serializable::serialize(const Acir::ProgramWithoutBrillig &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.functions, serializer); + serializer.decrease_container_depth(); +} + +template <> +template +Acir::ProgramWithoutBrillig serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Acir::ProgramWithoutBrillig obj; + obj.functions = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; +} + +namespace Acir { inline bool operator==(const PublicInputs &lhs, const PublicInputs &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -6992,16 +10844,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::PublicInputs &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::PublicInputs &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -7009,15 +10861,15 @@ void serde::Serializable::serialize(const Program::Public template <> template -Program::PublicInputs serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::PublicInputs serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::PublicInputs obj; + Acir::PublicInputs obj; obj.value = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const ValueOrArray &lhs, const ValueOrArray &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -7034,16 +10886,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::ValueOrArray &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::ValueOrArray &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -7051,15 +10903,15 @@ void serde::Serializable::serialize(const Program::ValueO template <> template -Program::ValueOrArray serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::ValueOrArray serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::ValueOrArray obj; + Acir::ValueOrArray obj; obj.value = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const ValueOrArray::MemoryAddress &lhs, const ValueOrArray::MemoryAddress &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -7076,28 +10928,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::ValueOrArray::MemoryAddress &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::ValueOrArray::MemoryAddress &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::ValueOrArray::MemoryAddress serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::ValueOrArray::MemoryAddress obj; +Acir::ValueOrArray::MemoryAddress serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::ValueOrArray::MemoryAddress obj; obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const ValueOrArray::HeapArray &lhs, const ValueOrArray::HeapArray &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -7114,28 +10966,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::ValueOrArray::HeapArray &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::ValueOrArray::HeapArray &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::ValueOrArray::HeapArray serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::ValueOrArray::HeapArray obj; +Acir::ValueOrArray::HeapArray serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::ValueOrArray::HeapArray obj; obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const ValueOrArray::HeapVector &lhs, const ValueOrArray::HeapVector &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -7152,28 +11004,28 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::ValueOrArray::HeapVector &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::ValueOrArray::HeapVector &obj, Serializer &serializer) { serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::ValueOrArray::HeapVector serde::Deserializable::deserialize(Deserializer &deserializer) { - Program::ValueOrArray::HeapVector obj; +Acir::ValueOrArray::HeapVector serde::Deserializable::deserialize(Deserializer &deserializer) { + Acir::ValueOrArray::HeapVector obj; obj.value = serde::Deserializable::deserialize(deserializer); return obj; } -namespace Program { +namespace Acir { inline bool operator==(const Witness &lhs, const Witness &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -7190,16 +11042,16 @@ namespace Program { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace Program +} // end of namespace Acir template <> template -void serde::Serializable::serialize(const Program::Witness &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Acir::Witness &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -7207,9 +11059,9 @@ void serde::Serializable::serialize(const Program::Witness &ob template <> template -Program::Witness serde::Deserializable::deserialize(Deserializer &deserializer) { +Acir::Witness serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - Program::Witness obj; + Acir::Witness obj; obj.value = serde::Deserializable::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 ad2b0550db2..f2f1dbc2d85 100644 --- a/acvm-repo/acir/codegen/witness.cpp +++ b/acvm-repo/acir/codegen/witness.cpp @@ -1,9 +1,57 @@ #pragma once #include "serde.hpp" +#include "msgpack.hpp" #include "bincode.hpp" -namespace WitnessStack { +namespace Witnesses { + struct Helpers { + static std::map make_kvmap( + msgpack::object const& o, + std::string const& name + ) { + if(o.type != msgpack::type::MAP) { + std::cerr << o << std::endl; + throw_or_abort("expected MAP for " + name); + } + std::map kvmap; + for (uint32_t i = 0; i < o.via.map.size; ++i) { + if (o.via.map.ptr[i].key.type != msgpack::type::STR) { + std::cerr << o << std::endl; + throw_or_abort("expected STR for keys of " + name); + } + kvmap.emplace( + std::string( + o.via.map.ptr[i].key.via.str.ptr, + o.via.map.ptr[i].key.via.str.size), + &o.via.map.ptr[i].val); + } + return kvmap; + } + template + static void conv_fld_from_kvmap( + std::map const& kvmap, + std::string const& struct_name, + std::string const& field_name, + T& field, + bool is_optional + ) { + auto it = kvmap.find(field_name); + if (it != kvmap.end()) { + try { + it->second->convert(field); + } catch (const msgpack::type_error&) { + std::cerr << *it->second << std::endl; + throw_or_abort("error converting into field " + struct_name + "::" + field_name); + } + } else if (!is_optional) { + throw_or_abort("missing field: " + struct_name + "::" + field_name); + } + } + }; + } + +namespace Witnesses { struct Witness { uint32_t value; @@ -11,37 +59,83 @@ namespace WitnessStack { friend bool operator==(const Witness&, const Witness&); std::vector bincodeSerialize() const; static Witness bincodeDeserialize(std::vector); + + bool operator<(Witness const& rhs) const { return value < rhs.value; }void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'Witness'"); + } + } }; struct WitnessMap { - std::map value; + std::map value; friend bool operator==(const WitnessMap&, const WitnessMap&); std::vector bincodeSerialize() const; static WitnessMap bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { packer.pack(value); } + + void msgpack_unpack(msgpack::object const& o) { + try { + o.convert(value); + } catch (const msgpack::type_error&) { + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype 'WitnessMap'"); + } + } }; struct StackItem { uint32_t index; - WitnessStack::WitnessMap witness; + Witnesses::WitnessMap witness; friend bool operator==(const StackItem&, const StackItem&); std::vector bincodeSerialize() const; static StackItem bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(2); + packer.pack(std::make_pair("index", index)); + packer.pack(std::make_pair("witness", witness)); + } + + 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); + } }; struct WitnessStack { - std::vector stack; + std::vector stack; friend bool operator==(const WitnessStack&, const WitnessStack&); std::vector bincodeSerialize() const; static WitnessStack bincodeDeserialize(std::vector); + + void msgpack_pack(auto& packer) const { + packer.pack_map(1); + packer.pack(std::make_pair("stack", stack)); + } + + 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); + } }; -} // end of namespace WitnessStack +} // end of namespace Witnesses -namespace WitnessStack { +namespace Witnesses { inline bool operator==(const StackItem &lhs, const StackItem &rhs) { if (!(lhs.index == rhs.index)) { return false; } @@ -59,16 +153,16 @@ namespace WitnessStack { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace WitnessStack +} // end of namespace Witnesses template <> template -void serde::Serializable::serialize(const WitnessStack::StackItem &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Witnesses::StackItem &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.index, serializer); serde::Serializable::serialize(obj.witness, serializer); @@ -77,16 +171,16 @@ void serde::Serializable::serialize(const WitnessStack: template <> template -WitnessStack::StackItem serde::Deserializable::deserialize(Deserializer &deserializer) { +Witnesses::StackItem serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - WitnessStack::StackItem obj; + Witnesses::StackItem obj; obj.index = serde::Deserializable::deserialize(deserializer); obj.witness = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace WitnessStack { +namespace Witnesses { inline bool operator==(const Witness &lhs, const Witness &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -103,16 +197,16 @@ namespace WitnessStack { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace WitnessStack +} // end of namespace Witnesses template <> template -void serde::Serializable::serialize(const WitnessStack::Witness &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Witnesses::Witness &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -120,15 +214,15 @@ void serde::Serializable::serialize(const WitnessStack::W template <> template -WitnessStack::Witness serde::Deserializable::deserialize(Deserializer &deserializer) { +Witnesses::Witness serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - WitnessStack::Witness obj; + Witnesses::Witness obj; obj.value = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace WitnessStack { +namespace Witnesses { inline bool operator==(const WitnessMap &lhs, const WitnessMap &rhs) { if (!(lhs.value == rhs.value)) { return false; } @@ -145,16 +239,16 @@ namespace WitnessStack { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace WitnessStack +} // end of namespace Witnesses template <> template -void serde::Serializable::serialize(const WitnessStack::WitnessMap &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Witnesses::WitnessMap &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.value, serializer); serializer.decrease_container_depth(); @@ -162,15 +256,15 @@ void serde::Serializable::serialize(const WitnessStack template <> template -WitnessStack::WitnessMap serde::Deserializable::deserialize(Deserializer &deserializer) { +Witnesses::WitnessMap serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - WitnessStack::WitnessMap obj; + Witnesses::WitnessMap obj; obj.value = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; } -namespace WitnessStack { +namespace Witnesses { inline bool operator==(const WitnessStack &lhs, const WitnessStack &rhs) { if (!(lhs.stack == rhs.stack)) { return false; } @@ -187,16 +281,16 @@ namespace WitnessStack { auto deserializer = serde::BincodeDeserializer(input); auto value = serde::Deserializable::deserialize(deserializer); if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); + throw_or_abort("Some input bytes were not read"); } return value; } -} // end of namespace WitnessStack +} // end of namespace Witnesses template <> template -void serde::Serializable::serialize(const WitnessStack::WitnessStack &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Witnesses::WitnessStack &obj, Serializer &serializer) { serializer.increase_container_depth(); serde::Serializable::serialize(obj.stack, serializer); serializer.decrease_container_depth(); @@ -204,9 +298,9 @@ void serde::Serializable::serialize(const WitnessSta template <> template -WitnessStack::WitnessStack serde::Deserializable::deserialize(Deserializer &deserializer) { +Witnesses::WitnessStack serde::Deserializable::deserialize(Deserializer &deserializer) { deserializer.increase_container_depth(); - WitnessStack::WitnessStack obj; + Witnesses::WitnessStack obj; obj.stack = serde::Deserializable::deserialize(deserializer); deserializer.decrease_container_depth(); return obj; diff --git a/acvm-repo/acir/src/circuit/mod.rs b/acvm-repo/acir/src/circuit/mod.rs index f7d87c52555..47515cb8bf3 100644 --- a/acvm-repo/acir/src/circuit/mod.rs +++ b/acvm-repo/acir/src/circuit/mod.rs @@ -6,7 +6,7 @@ pub mod opcodes; use crate::{ native_types::{Expression, Witness}, - serialization::{bincode_deserialize, bincode_serialize}, + serialization::{deserialize_any_format, serialize_with_format_from_env}, }; use acir_field::AcirField; pub use opcodes::Opcode; @@ -268,7 +268,9 @@ impl Circuit { impl Program { /// Serialize and compress the [Program] into bytes. fn write(&self, writer: W) -> std::io::Result<()> { - let buf = bincode_serialize(self)?; + let buf = serialize_with_format_from_env(self)?; + + // Compress the data, which should help with formats that uses field names. let mut encoder = flate2::write::GzEncoder::new(writer, Compression::default()); encoder.write_all(&buf)?; encoder.finish()?; @@ -298,7 +300,7 @@ impl Deserialize<'a>> Program { let mut gz_decoder = flate2::read::GzDecoder::new(reader); let mut buf = Vec::new(); gz_decoder.read_to_end(&mut buf)?; - let program = bincode_deserialize(&buf)?; + let program = deserialize_any_format(&buf)?; Ok(program) } @@ -679,8 +681,8 @@ mod tests { #[test] fn prop_witness_stack_roundtrip() { run_with_max_size_range(10, |witness: WitnessStack| { - let bz = Vec::::try_from(&witness)?; - let de = WitnessStack::try_from(bz.as_slice())?; + let bz = witness.serialize()?; + let de = WitnessStack::deserialize(bz.as_slice())?; prop_assert_eq!(witness, de); Ok(()) }); @@ -719,8 +721,8 @@ mod tests { #[test] fn prop_witness_map_roundtrip() { run_with_max_size_range(10, |witness: WitnessMap| { - let bz = Vec::::try_from(witness.clone())?; - let de = WitnessMap::try_from(bz.as_slice())?; + let bz = witness.serialize()?; + let de = WitnessMap::deserialize(bz.as_slice())?; prop_assert_eq!(witness, de); Ok(()) }); diff --git a/acvm-repo/acir/src/lib.rs b/acvm-repo/acir/src/lib.rs index ba65a114bae..4bf993b9fa1 100644 --- a/acvm-repo/acir/src/lib.rs +++ b/acvm-repo/acir/src/lib.rs @@ -1,3 +1,9 @@ +//! C++ code generation for ACIR format, to be used by Barretenberg. +//! +//! To regenerate code run the following command: +//! ```text +//! NOIR_CODEGEN_OVERWRITE=1 cargo test -p acir cpp_codegen +//! ``` #![cfg_attr(not(test), forbid(unsafe_code))] // `std::env::set_var` is used in tests. #![warn(unreachable_pub)] #![warn(clippy::semicolon_if_nothing_returned)] @@ -28,17 +34,23 @@ mod reflection { //! logic. Make sure to uncomment these lines afterwards and to commit the changes to the `codegen` folder. use std::{ + collections::BTreeMap, fs::File, io::Write, path::{Path, PathBuf}, }; - use acir_field::FieldElement; + use acir_field::{AcirField, FieldElement}; use brillig::{ BinaryFieldOp, BinaryIntOp, BitSize, BlackBoxOp, HeapValueType, IntegerBitSize, MemoryAddress, Opcode as BrilligOpcode, ValueOrArray, }; - use serde_reflection::{Tracer, TracerConfig}; + use regex::Regex; + use serde::{Deserialize, Serialize}; + use serde_generate::CustomCode; + use serde_reflection::{ + ContainerFormat, Format, Named, Registry, Tracer, TracerConfig, VariantFormat, + }; use crate::{ circuit::{ @@ -50,20 +62,27 @@ mod reflection { native_types::{Witness, WitnessMap, WitnessStack}, }; + /// Technical DTO for deserializing in Barretenberg while ignoring + /// the Brillig opcodes, so that we can add more without affecting it. + /// + /// This could be achieved in other ways, for example by having a + /// version of `Program` that deserializes into opaque bytes, + /// which would require a 2 step (de)serialization process. + /// + /// This one is simpler. The cost is that msgpack will deserialize + /// into a JSON-like structure, but since we won't be interpreting it, + /// it's okay if new tags appear. + #[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Default, Hash)] + struct ProgramWithoutBrillig { + pub functions: Vec>, + } + #[test] fn serde_acir_cpp_codegen() { - let path = PathBuf::from("./codegen/acir.cpp"); - - let old_hash = if path.is_file() { - let old_source = std::fs::read(&path).unwrap(); - Some(fxhash::hash64(&old_source)) - } else { - None - }; - let mut tracer = Tracer::new(TracerConfig::default()); tracer.trace_simple_type::().unwrap(); tracer.trace_simple_type::>().unwrap(); + tracer.trace_simple_type::>().unwrap(); tracer.trace_simple_type::>().unwrap(); tracer.trace_simple_type::().unwrap(); tracer.trace_simple_type::>().unwrap(); @@ -85,56 +104,85 @@ mod reflection { tracer.trace_simple_type::().unwrap(); tracer.trace_simple_type::().unwrap(); - let registry = tracer.registry().unwrap(); - - // Create C++ class definitions. - let mut source = Vec::new(); - let config = serde_generate::CodeGeneratorConfig::new("Program".to_string()) - .with_encodings(vec![serde_generate::Encoding::Bincode]); - let generator = serde_generate::cpp::CodeGenerator::new(&config); - generator.output(&mut source, ®istry).unwrap(); - - // Comment this out to write updated C++ code to file. - if let Some(old_hash) = old_hash { - let new_hash = fxhash::hash64(&source); - assert_eq!(new_hash, old_hash, "Serialization format has changed"); - } - - write_to_file(&source, &path); + serde_cpp_codegen( + "Acir", + PathBuf::from("./codegen/acir.cpp").as_path(), + &tracer.registry().unwrap(), + CustomCode::default(), + ); } #[test] fn serde_witness_map_cpp_codegen() { - let path = PathBuf::from("./codegen/witness.cpp"); + let mut tracer = Tracer::new(TracerConfig::default()); + tracer.trace_simple_type::().unwrap(); + tracer.trace_simple_type::>().unwrap(); + tracer.trace_simple_type::>().unwrap(); + let namespace = "Witnesses"; + let mut code = CustomCode::default(); + // The `WitnessMap` type will have a field of type `std::map`, + // which requires us to implement the comparison operator. + code.insert( + vec![namespace.to_string(), "Witness".to_string()], + "bool operator<(Witness const& rhs) const { return value < rhs.value; }".to_string(), + ); + + serde_cpp_codegen( + namespace, + PathBuf::from("./codegen/witness.cpp").as_path(), + &tracer.registry().unwrap(), + code, + ); + } + + /// Regenerate C++ code for serializing our domain model based on serde, + /// intended to be used by Barretenberg. + /// + /// If `should_overwrite()` returns `false` then just check if the old file hash is the + /// same as the new one, to guard against unintended changes in the serialization format. + fn serde_cpp_codegen(namespace: &str, path: &Path, registry: &Registry, code: CustomCode) { let old_hash = if path.is_file() { - let old_source = std::fs::read(&path).unwrap(); + let old_source = std::fs::read(path).expect("failed to read existing code"); + let old_source = String::from_utf8(old_source).expect("old source not UTF-8"); Some(fxhash::hash64(&old_source)) } else { None }; - - let mut tracer = Tracer::new(TracerConfig::default()); - tracer.trace_simple_type::().unwrap(); - tracer.trace_simple_type::>().unwrap(); - tracer.trace_simple_type::>().unwrap(); - - let registry = tracer.registry().unwrap(); + let msgpack_code = MsgPackCodeGenerator::generate(namespace, registry, code); // Create C++ class definitions. let mut source = Vec::new(); - let config = serde_generate::CodeGeneratorConfig::new("WitnessStack".to_string()) - .with_encodings(vec![serde_generate::Encoding::Bincode]); + let config = serde_generate::CodeGeneratorConfig::new(namespace.to_string()) + .with_encodings(vec![serde_generate::Encoding::Bincode]) + .with_custom_code(msgpack_code); let generator = serde_generate::cpp::CodeGenerator::new(&config); - generator.output(&mut source, ®istry).unwrap(); + generator.output(&mut source, registry).expect("failed to generate C++ code"); + + // Further massaging of the generated code + let mut source = String::from_utf8(source).expect("not a UTF-8 string"); + replace_throw(&mut source); + MsgPackCodeGenerator::add_preamble(&mut source); + MsgPackCodeGenerator::add_helpers(&mut source, namespace); + MsgPackCodeGenerator::replace_array_with_shared_ptr(&mut source); - // Comment this out to write updated C++ code to file. - if let Some(old_hash) = old_hash { - let new_hash = fxhash::hash64(&source); - assert_eq!(new_hash, old_hash, "Serialization format has changed"); + if !should_overwrite() { + if let Some(old_hash) = old_hash { + let new_hash = fxhash::hash64(&source); + assert_eq!(new_hash, old_hash, "Serialization format has changed",); + } } - write_to_file(&source, &path); + write_to_file(source.as_bytes(), path); + } + + /// Check if it's okay for the generated source to be overwritten with a new version. + /// Otherwise any changes causes a test failure. + fn should_overwrite() -> bool { + std::env::var("NOIR_CODEGEN_OVERWRITE") + .ok() + .map(|v| v == "1" || v == "true") + .unwrap_or_default() } fn write_to_file(bytes: &[u8], path: &Path) -> String { @@ -155,4 +203,420 @@ mod reflection { Ok(_) => display.to_string(), } } + + /// Replace all `throw serde::deserialization_error` with `throw_or_abort`. + /// + /// Since we're generating msgpack code that works specifically with the Barretenberg + /// codebase only (these are custom functions), we might as well do the other alterations + /// described in [the DSL](https://github.com/AztecProtocol/aztec-packages/tree/master/barretenberg/cpp/src/barretenberg/dsl). + fn replace_throw(source: &mut String) { + *source = source.replace("throw serde::deserialization_error", "throw_or_abort"); + } + + /// Generate custom code for the msgpack machinery in Barretenberg. + /// See https://github.com/AztecProtocol/aztec-packages/blob/master/barretenberg/cpp/src/barretenberg/serialize/msgpack.hpp + struct MsgPackCodeGenerator { + namespace: Vec, + code: CustomCode, + } + + impl MsgPackCodeGenerator { + /// Add the import of the Barretenberg C++ header for msgpack. + 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\""); + } + + /// Add helper functions to cut down repetition in the generated code. + fn add_helpers(source: &mut String, namespace: &str) { + // Based on https://github.com/AztecProtocol/msgpack-c/blob/54e9865b84bbdc73cfbf8d1d437dbf769b64e386/include/msgpack/v1/adaptor/detail/cpp11_define_map.hpp#L75 + // Using a `struct Helpers` with `static` methods, because top level functions turn up as duplicates in `wasm-ld`. + let helpers = r#" + struct Helpers { + static std::map make_kvmap( + msgpack::object const& o, + std::string const& name + ) { + if(o.type != msgpack::type::MAP) { + std::cerr << o << std::endl; + throw_or_abort("expected MAP for " + name); + } + std::map kvmap; + for (uint32_t i = 0; i < o.via.map.size; ++i) { + if (o.via.map.ptr[i].key.type != msgpack::type::STR) { + std::cerr << o << std::endl; + throw_or_abort("expected STR for keys of " + name); + } + kvmap.emplace( + std::string( + o.via.map.ptr[i].key.via.str.ptr, + o.via.map.ptr[i].key.via.str.size), + &o.via.map.ptr[i].val); + } + return kvmap; + } + template + static void conv_fld_from_kvmap( + std::map const& kvmap, + std::string const& struct_name, + std::string const& field_name, + T& field, + bool is_optional + ) { + auto it = kvmap.find(field_name); + if (it != kvmap.end()) { + try { + it->second->convert(field); + } catch (const msgpack::type_error&) { + std::cerr << *it->second << std::endl; + throw_or_abort("error converting into field " + struct_name + "::" + field_name); + } + } else if (!is_optional) { + throw_or_abort("missing field: " + struct_name + "::" + field_name); + } + } + }; + "#; + let pos = source.find(&format!("namespace {namespace}")).expect("namespace"); + source.insert_str(pos, &format!("namespace {namespace} {{{helpers}}}\n\n")); + } + + /// Reduce the opcode size in C++ by doing what Adam came up with in https://github.com/zefchain/serde-reflection/issues/75 + fn replace_array_with_shared_ptr(source: &mut String) { + // Capture `std::array<$TYPE, $LEN>` + let re = Regex::new(r#"std::array<\s*([^,<>]+?)\s*,\s*([0-9]+)\s*>"#) + .expect("failed to create regex"); + + let fixed = + re.replace_all(source, "std::shared_ptr>").into_owned(); + + *source = fixed; + } + + fn generate(namespace: &str, registry: &Registry, code: CustomCode) -> CustomCode { + let mut g = Self { namespace: vec![namespace.to_string()], code }; + for (name, container) in registry { + g.generate_container(name, container); + } + g.code + } + + /// Append custom code of an item in the current namespace. + fn add_code(&mut self, name: &str, code: &str) { + let mut ns = self.namespace.clone(); + ns.push(name.to_string()); + let c = self.code.entry(ns).or_default(); + if !c.is_empty() && code.contains('\n') { + c.push('\n'); + } + c.push_str(code); + c.push('\n'); + } + + fn generate_container(&mut self, name: &str, container: &ContainerFormat) { + use serde_reflection::ContainerFormat::*; + match container { + UnitStruct => { + self.generate_unit_struct(name); + } + NewTypeStruct(_format) => { + self.generate_newtype(name); + } + TupleStruct(formats) => { + self.generate_tuple(name, formats); + } + Struct(fields) => { + self.generate_struct(name, fields); + } + Enum(variants) => { + self.generate_enum(name, variants); + } + } + } + + /// Unit structs don't have fields to put into the data. + fn generate_unit_struct(&mut self, name: &str) { + // Ostensibly we could use `MSGPACK_FIELDS();`, but because of how enum unpacking + // expects each variant to have `msgpack_unpack`, we generate two empty methods. + // self.msgpack_fields(name, std::iter::empty()); + self.msgpack_pack(name, ""); + self.msgpack_unpack(name, ""); + } + + /// Regular structs pack into a map. + fn generate_struct(&mut self, name: &str, fields: &[Named]) { + // We could use the `MSGPACK_FIELDS` macro with the following: + // self.msgpack_fields(name, fields.iter().map(|f| f.name.clone())); + // Unfortunately it doesn't seem to deal with missing optional fields, + // which would mean we can't delete fields even if they were optional: + // https://github.com/AztecProtocol/msgpack-c/blob/54e9865b84bbdc73cfbf8d1d437dbf769b64e386/include/msgpack/v1/adaptor/detail/cpp11_define_map.hpp#L33-L45 + + // Or we can generate code for individual fields, which relies on + // the `add_helpers` to add some utility functions. This way the + // code is more verbose, but also easier to control, e.g. we can + // raise errors telling specifically which field was wrong, + // or we could reject the data if there was a new field we could + // not recognise, or we could even handle aliases. + + self.msgpack_pack(name, &{ + let mut body = format!( + " + packer.pack_map({});", + fields.len() + ); + for field in fields { + let field_name = &field.name; + body.push_str(&format!( + r#" + packer.pack(std::make_pair("{field_name}", {field_name}));"# + )); + } + body + }); + + self.msgpack_unpack(name, &{ + // Turn the MAP into a `std::map`, + // then look up each field, returning error if one isn't found. + let mut body = format!( + r#" + auto name = "{name}"; + auto kvmap = Helpers::make_kvmap(o, name);"# + ); + for field in fields { + let field_name = &field.name; + let is_optional = matches!(field.value, Format::Option(_)); + body.push_str(&format!( + r#" + Helpers::conv_fld_from_kvmap(kvmap, name, "{field_name}", {field_name}, {is_optional});"# + )); + } + body + }); + } + + /// Newtypes serialize as their underlying `value` that the C++ generator creates. + fn generate_newtype(&mut self, name: &str) { + self.msgpack_pack(name, "packer.pack(value);"); + self.msgpack_unpack( + name, + &format!( + r#" + try {{ + o.convert(value); + }} catch (const msgpack::type_error&) {{ + std::cerr << o << std::endl; + throw_or_abort("error converting into newtype '{name}'"); + }} + "# + ), + ); + } + + /// Tuples serialize as a vector of underlying data. + fn generate_tuple(&mut self, _name: &str, _formats: &[Format]) { + unimplemented!("Until we have a tuple enum in our schema we don't need this."); + } + + /// Enums serialize as a single element map keyed by the variant type name. + fn generate_enum(&mut self, name: &str, variants: &BTreeMap>) { + // Recurse into the variants + self.namespace.push(name.to_string()); + for variant in variants.values() { + self.generate_variant(&variant.name, &variant.value); + } + self.namespace.pop(); + + // Pack the enum itself + self.msgpack_pack(name, &{ + let cases = variants + .iter() + .map(|(i, v)| { + format!( + r#" + case {i}: + tag = "{}"; + is_unit = {}; + break;"#, + v.name, + matches!(v.value, VariantFormat::Unit) + ) + }) + .collect::>() + .join(""); + + format!( + r#" + std::string tag; + bool is_unit; + switch (value.index()) {{ + {cases} + default: + throw_or_abort("unknown enum '{name}' variant index: " + std::to_string(value.index())); + }} + if (is_unit) {{ + packer.pack(tag); + }} else {{ + std::visit([&packer, tag](const auto& arg) {{ + std::map data; + data[tag] = msgpack::object(arg); + packer.pack(data); + }}, value); + }}"# + ) + }); + + // Unpack the enum into a map, inspect the key, then unpack the entry value. + // See https://c.msgpack.org/cpp/structmsgpack_1_1object.html#a8c7c484d2a6979a833bdb69412ad382c + // for how to access the object's content without parsing it. + self.msgpack_unpack(name, &{ + let mut body = format!( + r#" + + if (o.type != msgpack::type::object_type::MAP && o.type != msgpack::type::object_type::STR) {{ + std::cerr << o << std::endl; + throw_or_abort("expected MAP or STR for enum '{name}'; got type " + std::to_string(o.type)); + }} + if (o.type == msgpack::type::object_type::MAP && o.via.map.size != 1) {{ + throw_or_abort("expected 1 entry for enum '{name}'; got " + std::to_string(o.via.map.size)); + }} + std::string tag; + try {{ + if (o.type == msgpack::type::object_type::MAP) {{ + o.via.map.ptr[0].key.convert(tag); + }} else {{ + o.convert(tag); + }} + }} catch(const msgpack::type_error&) {{ + std::cerr << o << std::endl; + throw_or_abort("error converting tag to string for enum '{name}'"); + }}"# + ); + + for (i, v) in variants.iter() { + let variant = &v.name; + body.push_str(&format!( + r#" + {}if (tag == "{variant}") {{ + {variant} v;"#, + if *i == 0 { "" } else { "else " } + )); + + if !matches!(v.value, VariantFormat::Unit) { + body.push_str(&format!( + r#" + try {{ + o.via.map.ptr[0].val.convert(v); + }} catch (const msgpack::type_error&) {{ + std::cerr << o << std::endl; + throw_or_abort("error converting into enum variant '{name}::{variant}'"); + }} + "# + )); + } + // Closing brace of if statement + body.push_str( + r#" + value = v; + }"#, + ); + } + body.push_str(&format!( + r#" + else {{ + std::cerr << o << std::endl; + throw_or_abort("unknown '{name}' enum variant: " + tag); + }}"# + )); + + body + }); + } + + /// Generate msgpack code for nested enum variants. + fn generate_variant(&mut self, name: &str, variant: &VariantFormat) { + match variant { + VariantFormat::Variable(_) => { + unreachable!("internal construct") + } + VariantFormat::Unit => self.generate_unit_struct(name), + VariantFormat::NewType(_format) => self.generate_newtype(name), + VariantFormat::Tuple(formats) => self.generate_tuple(name, formats), + VariantFormat::Struct(fields) => self.generate_struct(name, fields), + } + } + + /// Use the `MSGPACK_FIELDS` macro with a list of fields. + /// This one takes care of serializing and deserializing as well. + /// + /// Uses [define_map](https://github.com/AztecProtocol/msgpack-c/blob/54e9865b84bbdc73cfbf8d1d437dbf769b64e386/include/msgpack/v1/adaptor/detail/cpp11_define_map.hpp#L75-L88) under the hood. + #[allow(dead_code)] + fn msgpack_fields(&mut self, name: &str, fields: impl Iterator) { + let fields = fields.collect::>().join(", "); + let code = format!("MSGPACK_FIELDS({});", fields); + self.add_code(name, &code); + } + + /// Add a `msgpack_pack` implementation. + fn msgpack_pack(&mut self, name: &str, body: &str) { + let code = Self::make_fn("void msgpack_pack(auto& packer) const", body); + self.add_code(name, &code); + } + + /// Add a `msgpack_unpack` implementation. + fn msgpack_unpack(&mut self, name: &str, body: &str) { + // Using `msgpack::object const& o` instad of `auto o`, because the latter is passed as `msgpack::object::implicit_type`, + // which would have to be cast like `msgpack::object obj = o;`. This `const&` pattern exists in `msgpack-c` codebase. + + // Instead of implementing the `msgpack_unpack` method as suggested by `msgpack.hpp` in Barretenberg, + // we could implement an extension method on `msgpack::object` as below. However, it has to be in + // the `msgpack::adaptor` namespace, which would mean it has to be appended at the end of the code, + // rather than into the structs, where `CustomCode` goes. + // + // namespace msgpack { + // namespace adaptor { + // // For Opcode + // template <> struct msgpack::adaptor::convert { + // msgpack::object const& operator()(msgpack::object const& o, Acir::Opcode& v) const + // { + // return o; + // if (o.type != msgpack::type::MAP || o.via.map.size != 1) { + // throw_or_abort("expecteed signle element map for 'Opcode'"); + // } + + // auto& kv = o.via.map.ptr[0]; + // std::string key = kv.key.as(); + + // if (key == "BrilligCall") { + // Acir::Opcode::BrilligCall bc = kv.val.as(); + // v.value = bc; + // } else if (key == "AssertZero") { + // Acir::Opcode::AssertZero az = kv.val.as(); + // v.value = az; + // } else { + // throw_or_abort("unknown tag for 'Opcode': " + key); + // } + // return o; + // } + // }; + // } // namespace adaptor + // } // namespace msgpack + + let code = Self::make_fn("void msgpack_unpack(msgpack::object const& o)", body); + self.add_code(name, &code); + } + + fn make_fn(header: &str, body: &str) -> String { + let body = body.trim_end(); + if body.is_empty() { + format!("{header} {{}}") + } else if !body.contains('\n') { + format!("{header} {{ {body} }}") + } else if body.starts_with('\n') { + format!("{header} {{{body}\n}}") + } else { + format!("{header} {{\n{body}\n}}") + } + } + } } diff --git a/acvm-repo/acir/src/native_types/witness_map.rs b/acvm-repo/acir/src/native_types/witness_map.rs index fc8b1e0c18d..847ba04453d 100644 --- a/acvm-repo/acir/src/native_types/witness_map.rs +++ b/acvm-repo/acir/src/native_types/witness_map.rs @@ -11,16 +11,21 @@ use flate2::bufread::GzEncoder; use serde::{Deserialize, Serialize}; use thiserror::Error; -use crate::native_types::Witness; +use crate::{native_types::Witness, serialization}; #[derive(Debug, Error)] enum SerializationError { - #[error(transparent)] - Deflate(#[from] std::io::Error), + #[error("error compressing witness map: {0}")] + Compress(std::io::Error), + + #[error("error decompressing witness map: {0}")] + Decompress(std::io::Error), + + #[error("error serializing witness map: {0}")] + Serialize(std::io::Error), - #[allow(dead_code)] #[error("error deserializing witness map: {0}")] - Deserialize(String), + Deserialize(std::io::Error), } #[derive(Debug, Error)] @@ -83,38 +88,32 @@ impl From> for WitnessMap { } } -impl WitnessMap { - pub(crate) fn bincode_serialize(&self) -> Result, WitnessMapError> { - bincode::serialize(self).map_err(|e| SerializationError::Deserialize(e.to_string()).into()) - } -} +impl WitnessMap { + /// Serialize and compress. + pub fn serialize(&self) -> Result, WitnessMapError> { + let buf = serialization::serialize_with_format_from_env(self) + .map_err(|e| WitnessMapError(SerializationError::Serialize(e)))?; -impl Deserialize<'a>> WitnessMap { - pub(crate) fn bincode_deserialize(buf: &[u8]) -> Result { - bincode::deserialize(buf).map_err(|e| SerializationError::Deserialize(e.to_string()).into()) - } -} - -impl TryFrom> for Vec { - type Error = WitnessMapError; - - fn try_from(val: WitnessMap) -> Result { - let buf = val.bincode_serialize()?; let mut deflater = GzEncoder::new(buf.as_slice(), Compression::best()); let mut buf = Vec::new(); - deflater.read_to_end(&mut buf).map_err(|err| WitnessMapError(err.into()))?; + deflater + .read_to_end(&mut buf) + .map_err(|e| WitnessMapError(SerializationError::Compress(e)))?; + Ok(buf) } } -impl Deserialize<'a>> TryFrom<&[u8]> for WitnessMap { - type Error = WitnessMapError; - - fn try_from(bytes: &[u8]) -> Result { - let mut deflater = GzDecoder::new(bytes); +impl Deserialize<'a>> WitnessMap { + /// Decompress and deserialize. + pub fn deserialize(buf: &[u8]) -> Result { + let mut deflater = GzDecoder::new(buf); let mut buf = Vec::new(); - deflater.read_to_end(&mut buf).map_err(|err| WitnessMapError(err.into()))?; - let witness_map = Self::bincode_deserialize(&buf)?; - Ok(witness_map) + deflater + .read_to_end(&mut buf) + .map_err(|e| WitnessMapError(SerializationError::Decompress(e)))?; + + serialization::deserialize_any_format(&buf) + .map_err(|e| WitnessMapError(SerializationError::Deserialize(e))) } } diff --git a/acvm-repo/acir/src/native_types/witness_stack.rs b/acvm-repo/acir/src/native_types/witness_stack.rs index e1d0639d1d3..cf34c06e7a5 100644 --- a/acvm-repo/acir/src/native_types/witness_stack.rs +++ b/acvm-repo/acir/src/native_types/witness_stack.rs @@ -7,19 +7,23 @@ use flate2::bufread::GzEncoder; use serde::{Deserialize, Serialize}; use thiserror::Error; +use crate::serialization; + use super::WitnessMap; #[derive(Debug, Error)] enum SerializationError { - #[error(transparent)] - Deflate(#[from] std::io::Error), + #[error("error compressing witness stack: {0}")] + Compress(std::io::Error), + + #[error("error decompressing witness stack: {0}")] + Decompress(std::io::Error), - #[error(transparent)] - BincodeError(#[from] bincode::Error), + #[error("error serializing witness stack: {0}")] + Serialize(std::io::Error), - #[allow(dead_code)] #[error("error deserializing witness stack: {0}")] - Deserialize(String), + Deserialize(std::io::Error), } /// Native error for serializing/deserializating a witness stack. @@ -65,53 +69,39 @@ impl WitnessStack { } } -impl From> for WitnessStack { - fn from(witness: WitnessMap) -> Self { - let stack = vec![StackItem { index: 0, witness }]; - Self { stack } - } -} - -impl WitnessStack { - pub(crate) fn bincode_serialize(&self) -> Result, WitnessStackError> { - bincode::serialize(self).map_err(|e| WitnessStackError(e.into())) - } -} - -impl Deserialize<'a>> WitnessStack { - pub(crate) fn bincode_deserialize(buf: &[u8]) -> Result { - bincode::deserialize(buf).map_err(|e| WitnessStackError(e.into())) - } -} - -impl TryFrom<&WitnessStack> for Vec { - type Error = WitnessStackError; +impl WitnessStack { + /// Serialize and compress. + pub fn serialize(&self) -> Result, WitnessStackError> { + let buf = serialization::serialize_with_format_from_env(self) + .map_err(|e| WitnessStackError(SerializationError::Serialize(e)))?; - fn try_from(val: &WitnessStack) -> Result { - let buf = val.bincode_serialize()?; let mut deflater = GzEncoder::new(buf.as_slice(), Compression::best()); - let mut buf_c = Vec::new(); - deflater.read_to_end(&mut buf_c).map_err(|err| WitnessStackError(err.into()))?; - Ok(buf_c) + let mut buf = Vec::new(); + deflater + .read_to_end(&mut buf) + .map_err(|e| WitnessStackError(SerializationError::Compress(e)))?; + + Ok(buf) } } -impl TryFrom> for Vec { - type Error = WitnessStackError; +impl Deserialize<'a>> WitnessStack { + /// Decompress and deserialize. + pub fn deserialize(buf: &[u8]) -> Result { + let mut deflater = GzDecoder::new(buf); + let mut buf = Vec::new(); + deflater + .read_to_end(&mut buf) + .map_err(|e| WitnessStackError(SerializationError::Decompress(e)))?; - fn try_from(val: WitnessStack) -> Result { - Self::try_from(&val) + serialization::deserialize_any_format(&buf) + .map_err(|e| WitnessStackError(SerializationError::Deserialize(e))) } } -impl Deserialize<'a>> TryFrom<&[u8]> for WitnessStack { - type Error = WitnessStackError; - - fn try_from(bytes: &[u8]) -> Result { - let mut deflater = GzDecoder::new(bytes); - let mut buf = Vec::new(); - deflater.read_to_end(&mut buf).map_err(|err| WitnessStackError(err.into()))?; - let witness_stack = Self::bincode_deserialize(&buf)?; - Ok(witness_stack) +impl From> for WitnessStack { + fn from(witness: WitnessMap) -> Self { + let stack = vec![StackItem { index: 0, witness }]; + Self { stack } } } diff --git a/acvm-repo/acir/src/serialization.rs b/acvm-repo/acir/src/serialization.rs index 1b5407a4cbb..12323524508 100644 --- a/acvm-repo/acir/src/serialization.rs +++ b/acvm-repo/acir/src/serialization.rs @@ -1,8 +1,48 @@ //! Serialization formats we consider using for the bytecode and the witness stack. + use crate::proto::convert::ProtoSchema; use acir_field::AcirField; use noir_protobuf::ProtoCodec; +use num_enum::{IntoPrimitive, TryFromPrimitive}; use serde::{Deserialize, Serialize}; +use std::str::FromStr; +use strum_macros::EnumString; + +const FORMAT_ENV_VAR: &str = "NOIR_SERIALIZATION_FORMAT"; + +/// A marker byte for the serialization format. +#[derive(Debug, Clone, Copy, IntoPrimitive, TryFromPrimitive, EnumString, PartialEq, Eq)] +#[strum(serialize_all = "kebab-case")] +#[repr(u8)] +pub(crate) enum Format { + /// Bincode without format marker. + /// This does not actually appear in the data. + BincodeLegacy = 0, + /// Bincode with format marker. + Bincode = 1, + /// Msgpack with named structs. + Msgpack = 2, + /// Msgpack with tuple structs. + MsgpackCompact = 3, + Protobuf = 4, +} + +impl Format { + /// Look for a `NOIR_SERIALIZATION_FORMAT` env var to turn on formatted serialization. + /// + /// The reason we use an env var is because: + /// 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, String> { + let Ok(format) = std::env::var(FORMAT_ENV_VAR) else { + return Ok(None); + }; + Self::from_str(&format) + .map(Some) + .map_err(|e| format!("unknown format '{format}' in {FORMAT_ENV_VAR}: {e}")) + } +} /// Serialize a value using `bincode`, based on `serde`. /// @@ -38,10 +78,7 @@ pub(crate) fn msgpack_serialize( // * `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 - let mut buf = Vec::new(); - let mut ser = rmp_serde::Serializer::new(&mut buf).with_struct_map(); - value.serialize(&mut ser).map_err(std::io::Error::other)?; - Ok(buf) + rmp_serde::to_vec_named(value).map_err(std::io::Error::other) } } @@ -76,9 +113,100 @@ where .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidInput, e)) } +/// Deserialize any of the supported formats. Try go guess the format based on the first byte, +/// but fall back to the legacy `bincode` format if anything fails. +pub(crate) fn deserialize_any_format(buf: &[u8]) -> std::io::Result +where + T: for<'a> Deserialize<'a>, + F: AcirField, + R: prost::Message + Default, + ProtoSchema: ProtoCodec, +{ + // Unfortunately as long as we have to deal with legacy bincode format we might be able + // to deserialize any other format as pure coincidence, when it was just legacy data. + // Since `bincode` is the least backwards compatible, let's try that first. + let bincode_result = bincode_deserialize(buf); + + if bincode_result.is_err() && !buf.is_empty() { + if let Ok(format) = Format::try_from(buf[0]) { + match format { + Format::BincodeLegacy => { + // This is just a coincidence, as this format does not appear in the data, + // but we know it's none of the other formats. + } + Format::Bincode => { + if let Ok(value) = bincode_deserialize(&buf[1..]) { + return Ok(value); + } + } + Format::Msgpack | Format::MsgpackCompact => { + if let Ok(value) = msgpack_deserialize(&buf[1..]) { + return Ok(value); + } + } + Format::Protobuf => { + if let Ok(value) = proto_deserialize(&buf[1..]) { + return Ok(value); + } + } + } + } + } + + bincode_result +} + +pub(crate) fn serialize_with_format(value: &T, format: Format) -> std::io::Result> +where + F: AcirField, + T: Serialize, + R: prost::Message, + ProtoSchema: ProtoCodec, +{ + // It would be more efficient to skip having to create a vector here, and use a std::io::Writer instead. + let mut buf = match format { + Format::BincodeLegacy => return bincode_serialize(value), + Format::Bincode => bincode_serialize(value)?, + Format::Protobuf => proto_serialize(value), + Format::Msgpack => msgpack_serialize(value, false)?, + Format::MsgpackCompact => msgpack_serialize(value, true)?, + }; + let mut res = vec![format.into()]; + res.append(&mut buf); + Ok(res) +} + +pub(crate) fn serialize_with_format_from_env(value: &T) -> std::io::Result> +where + F: AcirField, + T: Serialize, + R: prost::Message, + ProtoSchema: ProtoCodec, +{ + 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 crate::serialization::{msgpack_deserialize, msgpack_serialize}; + use acir_field::FieldElement; + use brillig::{BitSize, HeapArray, IntegerBitSize, ValueOrArray}; + use std::str::FromStr; + + use crate::{ + circuit::{Opcode, brillig::BrilligFunctionId}, + native_types::Witness, + serialization::{Format, msgpack_deserialize, msgpack_serialize}, + }; mod version1 { use serde::{Deserialize, Serialize}; @@ -218,4 +346,88 @@ mod tests { } } } + + /// Test that an enum where each member wraps a struct serializes as a single item map keyed by the type. + #[test] + fn msgpack_repr_enum_of_structs() { + use rmpv::Value; + + let value = ValueOrArray::HeapArray(HeapArray { + pointer: brillig::MemoryAddress::Relative(0), + size: 3, + }); + let bz = msgpack_serialize(&value, false).unwrap(); + let msg = rmpv::decode::read_value::<&[u8]>(&mut bz.as_ref()).unwrap(); + + let Value::Map(fields) = msg else { + panic!("expected Map: {msg:?}"); + }; + assert_eq!(fields.len(), 1); + let Value::String(key) = &fields[0].0 else { + panic!("expected String key: {fields:?}"); + }; + assert_eq!(key.as_str(), Some("HeapArray")); + } + + /// Test that an enum of unit structs serializes as a string. + #[test] + fn msgpack_repr_enum_of_unit_structs() { + let value = IntegerBitSize::U1; + let bz = msgpack_serialize(&value, false).unwrap(); + let msg = rmpv::decode::read_value::<&[u8]>(&mut bz.as_ref()).unwrap(); + + assert_eq!(msg.as_str(), Some("U1")); + } + + /// Test how an enum where some members are unit structs serializes. + #[test] + fn msgpack_repr_enum_of_mixed() { + let value = vec![BitSize::Field, BitSize::Integer(IntegerBitSize::U64)]; + let bz = msgpack_serialize(&value, false).unwrap(); + let msg = rmpv::decode::read_value::<&[u8]>(&mut bz.as_ref()).unwrap(); + + assert_eq!(format!("{msg}"), r#"["Field", {"Integer": "U64"}]"#); + } + + /// Test that a newtype, just wrapping a value, is serialized as the underlying value. + #[test] + fn msgpack_repr_newtype() { + use rmpv::Value; + + let value = Witness(1); + let bz = msgpack_serialize(&value, false).unwrap(); + let msg = rmpv::decode::read_value::<&[u8]>(&mut bz.as_ref()).unwrap(); + + assert!(matches!(msg, Value::Integer(_))); + } + + /// Test to show that optional fields, when empty, are still in the map. + /// The Rust library handles deserializing them as `None` if they are not present, + /// but the `msgpack-c` library does not. + #[test] + fn msgpack_optional() { + use rmpv::Value; + + let value: Opcode = Opcode::BrilligCall { + id: BrilligFunctionId(1), + inputs: Vec::new(), + outputs: Vec::new(), + predicate: None, + }; + let bz = msgpack_serialize(&value, false).unwrap(); + let msg = rmpv::decode::read_value::<&[u8]>(&mut bz.as_ref()).unwrap(); + + let fields = msg.as_map().expect("enum is a map"); + let fields = &fields.first().expect("enum is non-empty").1; + let fields = fields.as_map().expect("fields are map"); + + let (k, v) = fields.last().expect("fields are not empty"); + assert_eq!(k.as_str().expect("names are str"), "predicate"); + assert!(matches!(v, Value::Nil)); + } + + #[test] + fn format_from_str() { + assert_eq!(Format::from_str("msgpack-compact").unwrap(), Format::MsgpackCompact); + } } diff --git a/acvm-repo/acvm_js/src/compression.rs b/acvm-repo/acvm_js/src/compression.rs index 8114e0d57d2..8229559c89d 100644 --- a/acvm-repo/acvm_js/src/compression.rs +++ b/acvm-repo/acvm_js/src/compression.rs @@ -14,8 +14,7 @@ pub fn compress_witness(witness_map: JsWitnessMap) -> Result, JsString> let witness_map = WitnessMap::from(witness_map); let witness_stack = WitnessStack::from(witness_map); - let compressed_witness_stack: Vec = - Vec::::try_from(witness_stack).map_err(|err| err.to_string())?; + let compressed_witness_stack = witness_stack.serialize().map_err(|err| err.to_string())?; Ok(compressed_witness_stack) } @@ -30,7 +29,7 @@ pub fn decompress_witness(compressed_witness: Vec) -> Result Result, console_error_panic_hook::set_once(); let witness_stack = WitnessStack::from(witness_stack); - let compressed_witness_stack: Vec = - Vec::::try_from(witness_stack).map_err(|err| err.to_string())?; + let compressed_witness_stack = witness_stack.serialize().map_err(|err| err.to_string())?; Ok(compressed_witness_stack) } @@ -61,7 +59,7 @@ pub fn decompress_witness_stack(compressed_witness: Vec) -> Result = witnesses.try_into().map_err(|e: WitnessStackError| { + let buf: Vec = witnesses.serialize().map_err(|e| { FilesystemError::OutputWitnessCreationFailed(witness_path.clone(), format!("{e:?}")) })?; diff --git a/tooling/noirc_abi_wasm/src/lib.rs b/tooling/noirc_abi_wasm/src/lib.rs index 8b30db7be78..18336ed4313 100644 --- a/tooling/noirc_abi_wasm/src/lib.rs +++ b/tooling/noirc_abi_wasm/src/lib.rs @@ -126,8 +126,8 @@ pub fn serialise_witness(witness_map: JsWitnessMap) -> Result, JsAbiErro console_error_panic_hook::set_once(); let converted_witness: WitnessMap = witness_map.into(); let witness_stack: WitnessStack = converted_witness.into(); - let output = witness_stack.try_into(); - output.map_err(|_| JsAbiError::new("Failed to convert to Vec".to_string())) + let output = witness_stack.serialize(); + output.map_err(|_| JsAbiError::new("Failed to serialize witness stack".to_string())) } #[wasm_bindgen(js_name = abiDecodeError)]