@aztec/ivc-integration 0.85.0 → 0.86.0

package/artifacts/mock_rollup_merge.json

@@ -1 +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":[]}
+{"noir_version":"1.0.0-beta.4+0000000000000000000000000000000000000000","hash":"8199822545176548954","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":113,"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":113,"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":"vZFNCoMwFITv8tZZNPElVa9SSokaJRASibFQxLs3in9Qoat2l3nzzTCQASpV9M1D29p1kN8GMK6UQTsb1QBsPnWttJPqgvQBcoqcgLJVfPFkJFBroyDnl5F8oCgytrCYiWyH6QlMRbIVX2m6wYyNdwLJ6RQhtgT+bQqeTknTJcEo/TJlZ5ExPE6J7fyH7VEUXhujm8fxn+P5Kb2WhVGLrHtbHtzwaldnzbfelarqvZqaZi/WvwE=","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\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\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#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\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#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\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::ops::arith::WrappingMul;\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]\n    fn test_wrapping_mul() {\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, zero.wrapping_mul(one));\n\n        // 0*1==0\n        assert_eq(zero, one.wrapping_mul(zero));\n\n        // 1*1==1\n        assert_eq(one, one.wrapping_mul(one));\n\n        // 0 * ( 1 << 64 ) ==  0\n        assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n        // ( 1 << 64 ) * 0 == 0\n        assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n        // 1 * ( 1 << 64 ) == 1 << 64\n        assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n        // ( 1 << 64 ) * 1 == 1 << 64\n        assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n        // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n        assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n        // -1 * -1 == 1\n        assert_eq(one, u128_max.wrapping_mul(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":"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    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\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\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\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.json

@@ -1 +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":[]}
+{"noir_version":"1.0.0-beta.4+0000000000000000000000000000000000000000","hash":"15103714446976190317","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":113,"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":113,"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":"vZHdCoMgGIbv5TvuIE2dditjhJWFIBpmgxHd+yz6gwU72s58v/eHBxyhVuXQFto2rof8PoJxlQza2ahGwMup76SdVR+kD5AjQhNQto4vmk0JNNooyGk6JR9RwgRes0QwcYTRRRixbB++Ib6HMZ4eCWSXKOxo/A+FXKJwtjZwKr6gIM43FIzJGSWu0x+uR1F6bYxui/M/x/NTei1Lo1bZDLY6ueHVbc7W77yrVD14NS8tXpx/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\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\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#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\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#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\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::ops::arith::WrappingMul;\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]\n    fn test_wrapping_mul() {\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, zero.wrapping_mul(one));\n\n        // 0*1==0\n        assert_eq(zero, one.wrapping_mul(zero));\n\n        // 1*1==1\n        assert_eq(one, one.wrapping_mul(one));\n\n        // 0 * ( 1 << 64 ) ==  0\n        assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n        // ( 1 << 64 ) * 0 == 0\n        assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n        // 1 * ( 1 << 64 ) == 1 << 64\n        assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n        // ( 1 << 64 ) * 1 == 1 << 64\n        assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n        // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n        assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n        // -1 * -1 == 1\n        assert_eq(one, u128_max.wrapping_mul(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":"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    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\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\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\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/dest/bb_working_directory.d.ts

@@ -0,0 +1,2 @@
+export declare function getWorkingDirectory(prefix: string): Promise<string>;
+//# sourceMappingURL=bb_working_directory.d.ts.map

package/dest/bb_working_directory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bb_working_directory.d.ts","sourceRoot":"","sources":["../src/bb_working_directory.ts"],"names":[],"mappings":"AAIA,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAIzE"}

package/dest/bb_working_directory.js

@@ -0,0 +1,10 @@
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+export async function getWorkingDirectory(prefix) {
+    const baseFolder = process.env.BB_WORKING_DIRECTORY || os.tmpdir();
+    await fs.mkdir(baseFolder, {
+        recursive: true
+    });
+    return await fs.mkdtemp(path.join(baseFolder, prefix));
+}

package/dest/prove_native.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prove_native.d.ts","sourceRoot":"","sources":["../src/prove_native.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAElF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,EAAE,cAAc,EAAS,MAAM,sBAAsB,CAAC;AAOlE,wBAAsB,cAAc,CAClC,YAAY,EAAE,MAAM,EACpB,kBAAkB,EAAE,MAAM,EAC1B,YAAY,EAAE,UAAU,EAAE,EAC1B,SAAS,EAAE,MAAM,EAAE,EACnB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,cAAc,CAAC,CAqBzB;AAyBD,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,mFAczF;AAoCD,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,EACxB,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,MAAM,mFAYf;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,EACxB,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,MAAM,mFAYf;AAED,wBAAsB,QAAQ,CAC5B,gBAAgB,EAAE,gBAAgB,EAClC,gBAAgB,EAAE,MAAM,EACxB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC;IACT,EAAE,EAAE,EAAE,EAAE,CAAC;IACT,KAAK,EAAE,EAAE,EAAE,CAAC;IACZ,YAAY,EAAE,sBAAsB,CAAC;CACtC,CAAC,CAoDD"}
+{"version":3,"file":"prove_native.d.ts","sourceRoot":"","sources":["../src/prove_native.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAElF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,EAAE,cAAc,EAAS,MAAM,sBAAsB,CAAC;AAOlE,wBAAsB,cAAc,CAClC,YAAY,EAAE,MAAM,EACpB,kBAAkB,EAAE,MAAM,EAC1B,YAAY,EAAE,UAAU,EAAE,EAC1B,SAAS,EAAE,MAAM,EAAE,EACnB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,cAAc,CAAC,CA0BzB;AAyBD,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,mFAczF;AAoCD,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,EACxB,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,MAAM,mFAYf;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,EACxB,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,MAAM,mFAYf;AAED,wBAAsB,QAAQ,CAC5B,gBAAgB,EAAE,gBAAgB,EAClC,gBAAgB,EAAE,MAAM,EACxB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC;IACT,EAAE,EAAE,EAAE,EAAE,CAAC;IACT,KAAK,EAAE,EAAE,EAAE,CAAC;IACZ,YAAY,EAAE,sBAAsB,CAAC;CACtC,CAAC,CAoDD"}

package/dest/prove_native.js

@@ -3,13 +3,24 @@ import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, AVM_V2_VERIFICATION_KEY_LENGTH_IN
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader } from '@aztec/foundation/serialize';
 import { makeProofAndVerificationKey } from '@aztec/stdlib/interfaces/server';
-import { encode } from '@msgpack/msgpack';
 import * as fs from 'fs/promises';
+import { Encoder } from 'msgpackr';
 import * as path from 'path';
 export async function proveClientIVC(bbBinaryPath, bbWorkingDirectory, witnessStack, bytecodes, logger) {
-    await fs.writeFile(path.join(bbWorkingDirectory, 'acir.msgpack'), encode(bytecodes.map((bytecode)=>Buffer.from(bytecode, 'base64'))));
-    await fs.writeFile(path.join(bbWorkingDirectory, 'witnesses.msgpack'), encode(witnessStack));
-    const provingResult = await executeBbClientIvcProof(bbBinaryPath, bbWorkingDirectory, path.join(bbWorkingDirectory, 'acir.msgpack'), path.join(bbWorkingDirectory, 'witnesses.msgpack'), logger.info, true);
+    const stepToStruct = (bytecode, index)=>{
+        return {
+            bytecode: Buffer.from(bytecode, 'base64'),
+            witness: witnessStack[index],
+            vk: Buffer.from([]),
+            functionName: `unknown_${index}`
+        };
+    };
+    const encoded = new Encoder({
+        useRecords: false
+    }).pack(bytecodes.map(stepToStruct));
+    const ivcInputsPath = path.join(bbWorkingDirectory, 'ivc-inputs.msgpack');
+    await fs.writeFile(ivcInputsPath, encoded);
+    const provingResult = await executeBbClientIvcProof(bbBinaryPath, bbWorkingDirectory, ivcInputsPath, logger.info, true);
     if (provingResult.status === BB_RESULT.FAILURE) {
         throw new Error(provingResult.reason);
     }

package/dest/prove_wasm.d.ts

@@ -1,2 +1,4 @@
+import { ClientIvcProof } from '@aztec/stdlib/proofs';
+export declare function proveClientIVC(bytecodes: string[], witnessStack: Uint8Array[], threads?: number): Promise<ClientIvcProof>;
 export declare function proveThenVerifyAztecClient(bytecodes: string[], witnessStack: Uint8Array[], threads?: number): Promise<boolean>;
 //# sourceMappingURL=prove_wasm.d.ts.map

package/dest/prove_wasm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prove_wasm.d.ts","sourceRoot":"","sources":["../src/prove_wasm.ts"],"names":[],"mappings":"AAMA,wBAAsB,0BAA0B,CAC9C,SAAS,EAAE,MAAM,EAAE,EACnB,YAAY,EAAE,UAAU,EAAE,EAC1B,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,OAAO,CAAC,CAalB"}
+{"version":3,"file":"prove_wasm.d.ts","sourceRoot":"","sources":["../src/prove_wasm.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAWtD,wBAAsB,cAAc,CAClC,SAAS,EAAE,MAAM,EAAE,EACnB,YAAY,EAAE,UAAU,EAAE,EAC1B,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,cAAc,CAAC,CAYzB;AAED,wBAAsB,0BAA0B,CAC9C,SAAS,EAAE,MAAM,EAAE,EACnB,YAAY,EAAE,UAAU,EAAE,EAC1B,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,OAAO,CAAC,CAclB"}

package/dest/prove_wasm.js

@@ -1,13 +1,32 @@
+import { createLogger } from '@aztec/foundation/log';
+import { ClientIvcProof } from '@aztec/stdlib/proofs';
+import os from 'os';
 import { ungzip } from 'pako';
+const logger = createLogger('ivc-integration:prove_wasm');
 function base64ToUint8Array(base64) {
     return Uint8Array.from(atob(base64), (c)=>c.charCodeAt(0));
 }
+export async function proveClientIVC(bytecodes, witnessStack, threads) {
+    const { AztecClientBackend } = await import('@aztec/bb.js');
+    const backend = new AztecClientBackend(bytecodes.map(base64ToUint8Array).map((arr)=>ungzip(arr)), {
+        threads: threads || Math.min(os.cpus().length, 16),
+        logger: logger.info
+    });
+    try {
+        const [proof] = await backend.prove(witnessStack.map((arr)=>ungzip(arr)));
+        return new ClientIvcProof(Buffer.from(proof));
+    } finally{
+        await backend.destroy();
+    }
+}
 export async function proveThenVerifyAztecClient(bytecodes, witnessStack, threads) {
     const { AztecClientBackend } = await import('@aztec/bb.js');
     const backend = new AztecClientBackend(bytecodes.map(base64ToUint8Array).map((arr)=>ungzip(arr)), {
-        threads
+        threads: threads || Math.min(os.cpus().length, 16),
+        logger: logger.info
     });
     try {
+        // These are optional - easier not to pass them.
         const [proof, vk] = await backend.prove(witnessStack.map((arr)=>ungzip(arr)));
         const verified = await backend.verify(proof, vk);
         return verified;

package/dest/types/index.d.ts

@@ -26,7 +26,7 @@ export type TubeData = {
     vk_data: VerificationKey;
 };
 export type VerificationKey = {
-    key: FixedLengthArray<Field, 139>;
+    key: FixedLengthArray<Field, 113>;
     hash: Field;
 };
 export type RollupPublicInputs = {
@@ -50,31 +50,31 @@ export declare function AppReader(commitments_to_read: FixedLengthArray<Field, 2
 export type MockPrivateKernelInitInputType = {
     tx: TxRequest;
     app_inputs: AppPublicInputs;
-    app_vk: FixedLengthArray<Field, 143>;
+    app_vk: FixedLengthArray<Field, 127>;
 };
 export type MockPrivateKernelInitReturnType = PrivateKernelPublicInputs;
-export declare function MockPrivateKernelInit(tx: TxRequest, app_inputs: AppPublicInputs, app_vk: FixedLengthArray<Field, 143>, MockPrivateKernelInit_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<PrivateKernelPublicInputs>;
+export declare function MockPrivateKernelInit(tx: TxRequest, app_inputs: AppPublicInputs, app_vk: FixedLengthArray<Field, 127>, MockPrivateKernelInit_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<PrivateKernelPublicInputs>;
 export type MockPrivateKernelInnerInputType = {
     prev_kernel_public_inputs: PrivateKernelPublicInputs;
-    kernel_vk: FixedLengthArray<Field, 143>;
+    kernel_vk: FixedLengthArray<Field, 127>;
     app_inputs: AppPublicInputs;
-    app_vk: FixedLengthArray<Field, 143>;
+    app_vk: FixedLengthArray<Field, 127>;
 };
 export type MockPrivateKernelInnerReturnType = PrivateKernelPublicInputs;
-export declare function MockPrivateKernelInner(prev_kernel_public_inputs: PrivateKernelPublicInputs, kernel_vk: FixedLengthArray<Field, 143>, app_inputs: AppPublicInputs, app_vk: FixedLengthArray<Field, 143>, MockPrivateKernelInner_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<PrivateKernelPublicInputs>;
+export declare function MockPrivateKernelInner(prev_kernel_public_inputs: PrivateKernelPublicInputs, kernel_vk: FixedLengthArray<Field, 127>, app_inputs: AppPublicInputs, app_vk: FixedLengthArray<Field, 127>, MockPrivateKernelInner_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<PrivateKernelPublicInputs>;
 export type MockPrivateKernelResetInputType = {
     prev_kernel_public_inputs: PrivateKernelPublicInputs;
-    kernel_vk: FixedLengthArray<Field, 143>;
+    kernel_vk: FixedLengthArray<Field, 127>;
     commitment_read_hints: FixedLengthArray<u32, 4>;
 };
 export type MockPrivateKernelResetReturnType = PrivateKernelPublicInputs;
-export declare function MockPrivateKernelReset(prev_kernel_public_inputs: PrivateKernelPublicInputs, kernel_vk: FixedLengthArray<Field, 143>, commitment_read_hints: FixedLengthArray<u32, 4>, MockPrivateKernelReset_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<PrivateKernelPublicInputs>;
+export declare function MockPrivateKernelReset(prev_kernel_public_inputs: PrivateKernelPublicInputs, kernel_vk: FixedLengthArray<Field, 127>, commitment_read_hints: FixedLengthArray<u32, 4>, MockPrivateKernelReset_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<PrivateKernelPublicInputs>;
 export type MockPrivateKernelTailInputType = {
     prev_kernel_public_inputs: PrivateKernelPublicInputs;
-    kernel_vk: FixedLengthArray<Field, 143>;
+    kernel_vk: FixedLengthArray<Field, 127>;
 };
 export type MockPrivateKernelTailReturnType = KernelPublicInputs;
-export declare function MockPrivateKernelTail(prev_kernel_public_inputs: PrivateKernelPublicInputs, kernel_vk: FixedLengthArray<Field, 143>, MockPrivateKernelTail_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<KernelPublicInputs>;
+export declare function MockPrivateKernelTail(prev_kernel_public_inputs: PrivateKernelPublicInputs, kernel_vk: FixedLengthArray<Field, 127>, MockPrivateKernelTail_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<KernelPublicInputs>;
 export type MockRollupBasePublicInputType = {
     tube_data: TubeData;
     verification_key: FixedLengthArray<Field, 1000>;

package/dest/witgen.d.ts

@@ -1,8 +1,6 @@
 import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, AVM_V2_PUBLIC_INPUTS_FLATTENED_SIZE, AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED, CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
-import type { PublicTxSimulationTester } from '@aztec/simulator/server';
 import type { AvmCircuitPublicInputs } from '@aztec/stdlib/avm';
-import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import type { RecursiveProof } from '@aztec/stdlib/proofs';
 import type { VerificationKeyAsFields } from '@aztec/stdlib/vks';
 import MockAppCreatorCircuit from '../artifacts/app_creator.json';
@@ -56,5 +54,4 @@ export declare function mapVerificationKeyToNoir<N extends number>(vk: Verificat
 };
 export declare function mapAvmVerificationKeyToNoir(vk: Fr[]): FixedLengthArray<string, typeof AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED>;
 export declare function mapAvmPublicInputsToNoir(publicInputs: AvmCircuitPublicInputs): FixedLengthArray<string, typeof AVM_V2_PUBLIC_INPUTS_FLATTENED_SIZE>;
-export declare function simulateAvmBulkTesting(simTester: PublicTxSimulationTester, contractInstance: ContractInstanceWithAddress): Promise<import("@aztec/simulator/server").PublicTxResult>;
 //# sourceMappingURL=witgen.d.ts.map

package/dest/witgen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"witgen.d.ts","sourceRoot":"","sources":["../src/witgen.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"witgen.d.ts","sourceRoot":"","sources":["../src/witgen.ts"],"names":[],"mappings":"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"}

package/dest/witgen.js

@@ -1,7 +1,6 @@
 import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, AVM_V2_PUBLIC_INPUTS_FLATTENED_SIZE, AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import { Noir } from '@aztec/noir-noir_js';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import createDebug from 'debug';
 import MockAppCreatorCircuit from '../artifacts/app_creator.json' assert {
     type: 'json'
@@ -292,44 +291,3 @@ export function mapAvmPublicInputsToNoir(publicInputs) {
     }
     return serialized.map((x)=>x.toString());
 }
-export async function simulateAvmBulkTesting(simTester, contractInstance) {
-    const argsField = [
-        1,
-        2,
-        3,
-        4,
-        5,
-        6,
-        7,
-        8,
-        9,
-        10
-    ].map((x)=>new Fr(x));
-    const argsU8 = [
-        1,
-        2,
-        3,
-        4,
-        5,
-        6,
-        7,
-        8,
-        9,
-        10
-    ].map((x)=>new Fr(x));
-    const args = [
-        argsField,
-        argsU8,
-        /*getInstanceForAddress=*/ contractInstance.address.toField(),
-        /*expectedDeployer=*/ contractInstance.deployer.toField(),
-        /*expectedClassId=*/ contractInstance.currentContractClassId.toField(),
-        /*expectedInitializationHash=*/ contractInstance.initializationHash.toField()
-    ];
-    return await simTester.simulateTx(/*sender=*/ AztecAddress.fromNumber(42), /*setupCalls=*/ [], /*appCalls=*/ [
-        {
-            address: contractInstance.address,
-            fnName: 'bulk_testing',
-            args
-        }
-    ], /*teardownCall=*/ undefined);
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/ivc-integration",
-  "version": "0.85.0",
+  "version": "0.86.0",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -13,8 +13,6 @@
   "scripts": {
     "build": "yarn clean && yarn generate && tsc -b &&  rm -rf dest && webpack",
     "clean": "rm -rf ./dest .tsbuildinfo src/types artifacts",
-    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
-    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
     "formatting:fix:types": "NODE_OPTIONS='--max-old-space-size=8096' run -T eslint --fix ./src/types && run -T prettier -w ./src/types",
     "generate": "yarn generate:noir-circuits",
     "generate:noir-circuits": "mkdir -p ./artifacts && cp -r ../../noir-projects/mock-protocol-circuits/target/* ./artifacts && node --no-warnings --loader @swc-node/register/esm src/scripts/generate_declaration_files.ts && node --no-warnings --loader @swc-node/register/esm src/scripts/generate_ts_from_abi.ts",
@@ -60,14 +58,14 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb.js": "0.85.0",
-    "@aztec/constants": "0.85.0",
-    "@aztec/foundation": "0.85.0",
-    "@aztec/noir-noir_codegen": "0.85.0",
-    "@aztec/noir-noir_js": "0.85.0",
-    "@aztec/noir-noirc_abi": "0.85.0",
-    "@aztec/noir-types": "0.85.0",
-    "@aztec/stdlib": "0.85.0",
+    "@aztec/bb.js": "0.86.0",
+    "@aztec/constants": "0.86.0",
+    "@aztec/foundation": "0.86.0",
+    "@aztec/noir-noir_codegen": "0.86.0",
+    "@aztec/noir-noir_js": "0.86.0",
+    "@aztec/noir-noirc_abi": "0.86.0",
+    "@aztec/noir-types": "0.86.0",
+    "@aztec/stdlib": "0.86.0",
     "chalk": "^5.3.0",
     "change-case": "^5.4.4",
     "pako": "^2.1.0",
@@ -76,14 +74,13 @@
     "tslib": "^2.4.0"
   },
   "devDependencies": {
-    "@aztec/bb-prover": "0.85.0",
-    "@aztec/kv-store": "0.85.0",
-    "@aztec/noir-contracts.js": "0.85.0",
-    "@aztec/simulator": "0.85.0",
-    "@aztec/telemetry-client": "0.85.0",
-    "@aztec/world-state": "0.85.0",
+    "@aztec/bb-prover": "0.86.0",
+    "@aztec/kv-store": "0.86.0",
+    "@aztec/noir-contracts.js": "0.86.0",
+    "@aztec/simulator": "0.86.0",
+    "@aztec/telemetry-client": "0.86.0",
+    "@aztec/world-state": "0.86.0",
     "@jest/globals": "^29.5.0",
-    "@msgpack/msgpack": "^3.0.0-beta2",
     "@playwright/test": "1.49.0",
     "@types/jest": "^29.5.0",
     "@types/node": "^22.8.1",
@@ -93,14 +90,15 @@
     "html-webpack-plugin": "^5.6.0",
     "jest": "^29.5.0",
     "jest-mock-extended": "^4.0.0-beta1",
+    "msgpackr": "^1.11.2",
     "resolve-typescript-plugin": "^2.0.1",
     "serve": "^14.2.1",
     "ts-loader": "^9.5.1",
     "ts-node": "^10.9.1",
     "typescript": "^5.0.4",
-    "webpack": "^5.90.3",
-    "webpack-cli": "^5.1.4",
-    "webpack-dev-server": "^5.2.0"
+    "webpack": "^5.99.6",
+    "webpack-cli": "^6.0.1",
+    "webpack-dev-server": "^5.2.1"
   },
   "files": [
     "dest",

package/src/bb_working_directory.ts

@@ -0,0 +1,9 @@
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+
+export async function getWorkingDirectory(prefix: string): Promise<string> {
+  const baseFolder = process.env.BB_WORKING_DIRECTORY || os.tmpdir();
+  await fs.mkdir(baseFolder, { recursive: true });
+  return await fs.mkdtemp(path.join(baseFolder, prefix));
+}

package/src/prove_native.ts

@@ -29,8 +29,8 @@ import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
 import type { ClientIvcProof, Proof } from '@aztec/stdlib/proofs';
 import type { VerificationKeyData } from '@aztec/stdlib/vks';
 
-import { encode } from '@msgpack/msgpack';
 import * as fs from 'fs/promises';
+import { Encoder } from 'msgpackr';
 import * as path from 'path';
 
 export async function proveClientIVC(
@@ -40,17 +40,22 @@ export async function proveClientIVC(
   bytecodes: string[],
   logger: Logger,
 ): Promise<ClientIvcProof> {
-  await fs.writeFile(
-    path.join(bbWorkingDirectory, 'acir.msgpack'),
-    encode(bytecodes.map(bytecode => Buffer.from(bytecode, 'base64'))),
-  );
+  const stepToStruct = (bytecode: string, index: number) => {
+    return {
+      bytecode: Buffer.from(bytecode, 'base64'),
+      witness: witnessStack[index],
+      vk: Buffer.from([]),
+      functionName: `unknown_${index}`,
+    };
+  };
+  const encoded = new Encoder({ useRecords: false }).pack(bytecodes.map(stepToStruct));
+  const ivcInputsPath = path.join(bbWorkingDirectory, 'ivc-inputs.msgpack');
+  await fs.writeFile(ivcInputsPath, encoded);
 
-  await fs.writeFile(path.join(bbWorkingDirectory, 'witnesses.msgpack'), encode(witnessStack));
   const provingResult = await executeBbClientIvcProof(
     bbBinaryPath,
     bbWorkingDirectory,
-    path.join(bbWorkingDirectory, 'acir.msgpack'),
-    path.join(bbWorkingDirectory, 'witnesses.msgpack'),
+    ivcInputsPath,
     logger.info,
     true,
   );