@aztec/ivc-integration 0.84.0 → 0.85.0

package/artifacts/mock_private_kernel_reset.json

@@ -1 +1 @@
-{"noir_version":"1.0.0-beta.3+0000000000000000000000000000000000000000","hash":"9007963978565632761","abi":{"parameters":[{"name":"prev_kernel_public_inputs","type":{"kind":"struct","path":"mock_types::PrivateKernelPublicInputs","fields":[{"name":"remaining_calls","type":{"kind":"integer","sign":"unsigned","width":32}},{"name":"commitments","type":{"kind":"array","length":4,"type":{"kind":"field"}}},{"name":"read_requests","type":{"kind":"array","length":4,"type":{"kind":"field"}}}]},"visibility":"databus"},{"name":"kernel_vk","type":{"kind":"array","length":143,"type":{"kind":"field"}},"visibility":"private"},{"name":"commitment_read_hints","type":{"kind":"array","length":4,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"}],"return_type":{"abi_type":{"kind":"struct","path":"mock_types::PrivateKernelPublicInputs","fields":[{"name":"remaining_calls","type":{"kind":"integer","sign":"unsigned","width":32}},{"name":"commitments","type":{"kind":"array","length":4,"type":{"kind":"field"}}},{"name":"read_requests","type":{"kind":"array","length":4,"type":{"kind":"field"}}}]},"visibility":"databus"},"error_types":{}},"bytecode":"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","debug_symbols":"tdbJasMwEAbgd9HZB0sz2vwqpQSvQWBs46VQTN69SrCLSdzCf8gtWr455NdMsoqqLpbrJXRNP4nsYxVtX+Zz6Lu4WoV5bE1D3t1X05yPs8i0SxNRd5XIDPMtEU1o67gbP75clYb0dlda6X4vK3P7TIR9a3V3Vt1KtQlr1LF6BB4FMoWFPBMu5U04Y5+FggXBgv8XXr0IfSa8Nrvw7lkYWFhYOFh4VKgUFhIWChaEvkTFsNCwMOhLVBYWp5k7p/98u8qjglK0PwjOnODMiWDBsID7nOA+J7jPCe5zgvuc4T5nOHOGM2c4c4YzZzhzNuhkYAsL+OecPTpLdAoLiU4GrWBBsIBnu4Znu4Yz1/Bs1w4WHv2uDDzbDZh5XBRjaNtwvRz/W8ftr3wMedHW27JZuvJwOn8P+8nuh7Ev62oZ63ulx1ks/wM=","file_map":{"26":{"source":"pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\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\nuse convert::AsPrimitive;\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\npub fn println<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(true, input);\n    }\n}\n\npub fn print<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(false, input);\n    }\n}\n\npub fn verify_proof<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) {\n    verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\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#[builtin(static_assert)]\npub fn static_assert<let N: u32>(predicate: bool, message: str<N>) {}\n\npub fn wrapping_add<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    AsPrimitive::as_(x.as_() + y.as_())\n}\n\npub fn wrapping_sub<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n    AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n\npub fn wrapping_mul<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n    use super::wrapping_mul;\n\n    #[test(should_fail_with = \"custom message\")]\n    fn test_static_assert_custom_message() {\n        super::static_assert(1 == 2, \"custom message\");\n    }\n\n    #[test(should_fail)]\n    fn test_wrapping_mul() {\n        // This currently fails.\n        // See: https://github.com/noir-lang/noir/issues/7528\n        let zero: u128 = 0;\n        let one: u128 = 1;\n        let two_pow_64: u128 = 0x10000000000000000;\n        let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n        // 1*0==0\n        assert_eq(zero, wrapping_mul(zero, one));\n\n        // 0*1==0\n        assert_eq(zero, wrapping_mul(one, zero));\n\n        // 1*1==1\n        assert_eq(one, wrapping_mul(one, one));\n\n        // 0 * ( 1 << 64 ) ==  0\n        assert_eq(zero, wrapping_mul(zero, two_pow_64));\n\n        // ( 1 << 64 ) * 0 == 0\n        assert_eq(zero, wrapping_mul(two_pow_64, zero));\n\n        // 1 * ( 1 << 64 ) == 1 << 64\n        assert_eq(two_pow_64, wrapping_mul(two_pow_64, one));\n\n        // ( 1 << 64 ) * 1 == 1 << 64\n        assert_eq(two_pow_64, wrapping_mul(one, two_pow_64));\n\n        // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n        assert_eq(zero, wrapping_mul(two_pow_64, two_pow_64));\n        // -1 * -1 == 1\n        assert_eq(one, wrapping_mul(u128_max, u128_max));\n    }\n}\n","path":"std/lib.nr"},"54":{"source":"use dep::mock_types::{\n    CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS, MAX_COMMITMENT_READ_REQUESTS_PER_TX,\n    MAX_COMMITMENTS_PER_TX, PrivateKernelPublicInputs, PROOF_TYPE_PG,\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: [Field; CLIENT_IVC_VERIFICATION_KEY_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, [], [], 0, PROOF_TYPE_PG);\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/aztec-packages/noir-projects/mock-protocol-circuits/crates/mock-private-kernel-reset/src/main.nr"}},"names":["main"],"brillig_names":["directive_invert"]}
+{"noir_version":"1.0.0-beta.4+0000000000000000000000000000000000000000","hash":"11503882794625761610","abi":{"parameters":[{"name":"prev_kernel_public_inputs","type":{"kind":"struct","path":"mock_types::PrivateKernelPublicInputs","fields":[{"name":"remaining_calls","type":{"kind":"integer","sign":"unsigned","width":32}},{"name":"commitments","type":{"kind":"array","length":4,"type":{"kind":"field"}}},{"name":"read_requests","type":{"kind":"array","length":4,"type":{"kind":"field"}}}]},"visibility":"databus"},{"name":"kernel_vk","type":{"kind":"array","length":143,"type":{"kind":"field"}},"visibility":"private"},{"name":"commitment_read_hints","type":{"kind":"array","length":4,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"}],"return_type":{"abi_type":{"kind":"struct","path":"mock_types::PrivateKernelPublicInputs","fields":[{"name":"remaining_calls","type":{"kind":"integer","sign":"unsigned","width":32}},{"name":"commitments","type":{"kind":"array","length":4,"type":{"kind":"field"}}},{"name":"read_requests","type":{"kind":"array","length":4,"type":{"kind":"field"}}}]},"visibility":"databus"},"error_types":{"14225679739041873922":{"error_kind":"string","string":"Index out of bounds"}}},"bytecode":"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","debug_symbols":"tZfNasJAFEbfZdYuMn/3zvgqpZSoUQIhkRgLRXz3RjEiaVo4iy7n59zNzfnu5GJ21eZ8+KjbfXcy67eLabptOdRdO64uRu5bp2PZ3lanoewHs46pWJmq3Zm1hHBdmX3dVONucV39uGrFx8ddqzY9Lzt3fV8Z/dfqaam6WvcgVNxr9RHIFLAFJuwSkcJEJJE54TDhMREwETGx+CmlIjwJnROKiYSJ/DeR3Zxwiz3PUSYipzlhMeEw4TERMBExIZhQTGDNHfbcY8899txjzz323GPPPfbcY8899twve57ir9b6TIlQ0GQI2POAPQ/Y84A9D9jzgD0P2POQMJEpEXG2R9zziHsecc8j7nnEPY9CMzEqJnC2x0zzSgpM4GwXnO2Cs10CTVGJmBCaiaKYSJjA81zxPFeLCdxzxT1XPM8Vz3MVTOB5rvjdrvjdnvA8T5YR42LT101THz5e/6HH7c+yr8tNUz2W+3O7fTkdvo7TycQf+25b7c59dat0PxvLfwM=","file_map":{"22":{"source":"pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\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\nuse convert::AsPrimitive;\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\npub fn println<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(true, input);\n    }\n}\n\npub fn print<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(false, input);\n    }\n}\n\npub fn verify_proof<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) {\n    verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\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#[builtin(static_assert)]\npub fn static_assert<let N: u32>(predicate: bool, message: str<N>) {}\n\npub fn wrapping_add<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    AsPrimitive::as_(x.as_() + y.as_())\n}\n\npub fn wrapping_sub<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n    AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n\npub fn wrapping_mul<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n    use super::wrapping_mul;\n\n    #[test(should_fail_with = \"custom message\")]\n    fn test_static_assert_custom_message() {\n        super::static_assert(1 == 2, \"custom message\");\n    }\n\n    #[test(should_fail)]\n    fn test_wrapping_mul() {\n        // This currently fails.\n        // See: https://github.com/noir-lang/noir/issues/7528\n        let zero: u128 = 0;\n        let one: u128 = 1;\n        let two_pow_64: u128 = 0x10000000000000000;\n        let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n        // 1*0==0\n        assert_eq(zero, wrapping_mul(zero, one));\n\n        // 0*1==0\n        assert_eq(zero, wrapping_mul(one, zero));\n\n        // 1*1==1\n        assert_eq(one, wrapping_mul(one, one));\n\n        // 0 * ( 1 << 64 ) ==  0\n        assert_eq(zero, wrapping_mul(zero, two_pow_64));\n\n        // ( 1 << 64 ) * 0 == 0\n        assert_eq(zero, wrapping_mul(two_pow_64, zero));\n\n        // 1 * ( 1 << 64 ) == 1 << 64\n        assert_eq(two_pow_64, wrapping_mul(two_pow_64, one));\n\n        // ( 1 << 64 ) * 1 == 1 << 64\n        assert_eq(two_pow_64, wrapping_mul(one, two_pow_64));\n\n        // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n        assert_eq(zero, wrapping_mul(two_pow_64, two_pow_64));\n        // -1 * -1 == 1\n        assert_eq(one, wrapping_mul(u128_max, u128_max));\n    }\n}\n","path":"std/lib.nr"},"50":{"source":"use dep::mock_types::{\n    CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS, MAX_COMMITMENT_READ_REQUESTS_PER_TX,\n    MAX_COMMITMENTS_PER_TX, PrivateKernelPublicInputs, PROOF_TYPE_PG,\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: [Field; CLIENT_IVC_VERIFICATION_KEY_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, [], [], 0, PROOF_TYPE_PG);\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/aztec-packages/noir-projects/mock-protocol-circuits/crates/mock-private-kernel-reset/src/main.nr"}},"names":["main"],"brillig_names":["directive_invert","directive_integer_quotient"]}

package/artifacts/mock_private_kernel_tail.json

@@ -1 +1 @@
-{"noir_version":"1.0.0-beta.3+0000000000000000000000000000000000000000","hash":"210985980862830698","abi":{"parameters":[{"name":"prev_kernel_public_inputs","type":{"kind":"struct","path":"mock_types::PrivateKernelPublicInputs","fields":[{"name":"remaining_calls","type":{"kind":"integer","sign":"unsigned","width":32}},{"name":"commitments","type":{"kind":"array","length":4,"type":{"kind":"field"}}},{"name":"read_requests","type":{"kind":"array","length":4,"type":{"kind":"field"}}}]},"visibility":"databus"},{"name":"kernel_vk","type":{"kind":"array","length":143,"type":{"kind":"field"}},"visibility":"private"}],"return_type":{"abi_type":{"kind":"struct","path":"mock_types::KernelPublicInputs","fields":[{"name":"commitments","type":{"kind":"array","length":4,"type":{"kind":"field"}}}]},"visibility":"public"},"error_types":{}},"bytecode":"H4sIAAAAAAAA/9XXZ08TAQCH8asTBPdeiHvrlbbQOhD33nshIMW998a9xS0Kn9XIkzuSJ+A7yotecukvNNY7Jdf/kwiio7PrLA96H4n4tS5+TYXV6XS+piqfTCUbw6pcUzYTpjNN1dlkNpnJZpqrsqlUPpvO1uSacjVhLplO5ZMtmVyqJYyOTn1W2MeDayvrOtt0raVd59/Yw+QyuVweLo+QR8qj5NHyGHmsPE4eL0+QJ8qT5MnyFHmqPE2eLlfIM+RKeaY8S54tz5HnyvPk+fICeaG8SF4sL5GXysvk5XIoJ+UqOSWn5YxcLdfIWTknr5BXyqvk1XKtvEauk9fK6+T18gZ5o7xJ3ixvkbfK2+Tt8g55p7xL3i3vkffK++T98gH5oHxIPiwfkY/Kx+Tj8gn5pFwvn5Ib5Ea5ST4tN8t5uUU+I5+Vz8nn5QvyRfmSfFm+Il+Vr8nX5RvyTfmWfFu+I9+V78n35QfyQ/mR/Fh+IrfKT+Vn8nP5hfxSfiW/lt/Ib+V38nv5g/xR/iS3yZ/lL/JX+Zv8Xf4h/5R/xe558F5n/N7A/7zHURe/hn07kgX8rLA/r3NwkVznkCK5zqFFcp0l/XSdA3pcZ183baKA99xeJPc8oID3/LtI7nlgAe/5T5Hc86AC3nNHAe+Z/wvO0vjz+M5MxPfPzwfFP/PZ/XxKxO9ztOvfruef53uHZzrPy5L476IpaUkaknakGWlFGpE2pAlpQRqQ9qP5aD0aj7aj6Wg5Go52qwiiVqsMojajyWgxGoz2orloLRqLtqKpaCkainaimWglfgn4QqeJaCEaiPaheWgdGoe2oWloGRqGdqkNolapC6I2oUloERqE9qA5aA0ag7agKWgJGoJ2oBloBRqBNqAJaAEagO3P5mfrs/HZ9mx6tjwbnu1eH0RbvSGItjmbnC3OBmd7s7nZ2mxstjWbmi3NhmY7s5nZymxktjGbmC3MBmb7snnZumxcti2bli3LhmW7slnZqq1BtE3ZpGxRNijbk83J1mRjsi3ZlGxJNiTbkc3IVmQjsg3ZhGxBNiDbj83H1us+/HvHc4/nQEfQ+/gHTI5ikpgRAAA=","debug_symbols":"tZHBCoQgGITf5T93yEqLXmVZwspCEA2zhSV69/0LC9nt4mFvM//MNwiu0It2GRupBzND/VhBmY47aTS6FdLjNE9c72523DqoaZomIHSPihVbAoNUAjXKnyphOfVdUpLqKmdseyZA/rqe3a5XxBMso+E6AvkdUF7PKYtvoIgFaCzA4gA0rZVKybEJvxHPL24lb5Xwdlh0F6TuPZ3JyU/WdKJfrNiXjgznPw==","file_map":{"26":{"source":"pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\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\nuse convert::AsPrimitive;\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\npub fn println<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(true, input);\n    }\n}\n\npub fn print<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(false, input);\n    }\n}\n\npub fn verify_proof<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) {\n    verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\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#[builtin(static_assert)]\npub fn static_assert<let N: u32>(predicate: bool, message: str<N>) {}\n\npub fn wrapping_add<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    AsPrimitive::as_(x.as_() + y.as_())\n}\n\npub fn wrapping_sub<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n    AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n\npub fn wrapping_mul<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n    use super::wrapping_mul;\n\n    #[test(should_fail_with = \"custom message\")]\n    fn test_static_assert_custom_message() {\n        super::static_assert(1 == 2, \"custom message\");\n    }\n\n    #[test(should_fail)]\n    fn test_wrapping_mul() {\n        // This currently fails.\n        // See: https://github.com/noir-lang/noir/issues/7528\n        let zero: u128 = 0;\n        let one: u128 = 1;\n        let two_pow_64: u128 = 0x10000000000000000;\n        let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n        // 1*0==0\n        assert_eq(zero, wrapping_mul(zero, one));\n\n        // 0*1==0\n        assert_eq(zero, wrapping_mul(one, zero));\n\n        // 1*1==1\n        assert_eq(one, wrapping_mul(one, one));\n\n        // 0 * ( 1 << 64 ) ==  0\n        assert_eq(zero, wrapping_mul(zero, two_pow_64));\n\n        // ( 1 << 64 ) * 0 == 0\n        assert_eq(zero, wrapping_mul(two_pow_64, zero));\n\n        // 1 * ( 1 << 64 ) == 1 << 64\n        assert_eq(two_pow_64, wrapping_mul(two_pow_64, one));\n\n        // ( 1 << 64 ) * 1 == 1 << 64\n        assert_eq(two_pow_64, wrapping_mul(one, two_pow_64));\n\n        // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n        assert_eq(zero, wrapping_mul(two_pow_64, two_pow_64));\n        // -1 * -1 == 1\n        assert_eq(one, wrapping_mul(u128_max, u128_max));\n    }\n}\n","path":"std/lib.nr"},"54":{"source":"use dep::mock_types::{\n    CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS, KernelPublicInputs,\n    MAX_COMMITMENT_READ_REQUESTS_PER_TX, PrivateKernelPublicInputs, PROOF_TYPE_PG,\n};\n\n// The tail kernel finishes the client IVC 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: [Field; CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS],\n) -> pub KernelPublicInputs {\n    std::verify_proof_with_type(kernel_vk, [], [], 0, PROOF_TYPE_PG);\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/aztec-packages/noir-projects/mock-protocol-circuits/crates/mock-private-kernel-tail/src/main.nr"}},"names":["main"],"brillig_names":[]}
+{"noir_version":"1.0.0-beta.4+0000000000000000000000000000000000000000","hash":"6942088771058445314","abi":{"parameters":[{"name":"prev_kernel_public_inputs","type":{"kind":"struct","path":"mock_types::PrivateKernelPublicInputs","fields":[{"name":"remaining_calls","type":{"kind":"integer","sign":"unsigned","width":32}},{"name":"commitments","type":{"kind":"array","length":4,"type":{"kind":"field"}}},{"name":"read_requests","type":{"kind":"array","length":4,"type":{"kind":"field"}}}]},"visibility":"databus"},{"name":"kernel_vk","type":{"kind":"array","length":143,"type":{"kind":"field"}},"visibility":"private"}],"return_type":{"abi_type":{"kind":"struct","path":"mock_types::KernelPublicInputs","fields":[{"name":"commitments","type":{"kind":"array","length":4,"type":{"kind":"field"}}}]},"visibility":"public"},"error_types":{}},"bytecode":"H4sIAAAAAAAA/9XXZ08TAQCH8asTBPdeiHvrlbbQOhD33nshIMW998a9xS0Kn9XIkzuSJ+A7yotecukvNNY7Jdf/kwiio7PrLA96H4n4tS5+TYXV6XS+piqfTCUbw6pcUzYTpjNN1dlkNpnJZpqrsqlUPpvO1uSacjVhLplO5ZMtmVyqJYyOTn1W2MeDayvrOtt0raVd59/Yw+QyuVweLo+QR8qj5NHyGHmsPE4eL0+QJ8qT5MnyFHmqPE2eLlfIM+RKeaY8S54tz5HnyvPk+fICeaG8SF4sL5GXysvk5XIoJ+UqOSWn5YxcLdfIWTknr5BXyqvk1XKtvEauk9fK6+T18gZ5o7xJ3ixvkbfK2+Tt8g55p7xL3i3vkffK++T98gH5oHxIPiwfkY/Kx+Tj8gn5pFwvn5Ib5Ea5ST4tN8t5uUU+I5+Vz8nn5QvyRfmSfFm+Il+Vr8nX5RvyTfmWfFu+I9+V78n35QfyQ/mR/Fh+IrfKT+Vn8nP5hfxSfiW/lt/Ib+V38nv5g/xR/iS3yZ/lL/JX+Zv8Xf4h/5R/xe558F5n/N7A/7zHURe/hn07kgX8rLA/r3NwkVznkCK5zqFFcp0l/XSdA3pcZ183baKA99xeJPc8oID3/LtI7nlgAe/5T5Hc86AC3nNHAe+Z/wvO0vjz+M5MxPfPzwfFP/PZ/XxKxO9ztOvfruef53uHZzrPy5L476IpaUkaknakGWlFGpE2pAlpQRqQ9qP5aD0aj7aj6Wg5Go52qwiiVqsMojajyWgxGoz2orloLRqLtqKpaCkainaimWglfgn4QqeJaCEaiPaheWgdGoe2oWloGRqGdqkNolapC6I2oUloERqE9qA5aA0ag7agKWgJGoJ2oBloBRqBNqAJaAEagO3P5mfrs/HZ9mx6tjwbnu1eH0RbvSGItjmbnC3OBmd7s7nZ2mxstjWbmi3NhmY7s5nZymxktjGbmC3MBmb7snnZumxcti2bli3LhmW7slnZqq1BtE3ZpGxRNijbk83J1mRjsi3ZlGxJNiTbkc3IVmQjsg3ZhGxBNiDbj83H1us+/HvHc4/nQEfQ+/gHTI5ikpgRAAA=","debug_symbols":"tZHNCoQgFIXf5a5dpKVFrzIMYWUhiIbZwBC9+1hYyEwbF7Pz/HwH4a7Qi3YZG6kHM0P9WEGZjjtptFcrZIc1T1zvanbcOqhpliEQuvcvVmwIBqnE7m7op4pZTkMXl7i6yoRsTwT4r+vkdr3CgWCExuseyO+A8vpOWXwDRSpAUwGWBnjRWqmUHJv4jN5+cSt5q0SQw6K7KHXv6UxOfrKmE/1ixb50ZH7+Aw==","file_map":{"22":{"source":"pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\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\nuse convert::AsPrimitive;\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\npub fn println<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(true, input);\n    }\n}\n\npub fn print<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(false, input);\n    }\n}\n\npub fn verify_proof<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) {\n    verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\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#[builtin(static_assert)]\npub fn static_assert<let N: u32>(predicate: bool, message: str<N>) {}\n\npub fn wrapping_add<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    AsPrimitive::as_(x.as_() + y.as_())\n}\n\npub fn wrapping_sub<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n    AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n\npub fn wrapping_mul<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n    use super::wrapping_mul;\n\n    #[test(should_fail_with = \"custom message\")]\n    fn test_static_assert_custom_message() {\n        super::static_assert(1 == 2, \"custom message\");\n    }\n\n    #[test(should_fail)]\n    fn test_wrapping_mul() {\n        // This currently fails.\n        // See: https://github.com/noir-lang/noir/issues/7528\n        let zero: u128 = 0;\n        let one: u128 = 1;\n        let two_pow_64: u128 = 0x10000000000000000;\n        let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n        // 1*0==0\n        assert_eq(zero, wrapping_mul(zero, one));\n\n        // 0*1==0\n        assert_eq(zero, wrapping_mul(one, zero));\n\n        // 1*1==1\n        assert_eq(one, wrapping_mul(one, one));\n\n        // 0 * ( 1 << 64 ) ==  0\n        assert_eq(zero, wrapping_mul(zero, two_pow_64));\n\n        // ( 1 << 64 ) * 0 == 0\n        assert_eq(zero, wrapping_mul(two_pow_64, zero));\n\n        // 1 * ( 1 << 64 ) == 1 << 64\n        assert_eq(two_pow_64, wrapping_mul(two_pow_64, one));\n\n        // ( 1 << 64 ) * 1 == 1 << 64\n        assert_eq(two_pow_64, wrapping_mul(one, two_pow_64));\n\n        // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n        assert_eq(zero, wrapping_mul(two_pow_64, two_pow_64));\n        // -1 * -1 == 1\n        assert_eq(one, wrapping_mul(u128_max, u128_max));\n    }\n}\n","path":"std/lib.nr"},"50":{"source":"use dep::mock_types::{\n    CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS, KernelPublicInputs,\n    MAX_COMMITMENT_READ_REQUESTS_PER_TX, PrivateKernelPublicInputs, PROOF_TYPE_PG,\n};\n\n// The tail kernel finishes the client IVC 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: [Field; CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS],\n) -> pub KernelPublicInputs {\n    std::verify_proof_with_type(kernel_vk, [], [], 0, PROOF_TYPE_PG);\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/aztec-packages/noir-projects/mock-protocol-circuits/crates/mock-private-kernel-tail/src/main.nr"}},"names":["main"],"brillig_names":[]}

package/artifacts/mock_rollup_base_private.json

@@ -0,0 +1 @@
+{"noir_version":"1.0.0-beta.4+0000000000000000000000000000000000000000","hash":"674395458853748092","abi":{"parameters":[{"name":"tube_data","type":{"kind":"struct","path":"mock_types::TubeData","fields":[{"name":"public_inputs","type":{"kind":"struct","path":"mock_types::KernelPublicInputs","fields":[{"name":"commitments","type":{"kind":"array","length":4,"type":{"kind":"field"}}}]}},{"name":"proof","type":{"kind":"array","length":535,"type":{"kind":"field"}}},{"name":"vk_data","type":{"kind":"struct","path":"types::proof::verification_key::VerificationKey","fields":[{"name":"key","type":{"kind":"array","length":139,"type":{"kind":"field"}}},{"name":"hash","type":{"kind":"field"}}]}}]},"visibility":"private"}],"return_type":{"abi_type":{"kind":"struct","path":"mock_types::RollupPublicInputs","fields":[{"name":"accumulated","type":{"kind":"integer","sign":"unsigned","width":32}}]},"visibility":"public"},"error_types":{}},"bytecode":"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","debug_symbols":"bY5bCoMwEEX3Mt9+GG1a61ZKkTwlEJKQR6GE7L1RtArt35y5Zy6TgQua5kkZaQOMjwzaMhKVNZUytOsqOGIWCpH4CCNCuAFheJ16VBqQSgsYcVuaHxX37X1z8WUYDhn9kdG1/xbf0CF3XXlWoF5prebp/GBdv4hXhGqxoUyGndL4dnuy3ztvmeDJi6VpzWr9Bw==","file_map":{"22":{"source":"pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\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\nuse convert::AsPrimitive;\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\npub fn println<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(true, input);\n    }\n}\n\npub fn print<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(false, input);\n    }\n}\n\npub fn verify_proof<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) {\n    verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\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#[builtin(static_assert)]\npub fn static_assert<let N: u32>(predicate: bool, message: str<N>) {}\n\npub fn wrapping_add<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    AsPrimitive::as_(x.as_() + y.as_())\n}\n\npub fn wrapping_sub<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n    AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n\npub fn wrapping_mul<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n    use super::wrapping_mul;\n\n    #[test(should_fail_with = \"custom message\")]\n    fn test_static_assert_custom_message() {\n        super::static_assert(1 == 2, \"custom message\");\n    }\n\n    #[test(should_fail)]\n    fn test_wrapping_mul() {\n        // This currently fails.\n        // See: https://github.com/noir-lang/noir/issues/7528\n        let zero: u128 = 0;\n        let one: u128 = 1;\n        let two_pow_64: u128 = 0x10000000000000000;\n        let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n        // 1*0==0\n        assert_eq(zero, wrapping_mul(zero, one));\n\n        // 0*1==0\n        assert_eq(zero, wrapping_mul(one, zero));\n\n        // 1*1==1\n        assert_eq(one, wrapping_mul(one, one));\n\n        // 0 * ( 1 << 64 ) ==  0\n        assert_eq(zero, wrapping_mul(zero, two_pow_64));\n\n        // ( 1 << 64 ) * 0 == 0\n        assert_eq(zero, wrapping_mul(two_pow_64, zero));\n\n        // 1 * ( 1 << 64 ) == 1 << 64\n        assert_eq(two_pow_64, wrapping_mul(two_pow_64, one));\n\n        // ( 1 << 64 ) * 1 == 1 << 64\n        assert_eq(two_pow_64, wrapping_mul(one, two_pow_64));\n\n        // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n        assert_eq(zero, wrapping_mul(two_pow_64, two_pow_64));\n        // -1 * -1 == 1\n        assert_eq(one, wrapping_mul(u128_max, u128_max));\n    }\n}\n","path":"std/lib.nr"},"50":{"source":"use dep::mock_types::{RollupPublicInputs, TubeData};\n\nfn main(tube_data: TubeData) -> pub RollupPublicInputs {\n    tube_data.verify();\n    RollupPublicInputs::new(1)\n}\n","path":"/home/aztec-dev/aztec-packages/noir-projects/mock-protocol-circuits/crates/mock-rollup-base-private/src/main.nr"},"51":{"source":"global MAX_COMMITMENTS_PER_CALL: u32 = 2;\nglobal MAX_COMMITMENTS_PER_TX: u32 = 4;\nglobal MAX_COMMITMENT_READ_REQUESTS_PER_CALL: u32 = 2;\nglobal MAX_COMMITMENT_READ_REQUESTS_PER_TX: u32 = 4;\n\npub use protocol_types::{\n    constants::{\n        CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,\n        PROOF_TYPE_OINK, PROOF_TYPE_PG, PROOF_TYPE_ROLLUP_HONK, PROOF_TYPE_ROOT_ROLLUP_HONK,\n        ROLLUP_HONK_VERIFICATION_KEY_LENGTH_IN_FIELDS, TUBE_PROOF_LENGTH,\n    },\n    proof::verification_key::{RollupHonkVerificationKey, VerificationKey},\n    traits::Serialize,\n};\n\nstruct TxRequest {\n    number_of_calls: u32,\n}\n\nstruct AppPublicInputs {\n    commitments: [Field; MAX_COMMITMENTS_PER_CALL],\n    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\nstruct PrivateKernelPublicInputs {\n    remaining_calls: u32,\n    commitments: [Field; MAX_COMMITMENTS_PER_TX],\n    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\nstruct PrivateKernelPublicInputsBuilder {\n    remaining_calls: u32,\n    commitments: BoundedVec<Field, MAX_COMMITMENTS_PER_TX>,\n    read_requests: BoundedVec<Field, MAX_COMMITMENT_READ_REQUESTS_PER_TX>,\n}\n\nimpl PrivateKernelPublicInputsBuilder {\n    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    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    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    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\npub struct KernelPublicInputs {\n    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\nimpl Serialize<MAX_COMMITMENTS_PER_TX> for KernelPublicInputs {\n    fn serialize(self) -> [Field; MAX_COMMITMENTS_PER_TX] {\n        self.commitments\n    }\n}\n\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\nimpl Serialize<1> for RollupPublicInputs {\n    fn serialize(self) -> [Field; 1] {\n        [self.accumulated as Field]\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\npub struct TubeData {\n    pub public_inputs: KernelPublicInputs,\n    pub proof: [Field; TUBE_PROOF_LENGTH],\n    pub vk_data: VerificationKey<ROLLUP_HONK_VERIFICATION_KEY_LENGTH_IN_FIELDS>,\n}\n\nimpl TubeData {\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_ROLLUP_HONK,\n        );\n    }\n}\n","path":"/home/aztec-dev/aztec-packages/noir-projects/mock-protocol-circuits/crates/mock-types/src/lib.nr"}},"names":["main"],"brillig_names":[]}

package/artifacts/mock_rollup_base_public.d.json.ts

@@ -0,0 +1,3 @@
+import { type NoirCompiledCircuit } from '@aztec/stdlib/noir';
+const circuit: NoirCompiledCircuit;
+export = circuit;

package/artifacts/mock_rollup_base_public.json

@@ -0,0 +1 @@
+{"noir_version":"1.0.0-beta.4+0000000000000000000000000000000000000000","hash":"10364304209210587254","abi":{"parameters":[{"name":"tube_data","type":{"kind":"struct","path":"mock_types::TubeData","fields":[{"name":"public_inputs","type":{"kind":"struct","path":"mock_types::KernelPublicInputs","fields":[{"name":"commitments","type":{"kind":"array","length":4,"type":{"kind":"field"}}}]}},{"name":"proof","type":{"kind":"array","length":535,"type":{"kind":"field"}}},{"name":"vk_data","type":{"kind":"struct","path":"types::proof::verification_key::VerificationKey","fields":[{"name":"key","type":{"kind":"array","length":139,"type":{"kind":"field"}}},{"name":"hash","type":{"kind":"field"}}]}}]},"visibility":"private"},{"name":"verification_key","type":{"kind":"array","length":1000,"type":{"kind":"field"}},"visibility":"private"},{"name":"proof","type":{"kind":"array","length":20000,"type":{"kind":"field"}},"visibility":"private"},{"name":"pub_cols_flattened","type":{"kind":"array","length":1,"type":{"kind":"field"}},"visibility":"private"}],"return_type":{"abi_type":{"kind":"struct","path":"mock_types::RollupPublicInputs","fields":[{"name":"accumulated","type":{"kind":"integer","sign":"unsigned","width":32}}]},"visibility":"public"},"error_types":{}},"bytecode":"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","debug_symbols":"tZDNCoMwEITfZc85uLH+1FcpRaJGCYREYiyUkHdvFFOFirfedna+HYZ10PFmHmqhej1B9XAgdcus0CooB8m6mkamFjVZZixUGSIBrrow0cIT6IXkYU48+UXT5B7ZW1nuMJ7AmKfZBmOBO0ypfxLA0yrfi7xIr6tcp9M/pgfRGCGlGOrjc8P6xYxgjeSb7GfVHlz7HqMT70ejW97Nhi9JqxfiPw==","file_map":{"22":{"source":"pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\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\nuse convert::AsPrimitive;\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\npub fn println<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(true, input);\n    }\n}\n\npub fn print<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(false, input);\n    }\n}\n\npub fn verify_proof<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) {\n    verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\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#[builtin(static_assert)]\npub fn static_assert<let N: u32>(predicate: bool, message: str<N>) {}\n\npub fn wrapping_add<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    AsPrimitive::as_(x.as_() + y.as_())\n}\n\npub fn wrapping_sub<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n    AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n\npub fn wrapping_mul<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n    use super::wrapping_mul;\n\n    #[test(should_fail_with = \"custom message\")]\n    fn test_static_assert_custom_message() {\n        super::static_assert(1 == 2, \"custom message\");\n    }\n\n    #[test(should_fail)]\n    fn test_wrapping_mul() {\n        // This currently fails.\n        // See: https://github.com/noir-lang/noir/issues/7528\n        let zero: u128 = 0;\n        let one: u128 = 1;\n        let two_pow_64: u128 = 0x10000000000000000;\n        let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n        // 1*0==0\n        assert_eq(zero, wrapping_mul(zero, one));\n\n        // 0*1==0\n        assert_eq(zero, wrapping_mul(one, zero));\n\n        // 1*1==1\n        assert_eq(one, wrapping_mul(one, one));\n\n        // 0 * ( 1 << 64 ) ==  0\n        assert_eq(zero, wrapping_mul(zero, two_pow_64));\n\n        // ( 1 << 64 ) * 0 == 0\n        assert_eq(zero, wrapping_mul(two_pow_64, zero));\n\n        // 1 * ( 1 << 64 ) == 1 << 64\n        assert_eq(two_pow_64, wrapping_mul(two_pow_64, one));\n\n        // ( 1 << 64 ) * 1 == 1 << 64\n        assert_eq(two_pow_64, wrapping_mul(one, two_pow_64));\n\n        // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n        assert_eq(zero, wrapping_mul(two_pow_64, two_pow_64));\n        // -1 * -1 == 1\n        assert_eq(one, wrapping_mul(u128_max, u128_max));\n    }\n}\n","path":"std/lib.nr"},"50":{"source":"use dep::types::constants::{\n    AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, AVM_V2_PUBLIC_INPUTS_FLATTENED_SIZE,\n    AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED, PROOF_TYPE_AVM,\n};\n\nuse dep::mock_types::{RollupPublicInputs, TubeData};\n\nfn main(\n    tube_data: TubeData,\n    verification_key: [Field; AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED],\n    proof: [Field; AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED],\n    pub_cols_flattened: [Field; AVM_V2_PUBLIC_INPUTS_FLATTENED_SIZE],\n) -> pub RollupPublicInputs {\n    tube_data.verify();\n    std::verify_proof_with_type(\n        verification_key,\n        proof,\n        pub_cols_flattened,\n        0,\n        PROOF_TYPE_AVM,\n    );\n    RollupPublicInputs::new(1)\n}\n","path":"/home/aztec-dev/aztec-packages/noir-projects/mock-protocol-circuits/crates/mock-rollup-base-public/src/main.nr"},"51":{"source":"global MAX_COMMITMENTS_PER_CALL: u32 = 2;\nglobal MAX_COMMITMENTS_PER_TX: u32 = 4;\nglobal MAX_COMMITMENT_READ_REQUESTS_PER_CALL: u32 = 2;\nglobal MAX_COMMITMENT_READ_REQUESTS_PER_TX: u32 = 4;\n\npub use protocol_types::{\n    constants::{\n        CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,\n        PROOF_TYPE_OINK, PROOF_TYPE_PG, PROOF_TYPE_ROLLUP_HONK, PROOF_TYPE_ROOT_ROLLUP_HONK,\n        ROLLUP_HONK_VERIFICATION_KEY_LENGTH_IN_FIELDS, TUBE_PROOF_LENGTH,\n    },\n    proof::verification_key::{RollupHonkVerificationKey, VerificationKey},\n    traits::Serialize,\n};\n\nstruct TxRequest {\n    number_of_calls: u32,\n}\n\nstruct AppPublicInputs {\n    commitments: [Field; MAX_COMMITMENTS_PER_CALL],\n    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\nstruct PrivateKernelPublicInputs {\n    remaining_calls: u32,\n    commitments: [Field; MAX_COMMITMENTS_PER_TX],\n    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\nstruct PrivateKernelPublicInputsBuilder {\n    remaining_calls: u32,\n    commitments: BoundedVec<Field, MAX_COMMITMENTS_PER_TX>,\n    read_requests: BoundedVec<Field, MAX_COMMITMENT_READ_REQUESTS_PER_TX>,\n}\n\nimpl PrivateKernelPublicInputsBuilder {\n    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    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    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    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\npub struct KernelPublicInputs {\n    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\nimpl Serialize<MAX_COMMITMENTS_PER_TX> for KernelPublicInputs {\n    fn serialize(self) -> [Field; MAX_COMMITMENTS_PER_TX] {\n        self.commitments\n    }\n}\n\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\nimpl Serialize<1> for RollupPublicInputs {\n    fn serialize(self) -> [Field; 1] {\n        [self.accumulated as Field]\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\npub struct TubeData {\n    pub public_inputs: KernelPublicInputs,\n    pub proof: [Field; TUBE_PROOF_LENGTH],\n    pub vk_data: VerificationKey<ROLLUP_HONK_VERIFICATION_KEY_LENGTH_IN_FIELDS>,\n}\n\nimpl TubeData {\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_ROLLUP_HONK,\n        );\n    }\n}\n","path":"/home/aztec-dev/aztec-packages/noir-projects/mock-protocol-circuits/crates/mock-types/src/lib.nr"}},"names":["main"],"brillig_names":[]}

package/artifacts/mock_rollup_merge.d.json.ts

@@ -0,0 +1,3 @@
+import { type NoirCompiledCircuit } from '@aztec/stdlib/noir';
+const circuit: NoirCompiledCircuit;
+export = circuit;

package/artifacts/mock_rollup_merge.json

@@ -0,0 +1 @@
+{"noir_version":"1.0.0-beta.4+0000000000000000000000000000000000000000","hash":"7074896877061821991","abi":{"parameters":[{"name":"a","type":{"kind":"struct","path":"mock_types::PreviousRollupData","fields":[{"name":"base_or_merge_public_inputs","type":{"kind":"struct","path":"mock_types::RollupPublicInputs","fields":[{"name":"accumulated","type":{"kind":"integer","sign":"unsigned","width":32}}]}},{"name":"proof","type":{"kind":"array","length":535,"type":{"kind":"field"}}},{"name":"vk","type":{"kind":"struct","path":"types::proof::verification_key::VerificationKey","fields":[{"name":"key","type":{"kind":"array","length":139,"type":{"kind":"field"}}},{"name":"hash","type":{"kind":"field"}}]}}]},"visibility":"private"},{"name":"b","type":{"kind":"struct","path":"mock_types::PreviousRollupData","fields":[{"name":"base_or_merge_public_inputs","type":{"kind":"struct","path":"mock_types::RollupPublicInputs","fields":[{"name":"accumulated","type":{"kind":"integer","sign":"unsigned","width":32}}]}},{"name":"proof","type":{"kind":"array","length":535,"type":{"kind":"field"}}},{"name":"vk","type":{"kind":"struct","path":"types::proof::verification_key::VerificationKey","fields":[{"name":"key","type":{"kind":"array","length":139,"type":{"kind":"field"}}},{"name":"hash","type":{"kind":"field"}}]}}]},"visibility":"private"}],"return_type":{"abi_type":{"kind":"struct","path":"mock_types::RollupPublicInputs","fields":[{"name":"accumulated","type":{"kind":"integer","sign":"unsigned","width":32}}]},"visibility":"public"},"error_types":{"5019202896831570965":{"error_kind":"string","string":"attempt to add with overflow"}}},"bytecode":"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","debug_symbols":"vZFLCoMwFEX38sYOfPk1uJVSStQogZBIjIUi7r1R1AoVOmpnue9+OJARal0O7d24xvdQXEewvlLReJfUCGQ59Z1ys+qjChEKZDwD7er04nTKoDFWQ8HzKfuIMpGzNcukxHcYT8Io6D58QbmHCZluGdBTFCH2BvsbCjtFkXJtEMQvKJjnGwpScURJ6/yH60mUwVhr2vvxn9P5oYJRpdWrbAZXHdz47DZn63fBV7oegp6XFi/NvwA=","file_map":{"22":{"source":"pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\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\nuse convert::AsPrimitive;\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\npub fn println<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(true, input);\n    }\n}\n\npub fn print<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(false, input);\n    }\n}\n\npub fn verify_proof<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) {\n    verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\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#[builtin(static_assert)]\npub fn static_assert<let N: u32>(predicate: bool, message: str<N>) {}\n\npub fn wrapping_add<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    AsPrimitive::as_(x.as_() + y.as_())\n}\n\npub fn wrapping_sub<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n    AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n\npub fn wrapping_mul<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n    use super::wrapping_mul;\n\n    #[test(should_fail_with = \"custom message\")]\n    fn test_static_assert_custom_message() {\n        super::static_assert(1 == 2, \"custom message\");\n    }\n\n    #[test(should_fail)]\n    fn test_wrapping_mul() {\n        // This currently fails.\n        // See: https://github.com/noir-lang/noir/issues/7528\n        let zero: u128 = 0;\n        let one: u128 = 1;\n        let two_pow_64: u128 = 0x10000000000000000;\n        let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n        // 1*0==0\n        assert_eq(zero, wrapping_mul(zero, one));\n\n        // 0*1==0\n        assert_eq(zero, wrapping_mul(one, zero));\n\n        // 1*1==1\n        assert_eq(one, wrapping_mul(one, one));\n\n        // 0 * ( 1 << 64 ) ==  0\n        assert_eq(zero, wrapping_mul(zero, two_pow_64));\n\n        // ( 1 << 64 ) * 0 == 0\n        assert_eq(zero, wrapping_mul(two_pow_64, zero));\n\n        // 1 * ( 1 << 64 ) == 1 << 64\n        assert_eq(two_pow_64, wrapping_mul(two_pow_64, one));\n\n        // ( 1 << 64 ) * 1 == 1 << 64\n        assert_eq(two_pow_64, wrapping_mul(one, two_pow_64));\n\n        // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n        assert_eq(zero, wrapping_mul(two_pow_64, two_pow_64));\n        // -1 * -1 == 1\n        assert_eq(one, wrapping_mul(u128_max, u128_max));\n    }\n}\n","path":"std/lib.nr"},"50":{"source":"use mock_types::{PreviousRollupData, RollupPublicInputs};\n\nfn main(a: PreviousRollupData, b: PreviousRollupData) -> pub RollupPublicInputs {\n    a.verify(false);\n    b.verify(false);\n\n    a.public_inputs().merge(b.public_inputs())\n}\n","path":"/home/aztec-dev/aztec-packages/noir-projects/mock-protocol-circuits/crates/mock-rollup-merge/src/main.nr"},"51":{"source":"global MAX_COMMITMENTS_PER_CALL: u32 = 2;\nglobal MAX_COMMITMENTS_PER_TX: u32 = 4;\nglobal MAX_COMMITMENT_READ_REQUESTS_PER_CALL: u32 = 2;\nglobal MAX_COMMITMENT_READ_REQUESTS_PER_TX: u32 = 4;\n\npub use protocol_types::{\n    constants::{\n        CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,\n        PROOF_TYPE_OINK, PROOF_TYPE_PG, PROOF_TYPE_ROLLUP_HONK, PROOF_TYPE_ROOT_ROLLUP_HONK,\n        ROLLUP_HONK_VERIFICATION_KEY_LENGTH_IN_FIELDS, TUBE_PROOF_LENGTH,\n    },\n    proof::verification_key::{RollupHonkVerificationKey, VerificationKey},\n    traits::Serialize,\n};\n\nstruct TxRequest {\n    number_of_calls: u32,\n}\n\nstruct AppPublicInputs {\n    commitments: [Field; MAX_COMMITMENTS_PER_CALL],\n    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\nstruct PrivateKernelPublicInputs {\n    remaining_calls: u32,\n    commitments: [Field; MAX_COMMITMENTS_PER_TX],\n    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\nstruct PrivateKernelPublicInputsBuilder {\n    remaining_calls: u32,\n    commitments: BoundedVec<Field, MAX_COMMITMENTS_PER_TX>,\n    read_requests: BoundedVec<Field, MAX_COMMITMENT_READ_REQUESTS_PER_TX>,\n}\n\nimpl PrivateKernelPublicInputsBuilder {\n    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    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    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    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\npub struct KernelPublicInputs {\n    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\nimpl Serialize<MAX_COMMITMENTS_PER_TX> for KernelPublicInputs {\n    fn serialize(self) -> [Field; MAX_COMMITMENTS_PER_TX] {\n        self.commitments\n    }\n}\n\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\nimpl Serialize<1> for RollupPublicInputs {\n    fn serialize(self) -> [Field; 1] {\n        [self.accumulated as Field]\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\npub struct TubeData {\n    pub public_inputs: KernelPublicInputs,\n    pub proof: [Field; TUBE_PROOF_LENGTH],\n    pub vk_data: VerificationKey<ROLLUP_HONK_VERIFICATION_KEY_LENGTH_IN_FIELDS>,\n}\n\nimpl TubeData {\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_ROLLUP_HONK,\n        );\n    }\n}\n","path":"/home/aztec-dev/aztec-packages/noir-projects/mock-protocol-circuits/crates/mock-types/src/lib.nr"}},"names":["main"],"brillig_names":[]}

package/artifacts/mock_rollup_root.d.json.ts

@@ -0,0 +1,3 @@
+import { type NoirCompiledCircuit } from '@aztec/stdlib/noir';
+const circuit: NoirCompiledCircuit;
+export = circuit;

package/artifacts/mock_rollup_root.json

@@ -0,0 +1 @@
+{"noir_version":"1.0.0-beta.4+0000000000000000000000000000000000000000","hash":"17848235517788917620","abi":{"parameters":[{"name":"a","type":{"kind":"struct","path":"mock_types::PreviousRollupData","fields":[{"name":"base_or_merge_public_inputs","type":{"kind":"struct","path":"mock_types::RollupPublicInputs","fields":[{"name":"accumulated","type":{"kind":"integer","sign":"unsigned","width":32}}]}},{"name":"proof","type":{"kind":"array","length":535,"type":{"kind":"field"}}},{"name":"vk","type":{"kind":"struct","path":"types::proof::verification_key::VerificationKey","fields":[{"name":"key","type":{"kind":"array","length":139,"type":{"kind":"field"}}},{"name":"hash","type":{"kind":"field"}}]}}]},"visibility":"private"},{"name":"b","type":{"kind":"struct","path":"mock_types::PreviousRollupData","fields":[{"name":"base_or_merge_public_inputs","type":{"kind":"struct","path":"mock_types::RollupPublicInputs","fields":[{"name":"accumulated","type":{"kind":"integer","sign":"unsigned","width":32}}]}},{"name":"proof","type":{"kind":"array","length":535,"type":{"kind":"field"}}},{"name":"vk","type":{"kind":"struct","path":"types::proof::verification_key::VerificationKey","fields":[{"name":"key","type":{"kind":"array","length":139,"type":{"kind":"field"}}},{"name":"hash","type":{"kind":"field"}}]}}]},"visibility":"private"}],"return_type":{"abi_type":{"kind":"struct","path":"mock_types::RollupPublicInputs","fields":[{"name":"accumulated","type":{"kind":"integer","sign":"unsigned","width":32}}]},"visibility":"public"},"error_types":{"5019202896831570965":{"error_kind":"string","string":"attempt to add with overflow"}}},"bytecode":"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","debug_symbols":"vZFLCoMwFEX38sYO8m/qVkopUaMEQiIxFoq490bxBxU6ame57344kAEqXfTNw7jad5DfBrC+VNF4l9QAZD51rXKT6qIKEXLMeAbaVenF6ZhBbayGnKMx+4gygdiSZVLiPYxPwljQbfiC5RYmZLxnQE9RxN74Hwo7RZFiaRB0/YKCEVpRMBVHlLTOf7ieRBGMtaZ5HP85nZ8qGFVYvci6d+XBja92ddZ+G3ypqz7oaWn20vwb","file_map":{"22":{"source":"pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\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\nuse convert::AsPrimitive;\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\npub fn println<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(true, input);\n    }\n}\n\npub fn print<T>(input: T) {\n    // Safety: a print statement cannot be constrained\n    unsafe {\n        print_unconstrained(false, input);\n    }\n}\n\npub fn verify_proof<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) {\n    verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\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#[builtin(static_assert)]\npub fn static_assert<let N: u32>(predicate: bool, message: str<N>) {}\n\npub fn wrapping_add<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    AsPrimitive::as_(x.as_() + y.as_())\n}\n\npub fn wrapping_sub<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n    AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n\npub fn wrapping_mul<T>(x: T, y: T) -> T\nwhere\n    T: AsPrimitive<Field>,\n    Field: AsPrimitive<T>,\n{\n    AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n    use super::wrapping_mul;\n\n    #[test(should_fail_with = \"custom message\")]\n    fn test_static_assert_custom_message() {\n        super::static_assert(1 == 2, \"custom message\");\n    }\n\n    #[test(should_fail)]\n    fn test_wrapping_mul() {\n        // This currently fails.\n        // See: https://github.com/noir-lang/noir/issues/7528\n        let zero: u128 = 0;\n        let one: u128 = 1;\n        let two_pow_64: u128 = 0x10000000000000000;\n        let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n        // 1*0==0\n        assert_eq(zero, wrapping_mul(zero, one));\n\n        // 0*1==0\n        assert_eq(zero, wrapping_mul(one, zero));\n\n        // 1*1==1\n        assert_eq(one, wrapping_mul(one, one));\n\n        // 0 * ( 1 << 64 ) ==  0\n        assert_eq(zero, wrapping_mul(zero, two_pow_64));\n\n        // ( 1 << 64 ) * 0 == 0\n        assert_eq(zero, wrapping_mul(two_pow_64, zero));\n\n        // 1 * ( 1 << 64 ) == 1 << 64\n        assert_eq(two_pow_64, wrapping_mul(two_pow_64, one));\n\n        // ( 1 << 64 ) * 1 == 1 << 64\n        assert_eq(two_pow_64, wrapping_mul(one, two_pow_64));\n\n        // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n        assert_eq(zero, wrapping_mul(two_pow_64, two_pow_64));\n        // -1 * -1 == 1\n        assert_eq(one, wrapping_mul(u128_max, u128_max));\n    }\n}\n","path":"std/lib.nr"},"50":{"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/aztec-packages/noir-projects/mock-protocol-circuits/crates/mock-rollup-root/src/main.nr"},"51":{"source":"global MAX_COMMITMENTS_PER_CALL: u32 = 2;\nglobal MAX_COMMITMENTS_PER_TX: u32 = 4;\nglobal MAX_COMMITMENT_READ_REQUESTS_PER_CALL: u32 = 2;\nglobal MAX_COMMITMENT_READ_REQUESTS_PER_TX: u32 = 4;\n\npub use protocol_types::{\n    constants::{\n        CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,\n        PROOF_TYPE_OINK, PROOF_TYPE_PG, PROOF_TYPE_ROLLUP_HONK, PROOF_TYPE_ROOT_ROLLUP_HONK,\n        ROLLUP_HONK_VERIFICATION_KEY_LENGTH_IN_FIELDS, TUBE_PROOF_LENGTH,\n    },\n    proof::verification_key::{RollupHonkVerificationKey, VerificationKey},\n    traits::Serialize,\n};\n\nstruct TxRequest {\n    number_of_calls: u32,\n}\n\nstruct AppPublicInputs {\n    commitments: [Field; MAX_COMMITMENTS_PER_CALL],\n    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\nstruct PrivateKernelPublicInputs {\n    remaining_calls: u32,\n    commitments: [Field; MAX_COMMITMENTS_PER_TX],\n    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\nstruct PrivateKernelPublicInputsBuilder {\n    remaining_calls: u32,\n    commitments: BoundedVec<Field, MAX_COMMITMENTS_PER_TX>,\n    read_requests: BoundedVec<Field, MAX_COMMITMENT_READ_REQUESTS_PER_TX>,\n}\n\nimpl PrivateKernelPublicInputsBuilder {\n    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    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    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    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\npub struct KernelPublicInputs {\n    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\nimpl Serialize<MAX_COMMITMENTS_PER_TX> for KernelPublicInputs {\n    fn serialize(self) -> [Field; MAX_COMMITMENTS_PER_TX] {\n        self.commitments\n    }\n}\n\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\nimpl Serialize<1> for RollupPublicInputs {\n    fn serialize(self) -> [Field; 1] {\n        [self.accumulated as Field]\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\npub struct TubeData {\n    pub public_inputs: KernelPublicInputs,\n    pub proof: [Field; TUBE_PROOF_LENGTH],\n    pub vk_data: VerificationKey<ROLLUP_HONK_VERIFICATION_KEY_LENGTH_IN_FIELDS>,\n}\n\nimpl TubeData {\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_ROLLUP_HONK,\n        );\n    }\n}\n","path":"/home/aztec-dev/aztec-packages/noir-projects/mock-protocol-circuits/crates/mock-types/src/lib.nr"}},"names":["main"],"brillig_names":[]}