@aztec/ivc-integration 5.0.0-rc.1 → 5.0.0-rc.2

package/artifacts/mock_private_kernel_reset.json

@@ -1,6 +1,6 @@
 {
-  "noir_version": "1.0.0-beta.22+c57152f91260ecdb9faad4efc20abb14b6d2ece7",
-  "hash": "15031538267256867310",
+  "noir_version": "1.0.0-beta.21+f1a4575adac59af0a86b036cf73ff5883d142a91",
+  "hash": "8301392119809402539",
   "abi": {
     "parameters": [
       {
@@ -126,53 +126,53 @@
     }
   },
   "bytecode": "H4sIAAAAAAAA/7XZ11cTWRwH8CTSFuy9i71X7J2qqBTB3jDCGEfDJIQJin3s3WSCKMVKlaIooID6ssfHe87+A754zj7s2/qyb7uHHYh+B0GT32DGB8/nxDv3d+/9zXyJQx/ZXViebeaFT4YVUkOM1Zx5LMZ2IsEpZMaarVapIi06eUO8LFXt5EWBy801RBIGsSLSqGLSqBLSqNIfjWpK4zKdjlw+j4u2WBycxSzyNqHwk+EurvsNCocioL5QP6g/NAAaCA2CBkNDoKHQMGg4NAIaCY2CRkNjoLHQOGg8NAGKhCZCk6DJ0BRoKjQNmg7NgGZCs6DZ0BxoLjQPmg8tgBZCi6AoaDG0BFoKLYOWQyugldAqaDW0BloLrYPWQ9FQDBQLxUHxUAK0AdoIJUKboM3QFigJSoZSoFRoK5QGpUPboO3QDmgntAvaDe2B9kL7oP3QASgDOgiZoUNQJpQFcdBhyAIdgXjoKHQMskLZkADZIDuUAzmgXEiEnFAedBw6AeVDJ6FT0GnoDHQWOqem23mVksoLKi+qvKTyssorKq+qvKbyusobKm+qvKXytso7KtVUZS6VbpVd4tqjskDlPZWFKu+7ukz3wCRVx9qEXNEsiB8jDb7/GKXaGAdvtfKWjh8HBQa3VJnOCxYr53G5Zf9Xs6KPkQuykh2fFz6Z2ZIa/0aSdu2fEfXXxvxWuzv28z+ev9vb/+ucMttu5Vilx+UirKgmWrm7HeIezmHzuD2URbBKWfa/EGUUYbIq3xN9UQb1ZoVVbsoKq/zOZfi+YUYZDetYiL+VsypWRO2rrwHt7e3/qneK76YaO/6ScRNUQ89ptwPhq83zyB4t8XsSSks8pJPw3Tf5S8egaplQ8TnhTLtuw+WmzFpNuGVqkrhsmyM/UeBFT1CRwWjqExQcEhqm5IRynHFm0Wzo1fnJATg/72Q1hPug2ruJFLsc5Pmd1bDa79YsEx7DYKXlpGekViYsOpiy+1qtD7TmBC7WksB1OiVwMasjJXAdZUf1eiRwMasnJXC93glcz4qpffU14BcS+AX0MmAJ/LIXCay0hJTAxZQEfkGJmZe6JPALSgL34nDkAByOd7IGzfHawF5pjtcQpZ+kB+AVJV5DKLt/pXu8lmiJ19c6xWsJe02K19eUHTXqEa8lrJEUr416x2sjK6H21deAX4jXJqg5YPHa3It4VVpCitcSSrw2UWKmWZd4bdIjXpXDkQNwON7J3miO1zfsreZ4DVX6SXoA3lLiNZSy+7e6x2uplnht0SleS1kLKV5bKDtq1SNeS1krKV5b9Y7XVlZK7auvAb8Qr23Qu4DF67texKvSElK8llLitY0SM+90idc2PeJVORw5AIfjney95nh9zz5ojtcwpZ+kB+ADJV7DKLv/oPHoXZTKBkrlh3pUNlIqP9KjsolS+bEelftQKj/Ro3IQpfJTHR7uYO+7bL+1n+lQO8T7Fsdv7TIdaod6/4vjt3a5DrXDvD///dau0PgyOLiIPWSP2GP2hD1lz1gZK2cVNWmc6HQIHa+FPxke4mXxb+ERffv1HzBw0OAhQ4cNHzFy1OgxY8eNnxA5cdLkKVOnTZ8xc9bsOXPnzV+wcFHU4iVLly1fsXLV6jVr162PjomNi0/YsDFx0+YtSckpqVvT0rdt37Fz1+49e/ftP5Bx0HwoM4s7bDnCHz1mzRZs9hxHrujMO34i/+Sp02fOnmPnmcQusIvsErvMrrCr7Bq7zm6wm+wWu83usLvMxdxMZh5WwO6xQnafPVDeTBcr3+9LXa4CWSqPzuQdfeU//gxLjTc135rg+vrRiJ4fTez50eyuH8kNWbyDyxT5PC6DF/KU9hVJFZ2/aPNIlXGd/zRMqkoURM7COcq2Ry0i/Njqdv1QbdcbpLqO7zNZSqdibfZ8TGNQ14OJu1UyVSTwnDWLUKI+hhfMjvzO4Sn2gm8T9KmMz3Garbk9apqkyk3ObHviYRlDw7pXNxKrG39W3VAWx+dhNnUN5emize6W1W1/Owi5rWvzOo84I8dpE3lOEB90X164tjaYul8fEeA2hqsT/+Q8TDVfC3Y5FoN6Pj+5yliW5LR26Zvf4enOQz+YvSzJlif/4D7o1owIbOd/ADB48FElAAA=",
-  "debug_symbols": "ndPBjoMgFAXQf2HtQnig0l+ZTBpqaUNC0FCdZNL03+fp1U67MGnceFW8B0LkLs7+NF6PIV26mzh83cUphxjD9Ri71g2hS/z2/ijE+ngcsvf8SryMc6t32adBHNIYYyF+XBznj269S3MOLvNoWQifzpwMXkL0092j+G+X21VTreVKy2fdyLe+3O4TVWYBSOvmKSj56Qrq0i5ATbS1gs/6xu7oN6Vc+k2l98xf66Vvac/81tDat+at/81Prg357Z8Rhje3EJU48LT1fG3mq+VSIWSJkAiFIIRGGAQTFQcMCUTaORQUBUVBUVAUFAVFQVFQFBQFhaAQFIJCUAgKQSEoBIWgEBQNRUPRUDQUDUVD0ZPymHY6B3eKfjlilzG1Lydu+O3XkfVM9rlr/XnMftrpeYz3/g8=",
+  "debug_symbols": "ndPBjoMgFAXQf2HNQngPLf2VyaShljYkBA3VSSZN/33Qq5120aRx41XxHhXlJk7+OF4OIZ27q9h/3cQxhxjD5RC71g2hS+Xs7S7FengYsvfllHgaL63eZZ8GsU9jjFL8uDjOF117l+YcXC6jlRQ+nUoW8Byin/bu8r9dva+aei3XrB51ti999b5PZNQCEBM/BP3xEzSVXYCG6N0TfNY3dkN/V60vsKt5y/0bXvqWttzfGlr71rz0v8uRa0N++WeEKZMrRV0ukaKZt7t5a8vHlEJVCIXQCEIwwiAKUZeAoYAoO4eGoqFoKBqKhqKhaCgaioaioRAUgkJQCApBISgEhaAQFILCUBgKQ2EoDIWh8KTcp5nOwR2jX5bYeUzt04obfvt1ZF2Tfe5afxqzn2Z6Hitz/wc=",
   "file_map": {
-    "21": {
-      "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod vector;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nmod primitive_docs;\nmod internal;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle<T>(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained<T>(with_newline: bool, input: T) {\n    print_oracle(with_newline, input);\n}\n\n/// Print the given input to stdout followed by a newline\npub fn println<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(true, input);\n    }\n}\n\n/// Print the given input to stdout\npub fn print<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(false, input);\n    }\n}\n\n/// Asserts the validity of the provided proof and public inputs against the provided verification key and hash.\n///\n/// The ACVM cannot determine whether the provided proof is valid during execution as this requires knowledge of\n/// the backend against which the program is being proven. However if an invalid proof if submitted, the program may\n/// fail to prove or the backend may generate a proof which will subsequently fail to verify.\n///\n/// # Important Note\n///\n/// If you are not developing your own backend such as [Barretenberg](https://github.com/AztecProtocol/barretenberg)\n/// you probably shouldn't need to interact with this function directly. It's easier and safer to use a verification\n/// library which is published by the developers of the backend which will document or enforce any safety requirements.\n///\n/// If you use this directly, you're liable to introduce underconstrainedness bugs and *your circuit will be insecure*.\n///\n/// # Arguments\n/// - verification_key: The verification key of the circuit to be verified.\n/// - proof: The proof to be verified.\n/// - public_inputs: The public inputs associated with `proof`\n/// - key_hash: The hash of `verification_key` of the form expected by the backend.\n/// - proof_type: An identifier for the proving scheme used to generate the proof to be verified. This allows\n///               for a single backend to support verifying multiple proving schemes.\n///\n/// # Constraining `key_hash`\n///\n/// The Noir compiler does not by itself constrain that `key_hash` is a valid hash of `verification_key`.\n/// This is because different backends may differ in how they hash their verification keys.\n/// It is then the responsibility of either the noir developer (by explicitly hashing the verification key\n/// in the correct manner) or by the proving system itself internally asserting the correctness of `key_hash`.\npub fn verify_proof_with_type<let N: u32, let M: u32, let K: u32>(\n    verification_key: [Field; N],\n    proof: [Field; M],\n    public_inputs: [Field; K],\n    key_hash: Field,\n    proof_type: u32,\n) {\n    if !crate::runtime::is_unconstrained() {\n        crate::assert_constant(proof_type);\n    }\n    verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal<let N: u32, let M: u32, let K: u32>(\n    verification_key: [Field; N],\n    proof: [Field; M],\n    public_inputs: [Field; K],\n    key_hash: Field,\n    proof_type: u32,\n) {}\n\n/// Asserts that the given value is known at compile-time.\n/// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant<T>(x: T) {}\n\n/// Asserts that the given value is both true and known at compile-time.\n/// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert<T>(predicate: bool, message: T) {}\n\n/// Force a field value to be a witness instead of a constant in the compiled output.\n/// This is often only useful for debugging compiler optimizations.\n///\n/// This has no effect in unconstrained or comptime code.\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n",
+    "20": {
+      "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod vector;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nmod primitive_docs;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle<T>(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained<T>(with_newline: bool, input: T) {\n    print_oracle(with_newline, input);\n}\n\n/// Print the given input to stdout followed by a newline\npub fn println<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(true, input);\n    }\n}\n\n/// Print the given input to stdout\npub fn print<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(false, input);\n    }\n}\n\n/// Asserts the validity of the provided proof and public inputs against the provided verification key and hash.\n///\n/// The ACVM cannot determine whether the provided proof is valid during execution as this requires knowledge of\n/// the backend against which the program is being proven. However if an invalid proof if submitted, the program may\n/// fail to prove or the backend may generate a proof which will subsequently fail to verify.\n///\n/// # Important Note\n///\n/// If you are not developing your own backend such as [Barretenberg](https://github.com/AztecProtocol/barretenberg)\n/// you probably shouldn't need to interact with this function directly. It's easier and safer to use a verification\n/// library which is published by the developers of the backend which will document or enforce any safety requirements.\n///\n/// If you use this directly, you're liable to introduce underconstrainedness bugs and *your circuit will be insecure*.\n///\n/// # Arguments\n/// - verification_key: The verification key of the circuit to be verified.\n/// - proof: The proof to be verified.\n/// - public_inputs: The public inputs associated with `proof`\n/// - key_hash: The hash of `verification_key` of the form expected by the backend.\n/// - proof_type: An identifier for the proving scheme used to generate the proof to be verified. This allows\n///               for a single backend to support verifying multiple proving schemes.\n///\n/// # Constraining `key_hash`\n///\n/// The Noir compiler does not by itself constrain that `key_hash` is a valid hash of `verification_key`.\n/// This is because different backends may differ in how they hash their verification keys.\n/// It is then the responsibility of either the noir developer (by explicitly hashing the verification key\n/// in the correct manner) or by the proving system itself internally asserting the correctness of `key_hash`.\npub fn verify_proof_with_type<let N: u32, let M: u32, let K: u32>(\n    verification_key: [Field; N],\n    proof: [Field; M],\n    public_inputs: [Field; K],\n    key_hash: Field,\n    proof_type: u32,\n) {\n    if !crate::runtime::is_unconstrained() {\n        crate::assert_constant(proof_type);\n    }\n    verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal<let N: u32, let M: u32, let K: u32>(\n    verification_key: [Field; N],\n    proof: [Field; M],\n    public_inputs: [Field; K],\n    key_hash: Field,\n    proof_type: u32,\n) {}\n\n/// Asserts that the given value is known at compile-time.\n/// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant<T>(x: T) {}\n\n/// Asserts that the given value is both true and known at compile-time.\n/// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert<T>(predicate: bool, message: T) {}\n\n/// Force a field value to be a witness instead of a constant in the compiled output.\n/// This is often only useful for debugging compiler optimizations.\n///\n/// This has no effect in unconstrained or comptime code.\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n",
       "path": "std/lib.nr",
       "function_locations": [
         {
-          "start": 676,
+          "start": 662,
           "name": "print_oracle"
         },
         {
-          "start": 750,
+          "start": 736,
           "name": "print_unconstrained"
         },
         {
-          "start": 880,
+          "start": 866,
           "name": "println"
         },
         {
-          "start": 1063,
+          "start": 1049,
           "name": "print"
         },
         {
-          "start": 3264,
+          "start": 3250,
           "name": "verify_proof_with_type"
         },
         {
-          "start": 3681,
+          "start": 3667,
           "name": "verify_proof_internal"
         },
         {
-          "start": 3846,
+          "start": 3832,
           "name": "assert_constant"
         },
         {
-          "start": 4105,
+          "start": 4091,
           "name": "static_assert"
         },
         {
-          "start": 4376,
+          "start": 4362,
           "name": "as_witness"
         }
       ]
     },
-    "51": {
+    "49": {
       "source": "use mock_types::{\n    MAX_COMMITMENT_READ_REQUESTS_PER_TX, MAX_COMMITMENTS_PER_TX, MEGA_VK_LENGTH_IN_FIELDS,\n    PrivateKernelPublicInputs, PROOF_TYPE_HN, VerificationKey,\n};\n\n// Mock reset kernel that reset read requests.\n// It needs hints to locate the commitment that matches the read requests.\nfn main(\n    mut prev_kernel_public_inputs: call_data(0) PrivateKernelPublicInputs,\n    kernel_vk: VerificationKey<MEGA_VK_LENGTH_IN_FIELDS>,\n    commitment_read_hints: [u32; MAX_COMMITMENT_READ_REQUESTS_PER_TX],\n) -> return_data PrivateKernelPublicInputs {\n    std::verify_proof_with_type(kernel_vk.key, [], [], kernel_vk.hash, PROOF_TYPE_HN);\n\n    for i in 0..MAX_COMMITMENT_READ_REQUESTS_PER_TX {\n        if commitment_read_hints[i] != MAX_COMMITMENTS_PER_TX {\n            assert_eq(\n                prev_kernel_public_inputs.commitments[commitment_read_hints[i]],\n                prev_kernel_public_inputs.read_requests[i],\n            );\n            prev_kernel_public_inputs.read_requests[i] = 0;\n        }\n    }\n    prev_kernel_public_inputs\n}\n",
-      "path": "/home/aztec-dev/ubuntu/pub/noir-projects/mock-protocol-circuits/crates/mock-private-kernel-reset/src/main.nr",
+      "path": "/home/mitch/aztec-clones/alpha/noir-projects/mock-protocol-circuits/crates/mock-private-kernel-reset/src/main.nr",
       "function_locations": [
         {
           "start": 554,
@@ -330,5 +330,5 @@
     ],
     "hash": ""
   },
-  "aztec_version": "5.0.0-rc.1"
+  "aztec_version": "5.0.0-rc.2"
 }

package/artifacts/mock_private_kernel_tail.json

@@ -1,6 +1,6 @@
 {
-  "noir_version": "1.0.0-beta.22+c57152f91260ecdb9faad4efc20abb14b6d2ece7",
-  "hash": "9421392509151835911",
+  "noir_version": "1.0.0-beta.21+f1a4575adac59af0a86b036cf73ff5883d142a91",
+  "hash": "6042723548934015913",
   "abi": {
     "parameters": [
       {
@@ -90,53 +90,53 @@
     "error_types": {}
   },
   "bytecode": "H4sIAAAAAAAA/7XWN1MbQRwFcJmcc84555yTyDnndIhDCMQJTidyOnJGgQyFC8/YQ+XC47F7l/sRaOhcunFv0by1GyMKbfWbm/+91+zurKVed/VhhlFwD+LnCiUjm65QLVZrOJmUUSrFL+2sTMOrFfNsuVzOs3JGUKi4qyfJufixRyFwrFptDzlAjpAT5Ay5QK6QG+QOeUCekBfkDflAvpAf5A8FQIFQEBQMhUChUBgUDkVAkVAUFA3FQLFQHBQPJUCJUBKUDKVAqVAalA5lQJlQFpQN5UC5UB6UDxVAhVARVAyVQKVQGVQOVUBSqBKqgqqhGqgWqoPqoQaoEWqCmqEWqBVqg9qhDqgT6oK6oR6oF+qD+qEBaBAagoahEWgUYqAxSAaNQyw0AcmhSUgBTUHTkBKagThIBc1CcxAPqSEB0kDz0AK0CC1By9AKtAqtQevQBkQ2KUXKLcptyh3KXco9yn3KA8pDyiPKY8oTylPKM0p6qxItpY5ST2mgvKC8pLyivNb+FXdjJ36Sqji1wHDCjzDJ/9c78bHcuJd4oZ/lVQatTv/6H5JXRyRvD7U2R6iNOUJtzRFq99ZQvTE0bbyZf05/H/+tteqrKPYOxWX+rF36PquTPv82/HpJNaGY3Jqj2cKU5jtzNFua0nxvjmYrU5ofTGluYmdU/FIdpxAMlhfkltyRe/Lw2M4KGp6rZATmnwmrW8k7C0sraxvbl2NvfNK9TEieJPSzvYOjk7OLq5u7h6eXt4+vn39AYFBwSGhYeERkVHRMbFx8QmJSckpqWnpGZlZ2Tm5efkFhUXFJaVl5hbSyqrqmtq6+obGpuaW1rb2js6u7p7evf2BwaHhklBmTjbMT8knF1LRyhlPNzvFqQTO/sLi0vLK6tr5BNolItsg22SG7ZI/skwNySI7IMTkhp+SMnBMt0RE9MZALckmuyDW50RrXH1JJRmutCgAA",
-  "debug_symbols": "jZHBDoMgDIbfpWcOMkDNXmVZDGpdSAgaBksW47uvEnV6cNml0Jav/WlHaLGOj8q4rn/C9TZC7Y215lHZvtHB9I6i48RgdavgESkEuzxRg/boAlxdtJbBS9uYHj0H7dIZtKdsxgBdSycV7IzF+TaxL52do7IsF1gVcsMVP/D8nBciV0sBIWW5VbjwfxWoki8FcpGfKfjBF9n6/UId+Tt5ujH+MHPISBwDTnoZXGgADESyMllFdpqbeaNri8uWuuia3dLCe1gz61oH3zfYRo9zs5Sj9h8=",
+  "debug_symbols": "jZHNDoMgDMffpWcOOmC6vcqyGNS6kBA0DJYsxndfJTL14LJLoR+/9g8docU6PCptu/4J19sItdPG6Edl+kZ53VuKjhOD5FbeIVIINnmiBuXQerjaYAyDlzIhFj0HZePplaNsxgBtSyc17LTB+Taxlc6OUVGWCywL8cXFZcfnxzznMl8acMHXDqe/FcgyNTjz85GCH3yRpecXcs/fyVONdrs/h4zEMchJL4MTFTLg0YpoJdlpHua0qg0uW+qCbTZL8+8hZdJaB9c32AaH87CYo/Ef",
   "file_map": {
-    "21": {
-      "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod vector;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nmod primitive_docs;\nmod internal;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle<T>(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained<T>(with_newline: bool, input: T) {\n    print_oracle(with_newline, input);\n}\n\n/// Print the given input to stdout followed by a newline\npub fn println<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(true, input);\n    }\n}\n\n/// Print the given input to stdout\npub fn print<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(false, input);\n    }\n}\n\n/// Asserts the validity of the provided proof and public inputs against the provided verification key and hash.\n///\n/// The ACVM cannot determine whether the provided proof is valid during execution as this requires knowledge of\n/// the backend against which the program is being proven. However if an invalid proof if submitted, the program may\n/// fail to prove or the backend may generate a proof which will subsequently fail to verify.\n///\n/// # Important Note\n///\n/// If you are not developing your own backend such as [Barretenberg](https://github.com/AztecProtocol/barretenberg)\n/// you probably shouldn't need to interact with this function directly. It's easier and safer to use a verification\n/// library which is published by the developers of the backend which will document or enforce any safety requirements.\n///\n/// If you use this directly, you're liable to introduce underconstrainedness bugs and *your circuit will be insecure*.\n///\n/// # Arguments\n/// - verification_key: The verification key of the circuit to be verified.\n/// - proof: The proof to be verified.\n/// - public_inputs: The public inputs associated with `proof`\n/// - key_hash: The hash of `verification_key` of the form expected by the backend.\n/// - proof_type: An identifier for the proving scheme used to generate the proof to be verified. This allows\n///               for a single backend to support verifying multiple proving schemes.\n///\n/// # Constraining `key_hash`\n///\n/// The Noir compiler does not by itself constrain that `key_hash` is a valid hash of `verification_key`.\n/// This is because different backends may differ in how they hash their verification keys.\n/// It is then the responsibility of either the noir developer (by explicitly hashing the verification key\n/// in the correct manner) or by the proving system itself internally asserting the correctness of `key_hash`.\npub fn verify_proof_with_type<let N: u32, let M: u32, let K: u32>(\n    verification_key: [Field; N],\n    proof: [Field; M],\n    public_inputs: [Field; K],\n    key_hash: Field,\n    proof_type: u32,\n) {\n    if !crate::runtime::is_unconstrained() {\n        crate::assert_constant(proof_type);\n    }\n    verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal<let N: u32, let M: u32, let K: u32>(\n    verification_key: [Field; N],\n    proof: [Field; M],\n    public_inputs: [Field; K],\n    key_hash: Field,\n    proof_type: u32,\n) {}\n\n/// Asserts that the given value is known at compile-time.\n/// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant<T>(x: T) {}\n\n/// Asserts that the given value is both true and known at compile-time.\n/// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert<T>(predicate: bool, message: T) {}\n\n/// Force a field value to be a witness instead of a constant in the compiled output.\n/// This is often only useful for debugging compiler optimizations.\n///\n/// This has no effect in unconstrained or comptime code.\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n",
+    "20": {
+      "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod vector;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nmod primitive_docs;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle<T>(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained<T>(with_newline: bool, input: T) {\n    print_oracle(with_newline, input);\n}\n\n/// Print the given input to stdout followed by a newline\npub fn println<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(true, input);\n    }\n}\n\n/// Print the given input to stdout\npub fn print<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(false, input);\n    }\n}\n\n/// Asserts the validity of the provided proof and public inputs against the provided verification key and hash.\n///\n/// The ACVM cannot determine whether the provided proof is valid during execution as this requires knowledge of\n/// the backend against which the program is being proven. However if an invalid proof if submitted, the program may\n/// fail to prove or the backend may generate a proof which will subsequently fail to verify.\n///\n/// # Important Note\n///\n/// If you are not developing your own backend such as [Barretenberg](https://github.com/AztecProtocol/barretenberg)\n/// you probably shouldn't need to interact with this function directly. It's easier and safer to use a verification\n/// library which is published by the developers of the backend which will document or enforce any safety requirements.\n///\n/// If you use this directly, you're liable to introduce underconstrainedness bugs and *your circuit will be insecure*.\n///\n/// # Arguments\n/// - verification_key: The verification key of the circuit to be verified.\n/// - proof: The proof to be verified.\n/// - public_inputs: The public inputs associated with `proof`\n/// - key_hash: The hash of `verification_key` of the form expected by the backend.\n/// - proof_type: An identifier for the proving scheme used to generate the proof to be verified. This allows\n///               for a single backend to support verifying multiple proving schemes.\n///\n/// # Constraining `key_hash`\n///\n/// The Noir compiler does not by itself constrain that `key_hash` is a valid hash of `verification_key`.\n/// This is because different backends may differ in how they hash their verification keys.\n/// It is then the responsibility of either the noir developer (by explicitly hashing the verification key\n/// in the correct manner) or by the proving system itself internally asserting the correctness of `key_hash`.\npub fn verify_proof_with_type<let N: u32, let M: u32, let K: u32>(\n    verification_key: [Field; N],\n    proof: [Field; M],\n    public_inputs: [Field; K],\n    key_hash: Field,\n    proof_type: u32,\n) {\n    if !crate::runtime::is_unconstrained() {\n        crate::assert_constant(proof_type);\n    }\n    verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal<let N: u32, let M: u32, let K: u32>(\n    verification_key: [Field; N],\n    proof: [Field; M],\n    public_inputs: [Field; K],\n    key_hash: Field,\n    proof_type: u32,\n) {}\n\n/// Asserts that the given value is known at compile-time.\n/// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant<T>(x: T) {}\n\n/// Asserts that the given value is both true and known at compile-time.\n/// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert<T>(predicate: bool, message: T) {}\n\n/// Force a field value to be a witness instead of a constant in the compiled output.\n/// This is often only useful for debugging compiler optimizations.\n///\n/// This has no effect in unconstrained or comptime code.\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n",
       "path": "std/lib.nr",
       "function_locations": [
         {
-          "start": 676,
+          "start": 662,
           "name": "print_oracle"
         },
         {
-          "start": 750,
+          "start": 736,
           "name": "print_unconstrained"
         },
         {
-          "start": 880,
+          "start": 866,
           "name": "println"
         },
         {
-          "start": 1063,
+          "start": 1049,
           "name": "print"
         },
         {
-          "start": 3264,
+          "start": 3250,
           "name": "verify_proof_with_type"
         },
         {
-          "start": 3681,
+          "start": 3667,
           "name": "verify_proof_internal"
         },
         {
-          "start": 3846,
+          "start": 3832,
           "name": "assert_constant"
         },
         {
-          "start": 4105,
+          "start": 4091,
           "name": "static_assert"
         },
         {
-          "start": 4376,
+          "start": 4362,
           "name": "as_witness"
         }
       ]
     },
-    "51": {
+    "49": {
       "source": "use mock_types::{\n    KernelPublicInputs, MAX_COMMITMENT_READ_REQUESTS_PER_TX, MEGA_VK_LENGTH_IN_FIELDS,\n    PrivateKernelPublicInputs, PROOF_TYPE_HN_TAIL, VerificationKey,\n};\n\n// The tail kernel finishes the chonk chain exposing the final public inputs with no remaining calls or unfulfilled read requests.\nfn main(\n    prev_kernel_public_inputs: call_data(0) PrivateKernelPublicInputs,\n    kernel_vk: VerificationKey<MEGA_VK_LENGTH_IN_FIELDS>,\n) -> return_data KernelPublicInputs {\n    std::verify_proof_with_type(kernel_vk.key, [], [], kernel_vk.hash, PROOF_TYPE_HN_TAIL);\n\n    assert_eq(prev_kernel_public_inputs.remaining_calls, 0);\n    for i in 0..MAX_COMMITMENT_READ_REQUESTS_PER_TX {\n        assert_eq(prev_kernel_public_inputs.read_requests[i], 0);\n    }\n\n    KernelPublicInputs { commitments: prev_kernel_public_inputs.commitments }\n}\n",
-      "path": "/home/aztec-dev/ubuntu/pub/noir-projects/mock-protocol-circuits/crates/mock-private-kernel-tail/src/main.nr",
+      "path": "/home/mitch/aztec-clones/alpha/noir-projects/mock-protocol-circuits/crates/mock-private-kernel-tail/src/main.nr",
       "function_locations": [
         {
           "start": 482,
@@ -294,5 +294,5 @@
     ],
     "hash": ""
   },
-  "aztec_version": "5.0.0-rc.1"
+  "aztec_version": "5.0.0-rc.2"
 }

package/artifacts/mock_rollup_root.json

@@ -1,6 +1,6 @@
 {
-  "noir_version": "1.0.0-beta.22+c57152f91260ecdb9faad4efc20abb14b6d2ece7",
-  "hash": "8967159490919717988",
+  "noir_version": "1.0.0-beta.21+f1a4575adac59af0a86b036cf73ff5883d142a91",
+  "hash": "1299815907967016143",
   "abi": {
     "parameters": [
       {
@@ -153,53 +153,53 @@
     }
   },
   "bytecode": "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",
-  "debug_symbols": "tZTbioMwEIbfJddeZCYn7assS0ltWgIhSqoLS+m7bxTj4SIiyF7FZPy/yWR+5k3u5tY/r9Y/mhe5fL3JLVjn7PPqmlp3tvHx9P0pSNpeu2BMPCKreFS1OhjfkYvvnSvIj3b9+NOr1X5cOx1ilBbE+HtcI/BhnRm+PsWipnkpcDGJQbBZLmCjh7yeS64mAJdltRBwQ8AdAgIkAqqFgJRvECyPYIonBCuBZhF8B4GySggscYWQxxFCzghZZhEyj0CWWolifQd1uB2KYnrMSmXbUe5UwWRyBON8VQUcttQMAJW3FD3tKYDzpgI87ypg5221zzjmKxCnjUVPOwvUv1qrTC+BtMpaq9qpIj5mqoJJ2FTxHXe6tmEzogmSS+SxIXdB+JC4IGJYPkOWYPXNmWmWP3pfr0Z799umSBr+bWhqc++DGXKMsZj1Dw==",
+  "debug_symbols": "tZTbioMwEIbfJddeZCYn7assS0ltWgIhSqoLi/TdN4qxehERZK9iMs43p58ZyN3c+ufV+kfzIpevgdyCdc4+r66pdWcbH1+Hd0HS9doFY+ITWdmjV6uD8R25+N65gvxo108/vVrtp7PTIVppQYy/xzMCH9aZ8etdfLxp3hW4mJ1BsMWdVxt/yPtzydUM4LKsFoLYZoA7BARIBFQfAlLcIFgewRRPCFYCzSL4DgJllRBY4grBjyOEXBCyzCJkHoEsjRLFOgdxeByKYmpmpbLjKHeqYGLpJWd8lcRhSclFUiovKXpaUwDnRQV4XlXAzstqn3FMVyBOC4ueVhaof5VWmTqBtMpKq9qpIjYzVcEkbKr4jjdd27BZ0QTJJfLYGLsgfAxcEDHlPEYJVt+cmXf5o/f1arV3v22ypOXfhqY29z6YMcZki1H/AA==",
   "file_map": {
-    "21": {
-      "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod vector;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nmod primitive_docs;\nmod internal;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle<T>(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained<T>(with_newline: bool, input: T) {\n    print_oracle(with_newline, input);\n}\n\n/// Print the given input to stdout followed by a newline\npub fn println<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(true, input);\n    }\n}\n\n/// Print the given input to stdout\npub fn print<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(false, input);\n    }\n}\n\n/// Asserts the validity of the provided proof and public inputs against the provided verification key and hash.\n///\n/// The ACVM cannot determine whether the provided proof is valid during execution as this requires knowledge of\n/// the backend against which the program is being proven. However if an invalid proof if submitted, the program may\n/// fail to prove or the backend may generate a proof which will subsequently fail to verify.\n///\n/// # Important Note\n///\n/// If you are not developing your own backend such as [Barretenberg](https://github.com/AztecProtocol/barretenberg)\n/// you probably shouldn't need to interact with this function directly. It's easier and safer to use a verification\n/// library which is published by the developers of the backend which will document or enforce any safety requirements.\n///\n/// If you use this directly, you're liable to introduce underconstrainedness bugs and *your circuit will be insecure*.\n///\n/// # Arguments\n/// - verification_key: The verification key of the circuit to be verified.\n/// - proof: The proof to be verified.\n/// - public_inputs: The public inputs associated with `proof`\n/// - key_hash: The hash of `verification_key` of the form expected by the backend.\n/// - proof_type: An identifier for the proving scheme used to generate the proof to be verified. This allows\n///               for a single backend to support verifying multiple proving schemes.\n///\n/// # Constraining `key_hash`\n///\n/// The Noir compiler does not by itself constrain that `key_hash` is a valid hash of `verification_key`.\n/// This is because different backends may differ in how they hash their verification keys.\n/// It is then the responsibility of either the noir developer (by explicitly hashing the verification key\n/// in the correct manner) or by the proving system itself internally asserting the correctness of `key_hash`.\npub fn verify_proof_with_type<let N: u32, let M: u32, let K: u32>(\n    verification_key: [Field; N],\n    proof: [Field; M],\n    public_inputs: [Field; K],\n    key_hash: Field,\n    proof_type: u32,\n) {\n    if !crate::runtime::is_unconstrained() {\n        crate::assert_constant(proof_type);\n    }\n    verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal<let N: u32, let M: u32, let K: u32>(\n    verification_key: [Field; N],\n    proof: [Field; M],\n    public_inputs: [Field; K],\n    key_hash: Field,\n    proof_type: u32,\n) {}\n\n/// Asserts that the given value is known at compile-time.\n/// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant<T>(x: T) {}\n\n/// Asserts that the given value is both true and known at compile-time.\n/// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert<T>(predicate: bool, message: T) {}\n\n/// Force a field value to be a witness instead of a constant in the compiled output.\n/// This is often only useful for debugging compiler optimizations.\n///\n/// This has no effect in unconstrained or comptime code.\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n",
+    "20": {
+      "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod vector;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nmod primitive_docs;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle<T>(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained<T>(with_newline: bool, input: T) {\n    print_oracle(with_newline, input);\n}\n\n/// Print the given input to stdout followed by a newline\npub fn println<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(true, input);\n    }\n}\n\n/// Print the given input to stdout\npub fn print<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(false, input);\n    }\n}\n\n/// Asserts the validity of the provided proof and public inputs against the provided verification key and hash.\n///\n/// The ACVM cannot determine whether the provided proof is valid during execution as this requires knowledge of\n/// the backend against which the program is being proven. However if an invalid proof if submitted, the program may\n/// fail to prove or the backend may generate a proof which will subsequently fail to verify.\n///\n/// # Important Note\n///\n/// If you are not developing your own backend such as [Barretenberg](https://github.com/AztecProtocol/barretenberg)\n/// you probably shouldn't need to interact with this function directly. It's easier and safer to use a verification\n/// library which is published by the developers of the backend which will document or enforce any safety requirements.\n///\n/// If you use this directly, you're liable to introduce underconstrainedness bugs and *your circuit will be insecure*.\n///\n/// # Arguments\n/// - verification_key: The verification key of the circuit to be verified.\n/// - proof: The proof to be verified.\n/// - public_inputs: The public inputs associated with `proof`\n/// - key_hash: The hash of `verification_key` of the form expected by the backend.\n/// - proof_type: An identifier for the proving scheme used to generate the proof to be verified. This allows\n///               for a single backend to support verifying multiple proving schemes.\n///\n/// # Constraining `key_hash`\n///\n/// The Noir compiler does not by itself constrain that `key_hash` is a valid hash of `verification_key`.\n/// This is because different backends may differ in how they hash their verification keys.\n/// It is then the responsibility of either the noir developer (by explicitly hashing the verification key\n/// in the correct manner) or by the proving system itself internally asserting the correctness of `key_hash`.\npub fn verify_proof_with_type<let N: u32, let M: u32, let K: u32>(\n    verification_key: [Field; N],\n    proof: [Field; M],\n    public_inputs: [Field; K],\n    key_hash: Field,\n    proof_type: u32,\n) {\n    if !crate::runtime::is_unconstrained() {\n        crate::assert_constant(proof_type);\n    }\n    verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal<let N: u32, let M: u32, let K: u32>(\n    verification_key: [Field; N],\n    proof: [Field; M],\n    public_inputs: [Field; K],\n    key_hash: Field,\n    proof_type: u32,\n) {}\n\n/// Asserts that the given value is known at compile-time.\n/// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant<T>(x: T) {}\n\n/// Asserts that the given value is both true and known at compile-time.\n/// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert<T>(predicate: bool, message: T) {}\n\n/// Force a field value to be a witness instead of a constant in the compiled output.\n/// This is often only useful for debugging compiler optimizations.\n///\n/// This has no effect in unconstrained or comptime code.\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n",
       "path": "std/lib.nr",
       "function_locations": [
         {
-          "start": 676,
+          "start": 662,
           "name": "print_oracle"
         },
         {
-          "start": 750,
+          "start": 736,
           "name": "print_unconstrained"
         },
         {
-          "start": 880,
+          "start": 866,
           "name": "println"
         },
         {
-          "start": 1063,
+          "start": 1049,
           "name": "print"
         },
         {
-          "start": 3264,
+          "start": 3250,
           "name": "verify_proof_with_type"
         },
         {
-          "start": 3681,
+          "start": 3667,
           "name": "verify_proof_internal"
         },
         {
-          "start": 3846,
+          "start": 3832,
           "name": "assert_constant"
         },
         {
-          "start": 4105,
+          "start": 4091,
           "name": "static_assert"
         },
         {
-          "start": 4376,
+          "start": 4362,
           "name": "as_witness"
         }
       ]
     },
-    "51": {
+    "49": {
       "source": "use mock_types::{PreviousRollupData, RollupPublicInputs};\n\nfn main(a: PreviousRollupData, b: PreviousRollupData) -> pub RollupPublicInputs {\n    a.verify(true);\n    b.verify(true);\n\n    a.public_inputs().merge(b.public_inputs())\n}\n",
-      "path": "/home/aztec-dev/ubuntu/pub/noir-projects/mock-protocol-circuits/crates/mock-rollup-root/src/main.nr",
+      "path": "/home/mitch/aztec-clones/alpha/noir-projects/mock-protocol-circuits/crates/mock-rollup-root/src/main.nr",
       "function_locations": [
         {
           "start": 139,
@@ -207,9 +207,9 @@
         }
       ]
     },
-    "52": {
+    "50": {
       "source": "pub global MAX_COMMITMENTS_PER_CALL: u32 = 2;\npub global MAX_COMMITMENTS_PER_TX: u32 = 4;\npub global MAX_COMMITMENT_READ_REQUESTS_PER_CALL: u32 = 2;\npub global MAX_COMMITMENT_READ_REQUESTS_PER_TX: u32 = 4;\n\npub use protocol_types::{\n    abis::avm_circuit_public_inputs::AvmCircuitPublicInputs,\n    constants::{\n        AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED,\n        CHONK_PROOF_LENGTH, CHONK_VK_LENGTH_IN_FIELDS, MEGA_VK_LENGTH_IN_FIELDS,\n        NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, PROOF_TYPE_AVM, PROOF_TYPE_CHONK, PROOF_TYPE_HN,\n        PROOF_TYPE_HN_FINAL, PROOF_TYPE_HN_TAIL, PROOF_TYPE_OINK, PROOF_TYPE_ROLLUP_HONK,\n        PROOF_TYPE_ROOT_ROLLUP_HONK,\n    },\n    proof::{\n        traits::SerializeToColumns,\n        verification_key::{RollupHonkVerificationKey, VerificationKey},\n    },\n    traits::Serialize,\n};\n\npub struct TxRequest {\n    pub number_of_calls: u32,\n}\n\npub struct AppPublicInputs {\n    pub commitments: [Field; MAX_COMMITMENTS_PER_CALL],\n    pub read_requests: [Field; MAX_COMMITMENT_READ_REQUESTS_PER_CALL],\n}\n\nimpl Default for AppPublicInputs {\n    fn default() -> Self {\n        Self {\n            commitments: [0; MAX_COMMITMENTS_PER_CALL],\n            read_requests: [0; MAX_COMMITMENT_READ_REQUESTS_PER_CALL],\n        }\n    }\n}\n\npub struct PrivateKernelPublicInputs {\n    pub remaining_calls: u32,\n    pub commitments: [Field; MAX_COMMITMENTS_PER_TX],\n    pub read_requests: [Field; MAX_COMMITMENT_READ_REQUESTS_PER_TX],\n}\n\nimpl Default for PrivateKernelPublicInputs {\n    fn default() -> Self {\n        Self {\n            remaining_calls: 0,\n            commitments: [0; MAX_COMMITMENTS_PER_TX],\n            read_requests: [0; MAX_COMMITMENT_READ_REQUESTS_PER_TX],\n        }\n    }\n}\n\npub struct PrivateKernelPublicInputsBuilder {\n    pub remaining_calls: u32,\n    pub commitments: BoundedVec<Field, MAX_COMMITMENTS_PER_TX>,\n    pub read_requests: BoundedVec<Field, MAX_COMMITMENT_READ_REQUESTS_PER_TX>,\n}\n\nimpl PrivateKernelPublicInputsBuilder {\n    pub fn from_tx(tx: TxRequest) -> Self {\n        Self {\n            remaining_calls: tx.number_of_calls,\n            commitments: BoundedVec::new(),\n            read_requests: BoundedVec::new(),\n        }\n    }\n\n    pub fn from_previous_kernel(prev_kernel_public_inputs: PrivateKernelPublicInputs) -> Self {\n        let mut builder = PrivateKernelPublicInputsBuilder {\n            remaining_calls: prev_kernel_public_inputs.remaining_calls,\n            commitments: BoundedVec::new(),\n            read_requests: BoundedVec::new(),\n        };\n        for i in 0..MAX_COMMITMENTS_PER_TX {\n            if prev_kernel_public_inputs.commitments[i] != 0 {\n                builder.commitments.push(prev_kernel_public_inputs.commitments[i]);\n            }\n        }\n        for i in 0..MAX_COMMITMENT_READ_REQUESTS_PER_TX {\n            if prev_kernel_public_inputs.read_requests[i] != 0 {\n                builder.read_requests.push(prev_kernel_public_inputs.read_requests[i]);\n            }\n        }\n        builder\n    }\n\n    pub fn ingest_app_inputs(&mut self, app_inputs: AppPublicInputs) {\n        for i in 0..MAX_COMMITMENTS_PER_CALL {\n            if app_inputs.commitments[i] != 0 {\n                self.commitments.push(app_inputs.commitments[i]);\n            }\n        }\n\n        for i in 0..MAX_COMMITMENT_READ_REQUESTS_PER_CALL {\n            if app_inputs.read_requests[i] != 0 {\n                self.read_requests.push(app_inputs.read_requests[i]);\n            }\n        }\n\n        self.remaining_calls -= 1;\n    }\n\n    pub fn finish(self) -> PrivateKernelPublicInputs {\n        PrivateKernelPublicInputs {\n            remaining_calls: self.remaining_calls,\n            commitments: self.commitments.storage(),\n            read_requests: self.read_requests.storage(),\n        }\n    }\n}\n\n#[derive(Serialize)]\npub struct KernelPublicInputs {\n    pub commitments: [Field; MAX_COMMITMENTS_PER_TX],\n}\n\nimpl Default for KernelPublicInputs {\n    fn default() -> Self {\n        Self { commitments: [0; MAX_COMMITMENTS_PER_TX] }\n    }\n}\n\n#[derive(Serialize)]\npub struct RollupPublicInputs {\n    accumulated: u32,\n}\n\nimpl RollupPublicInputs {\n    pub fn new(accumulated: u32) -> Self {\n        Self { accumulated }\n    }\n\n    pub fn merge(self, other: Self) -> Self {\n        Self { accumulated: self.accumulated + other.accumulated }\n    }\n}\n\npub struct PreviousRollupData {\n    base_or_merge_public_inputs: RollupPublicInputs,\n    proof: [Field; NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH],\n    vk: RollupHonkVerificationKey,\n}\n\nimpl PreviousRollupData {\n    pub fn verify(self, is_root: bool) {\n        let inputs = self.base_or_merge_public_inputs.serialize();\n\n        std::verify_proof_with_type(\n            self.vk.key,\n            self.proof,\n            inputs,\n            self.vk.hash,\n            if is_root {\n                PROOF_TYPE_ROOT_ROLLUP_HONK\n            } else {\n                PROOF_TYPE_ROLLUP_HONK\n            },\n        );\n    }\n\n    pub fn public_inputs(self) -> RollupPublicInputs {\n        self.base_or_merge_public_inputs\n    }\n}\n\n// CHONK: \"Client Honk\" - An UltraHonk variant with incremental folding and delayed non-native arithmetic.\npub struct ChonkProofData {\n    pub public_inputs: KernelPublicInputs,\n    pub proof: [Field; CHONK_PROOF_LENGTH],\n    pub vk_data: VerificationKey<CHONK_VK_LENGTH_IN_FIELDS>,\n}\n\nimpl ChonkProofData {\n    pub fn verify(self) {\n        let inputs = KernelPublicInputs::serialize(self.public_inputs);\n        std::verify_proof_with_type(\n            self.vk_data.key,\n            self.proof,\n            inputs,\n            self.vk_data.hash,\n            PROOF_TYPE_CHONK,\n        );\n    }\n}\n",
-      "path": "/home/aztec-dev/ubuntu/pub/noir-projects/mock-protocol-circuits/crates/mock-types/src/lib.nr",
+      "path": "/home/mitch/aztec-clones/alpha/noir-projects/mock-protocol-circuits/crates/mock-types/src/lib.nr",
       "function_locations": [
         {
           "start": 1151,
@@ -327,5 +327,5 @@
     ],
     "hash": "01786c33cc1da8606b46ccd4ed4335d11fdfbe1dc0ffaf6d7b57aa0f2715b01a"
   },
-  "aztec_version": "5.0.0-rc.1"
+  "aztec_version": "5.0.0-rc.2"
 }

package/artifacts/mock_rollup_tx_base_private.json

@@ -1,6 +1,6 @@
 {
-  "noir_version": "1.0.0-beta.22+c57152f91260ecdb9faad4efc20abb14b6d2ece7",
-  "hash": "8932729433657314437",
+  "noir_version": "1.0.0-beta.21+f1a4575adac59af0a86b036cf73ff5883d142a91",
+  "hash": "13404248160295009019",
   "abi": {
     "parameters": [
       {
@@ -88,53 +88,53 @@
     "error_types": {}
   },
   "bytecode": "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",
-  "debug_symbols": "nZPLqoMwEIbfJWsXucf0VQ4HiRpLIERJtXCQvvsZxXhZpJSucpn8X4b5Z2bU2nq6Vy50/QPdfmZUR+e9u1e+b8zo+gC386tA6ViN0Vq4Qqc4qAYTbRjRLUzeF+hp/LQ+egwmrOtoIkRxgWxoYQVg57xddq/iUOO8lFC9iYmgu1yQi57k9YLzcgMIrtVBoBcCzRM4JWQjcKr0TqCYXxAsj2CKJwQrCc4ieB6hJU6F0JLIE0J+hWAsi5BvqikxTdWUhGcRKo+gLHUDPRlKsfrYUYHVnkOJc47qN3YwKZId0B5HEtBVv3AyjYuXOUAYMlp+eproTO3tNhzdFJrTrIx/Q4qkaRpi39h2inbhrTH44R8=",
+  "debug_symbols": "nZNNjoQgEIXvwtoFFAU2fZXJxKBih4SgobWTifHug0YcXdCZ9Iqf4n0U9aiZtKaeHpX1Xf8k96+Z1ME6Zx+V6xs92t7H3XkpSFpWYzAmbpFTPKoGHYwfyd1PzhXkpd20HXoO2m/jqEOM0oIY38YxAjvrzDpbij81zUsZqF3MBBxyVBc9y+sF4m0HCFTlQRDXDCBPQGBsJyCU6iAAhQuC5xG8xITgN0azCMwjlKSpEEoyeULgRwjOswj5ppqSQqqmZJhFlHkE8PQb4GQoUPFvRwUtjxxuNOeoemMHF4cdyM+vWJbvuNKNDZc+IDRmtN700sHq2pm9ObrJN6deGX+GFEndNIS+Me0UzMrbYvGGXw==",
   "file_map": {
-    "21": {
-      "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod vector;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nmod primitive_docs;\nmod internal;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle<T>(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained<T>(with_newline: bool, input: T) {\n    print_oracle(with_newline, input);\n}\n\n/// Print the given input to stdout followed by a newline\npub fn println<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(true, input);\n    }\n}\n\n/// Print the given input to stdout\npub fn print<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(false, input);\n    }\n}\n\n/// Asserts the validity of the provided proof and public inputs against the provided verification key and hash.\n///\n/// The ACVM cannot determine whether the provided proof is valid during execution as this requires knowledge of\n/// the backend against which the program is being proven. However if an invalid proof if submitted, the program may\n/// fail to prove or the backend may generate a proof which will subsequently fail to verify.\n///\n/// # Important Note\n///\n/// If you are not developing your own backend such as [Barretenberg](https://github.com/AztecProtocol/barretenberg)\n/// you probably shouldn't need to interact with this function directly. It's easier and safer to use a verification\n/// library which is published by the developers of the backend which will document or enforce any safety requirements.\n///\n/// If you use this directly, you're liable to introduce underconstrainedness bugs and *your circuit will be insecure*.\n///\n/// # Arguments\n/// - verification_key: The verification key of the circuit to be verified.\n/// - proof: The proof to be verified.\n/// - public_inputs: The public inputs associated with `proof`\n/// - key_hash: The hash of `verification_key` of the form expected by the backend.\n/// - proof_type: An identifier for the proving scheme used to generate the proof to be verified. This allows\n///               for a single backend to support verifying multiple proving schemes.\n///\n/// # Constraining `key_hash`\n///\n/// The Noir compiler does not by itself constrain that `key_hash` is a valid hash of `verification_key`.\n/// This is because different backends may differ in how they hash their verification keys.\n/// It is then the responsibility of either the noir developer (by explicitly hashing the verification key\n/// in the correct manner) or by the proving system itself internally asserting the correctness of `key_hash`.\npub fn verify_proof_with_type<let N: u32, let M: u32, let K: u32>(\n    verification_key: [Field; N],\n    proof: [Field; M],\n    public_inputs: [Field; K],\n    key_hash: Field,\n    proof_type: u32,\n) {\n    if !crate::runtime::is_unconstrained() {\n        crate::assert_constant(proof_type);\n    }\n    verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal<let N: u32, let M: u32, let K: u32>(\n    verification_key: [Field; N],\n    proof: [Field; M],\n    public_inputs: [Field; K],\n    key_hash: Field,\n    proof_type: u32,\n) {}\n\n/// Asserts that the given value is known at compile-time.\n/// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant<T>(x: T) {}\n\n/// Asserts that the given value is both true and known at compile-time.\n/// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert<T>(predicate: bool, message: T) {}\n\n/// Force a field value to be a witness instead of a constant in the compiled output.\n/// This is often only useful for debugging compiler optimizations.\n///\n/// This has no effect in unconstrained or comptime code.\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n",
+    "20": {
+      "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod vector;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nmod primitive_docs;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle<T>(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained<T>(with_newline: bool, input: T) {\n    print_oracle(with_newline, input);\n}\n\n/// Print the given input to stdout followed by a newline\npub fn println<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(true, input);\n    }\n}\n\n/// Print the given input to stdout\npub fn print<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(false, input);\n    }\n}\n\n/// Asserts the validity of the provided proof and public inputs against the provided verification key and hash.\n///\n/// The ACVM cannot determine whether the provided proof is valid during execution as this requires knowledge of\n/// the backend against which the program is being proven. However if an invalid proof if submitted, the program may\n/// fail to prove or the backend may generate a proof which will subsequently fail to verify.\n///\n/// # Important Note\n///\n/// If you are not developing your own backend such as [Barretenberg](https://github.com/AztecProtocol/barretenberg)\n/// you probably shouldn't need to interact with this function directly. It's easier and safer to use a verification\n/// library which is published by the developers of the backend which will document or enforce any safety requirements.\n///\n/// If you use this directly, you're liable to introduce underconstrainedness bugs and *your circuit will be insecure*.\n///\n/// # Arguments\n/// - verification_key: The verification key of the circuit to be verified.\n/// - proof: The proof to be verified.\n/// - public_inputs: The public inputs associated with `proof`\n/// - key_hash: The hash of `verification_key` of the form expected by the backend.\n/// - proof_type: An identifier for the proving scheme used to generate the proof to be verified. This allows\n///               for a single backend to support verifying multiple proving schemes.\n///\n/// # Constraining `key_hash`\n///\n/// The Noir compiler does not by itself constrain that `key_hash` is a valid hash of `verification_key`.\n/// This is because different backends may differ in how they hash their verification keys.\n/// It is then the responsibility of either the noir developer (by explicitly hashing the verification key\n/// in the correct manner) or by the proving system itself internally asserting the correctness of `key_hash`.\npub fn verify_proof_with_type<let N: u32, let M: u32, let K: u32>(\n    verification_key: [Field; N],\n    proof: [Field; M],\n    public_inputs: [Field; K],\n    key_hash: Field,\n    proof_type: u32,\n) {\n    if !crate::runtime::is_unconstrained() {\n        crate::assert_constant(proof_type);\n    }\n    verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal<let N: u32, let M: u32, let K: u32>(\n    verification_key: [Field; N],\n    proof: [Field; M],\n    public_inputs: [Field; K],\n    key_hash: Field,\n    proof_type: u32,\n) {}\n\n/// Asserts that the given value is known at compile-time.\n/// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant<T>(x: T) {}\n\n/// Asserts that the given value is both true and known at compile-time.\n/// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert<T>(predicate: bool, message: T) {}\n\n/// Force a field value to be a witness instead of a constant in the compiled output.\n/// This is often only useful for debugging compiler optimizations.\n///\n/// This has no effect in unconstrained or comptime code.\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n",
       "path": "std/lib.nr",
       "function_locations": [
         {
-          "start": 676,
+          "start": 662,
           "name": "print_oracle"
         },
         {
-          "start": 750,
+          "start": 736,
           "name": "print_unconstrained"
         },
         {
-          "start": 880,
+          "start": 866,
           "name": "println"
         },
         {
-          "start": 1063,
+          "start": 1049,
           "name": "print"
         },
         {
-          "start": 3264,
+          "start": 3250,
           "name": "verify_proof_with_type"
         },
         {
-          "start": 3681,
+          "start": 3667,
           "name": "verify_proof_internal"
         },
         {
-          "start": 3846,
+          "start": 3832,
           "name": "assert_constant"
         },
         {
-          "start": 4105,
+          "start": 4091,
           "name": "static_assert"
         },
         {
-          "start": 4376,
+          "start": 4362,
           "name": "as_witness"
         }
       ]
     },
-    "51": {
+    "49": {
       "source": "use mock_types::{ChonkProofData, RollupPublicInputs};\n\nfn main(chonk_proof_data: ChonkProofData) -> pub RollupPublicInputs {\n    chonk_proof_data.verify();\n    RollupPublicInputs::new(1)\n}\n",
-      "path": "/home/aztec-dev/ubuntu/pub/noir-projects/mock-protocol-circuits/crates/mock-rollup-tx-base-private/src/main.nr",
+      "path": "/home/mitch/aztec-clones/alpha/noir-projects/mock-protocol-circuits/crates/mock-rollup-tx-base-private/src/main.nr",
       "function_locations": [
         {
           "start": 123,
@@ -142,9 +142,9 @@
         }
       ]
     },
-    "52": {
+    "50": {
       "source": "pub global MAX_COMMITMENTS_PER_CALL: u32 = 2;\npub global MAX_COMMITMENTS_PER_TX: u32 = 4;\npub global MAX_COMMITMENT_READ_REQUESTS_PER_CALL: u32 = 2;\npub global MAX_COMMITMENT_READ_REQUESTS_PER_TX: u32 = 4;\n\npub use protocol_types::{\n    abis::avm_circuit_public_inputs::AvmCircuitPublicInputs,\n    constants::{\n        AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED,\n        CHONK_PROOF_LENGTH, CHONK_VK_LENGTH_IN_FIELDS, MEGA_VK_LENGTH_IN_FIELDS,\n        NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, PROOF_TYPE_AVM, PROOF_TYPE_CHONK, PROOF_TYPE_HN,\n        PROOF_TYPE_HN_FINAL, PROOF_TYPE_HN_TAIL, PROOF_TYPE_OINK, PROOF_TYPE_ROLLUP_HONK,\n        PROOF_TYPE_ROOT_ROLLUP_HONK,\n    },\n    proof::{\n        traits::SerializeToColumns,\n        verification_key::{RollupHonkVerificationKey, VerificationKey},\n    },\n    traits::Serialize,\n};\n\npub struct TxRequest {\n    pub number_of_calls: u32,\n}\n\npub struct AppPublicInputs {\n    pub commitments: [Field; MAX_COMMITMENTS_PER_CALL],\n    pub read_requests: [Field; MAX_COMMITMENT_READ_REQUESTS_PER_CALL],\n}\n\nimpl Default for AppPublicInputs {\n    fn default() -> Self {\n        Self {\n            commitments: [0; MAX_COMMITMENTS_PER_CALL],\n            read_requests: [0; MAX_COMMITMENT_READ_REQUESTS_PER_CALL],\n        }\n    }\n}\n\npub struct PrivateKernelPublicInputs {\n    pub remaining_calls: u32,\n    pub commitments: [Field; MAX_COMMITMENTS_PER_TX],\n    pub read_requests: [Field; MAX_COMMITMENT_READ_REQUESTS_PER_TX],\n}\n\nimpl Default for PrivateKernelPublicInputs {\n    fn default() -> Self {\n        Self {\n            remaining_calls: 0,\n            commitments: [0; MAX_COMMITMENTS_PER_TX],\n            read_requests: [0; MAX_COMMITMENT_READ_REQUESTS_PER_TX],\n        }\n    }\n}\n\npub struct PrivateKernelPublicInputsBuilder {\n    pub remaining_calls: u32,\n    pub commitments: BoundedVec<Field, MAX_COMMITMENTS_PER_TX>,\n    pub read_requests: BoundedVec<Field, MAX_COMMITMENT_READ_REQUESTS_PER_TX>,\n}\n\nimpl PrivateKernelPublicInputsBuilder {\n    pub fn from_tx(tx: TxRequest) -> Self {\n        Self {\n            remaining_calls: tx.number_of_calls,\n            commitments: BoundedVec::new(),\n            read_requests: BoundedVec::new(),\n        }\n    }\n\n    pub fn from_previous_kernel(prev_kernel_public_inputs: PrivateKernelPublicInputs) -> Self {\n        let mut builder = PrivateKernelPublicInputsBuilder {\n            remaining_calls: prev_kernel_public_inputs.remaining_calls,\n            commitments: BoundedVec::new(),\n            read_requests: BoundedVec::new(),\n        };\n        for i in 0..MAX_COMMITMENTS_PER_TX {\n            if prev_kernel_public_inputs.commitments[i] != 0 {\n                builder.commitments.push(prev_kernel_public_inputs.commitments[i]);\n            }\n        }\n        for i in 0..MAX_COMMITMENT_READ_REQUESTS_PER_TX {\n            if prev_kernel_public_inputs.read_requests[i] != 0 {\n                builder.read_requests.push(prev_kernel_public_inputs.read_requests[i]);\n            }\n        }\n        builder\n    }\n\n    pub fn ingest_app_inputs(&mut self, app_inputs: AppPublicInputs) {\n        for i in 0..MAX_COMMITMENTS_PER_CALL {\n            if app_inputs.commitments[i] != 0 {\n                self.commitments.push(app_inputs.commitments[i]);\n            }\n        }\n\n        for i in 0..MAX_COMMITMENT_READ_REQUESTS_PER_CALL {\n            if app_inputs.read_requests[i] != 0 {\n                self.read_requests.push(app_inputs.read_requests[i]);\n            }\n        }\n\n        self.remaining_calls -= 1;\n    }\n\n    pub fn finish(self) -> PrivateKernelPublicInputs {\n        PrivateKernelPublicInputs {\n            remaining_calls: self.remaining_calls,\n            commitments: self.commitments.storage(),\n            read_requests: self.read_requests.storage(),\n        }\n    }\n}\n\n#[derive(Serialize)]\npub struct KernelPublicInputs {\n    pub commitments: [Field; MAX_COMMITMENTS_PER_TX],\n}\n\nimpl Default for KernelPublicInputs {\n    fn default() -> Self {\n        Self { commitments: [0; MAX_COMMITMENTS_PER_TX] }\n    }\n}\n\n#[derive(Serialize)]\npub struct RollupPublicInputs {\n    accumulated: u32,\n}\n\nimpl RollupPublicInputs {\n    pub fn new(accumulated: u32) -> Self {\n        Self { accumulated }\n    }\n\n    pub fn merge(self, other: Self) -> Self {\n        Self { accumulated: self.accumulated + other.accumulated }\n    }\n}\n\npub struct PreviousRollupData {\n    base_or_merge_public_inputs: RollupPublicInputs,\n    proof: [Field; NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH],\n    vk: RollupHonkVerificationKey,\n}\n\nimpl PreviousRollupData {\n    pub fn verify(self, is_root: bool) {\n        let inputs = self.base_or_merge_public_inputs.serialize();\n\n        std::verify_proof_with_type(\n            self.vk.key,\n            self.proof,\n            inputs,\n            self.vk.hash,\n            if is_root {\n                PROOF_TYPE_ROOT_ROLLUP_HONK\n            } else {\n                PROOF_TYPE_ROLLUP_HONK\n            },\n        );\n    }\n\n    pub fn public_inputs(self) -> RollupPublicInputs {\n        self.base_or_merge_public_inputs\n    }\n}\n\n// CHONK: \"Client Honk\" - An UltraHonk variant with incremental folding and delayed non-native arithmetic.\npub struct ChonkProofData {\n    pub public_inputs: KernelPublicInputs,\n    pub proof: [Field; CHONK_PROOF_LENGTH],\n    pub vk_data: VerificationKey<CHONK_VK_LENGTH_IN_FIELDS>,\n}\n\nimpl ChonkProofData {\n    pub fn verify(self) {\n        let inputs = KernelPublicInputs::serialize(self.public_inputs);\n        std::verify_proof_with_type(\n            self.vk_data.key,\n            self.proof,\n            inputs,\n            self.vk_data.hash,\n            PROOF_TYPE_CHONK,\n        );\n    }\n}\n",
-      "path": "/home/aztec-dev/ubuntu/pub/noir-projects/mock-protocol-circuits/crates/mock-types/src/lib.nr",
+      "path": "/home/mitch/aztec-clones/alpha/noir-projects/mock-protocol-circuits/crates/mock-types/src/lib.nr",
       "function_locations": [
         {
           "start": 1151,
@@ -318,5 +318,5 @@
     ],
     "hash": "21b282fd9ecb217a0e70cc3b185cd534aadd9ff5697cb7551bb7f4d1fed3196b"
   },
-  "aztec_version": "5.0.0-rc.1"
+  "aztec_version": "5.0.0-rc.2"
 }