@aztec/ivc-integration 2.1.0-rc.9 → 3.0.0-devnet.2

package/artifacts/mock_rollup_tx_merge.json

@@ -0,0 +1,297 @@
+{
+  "noir_version": "1.0.0-beta.14+82ec52a8c755d30ce655a2005834186a4acfa0c7-aztec",
+  "hash": "12277965546342349269",
+  "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": "mock_types::protocol_types::proof::verification_key::VerificationKey",
+                "fields": [
+                  {
+                    "name": "key",
+                    "type": {
+                      "kind": "array",
+                      "length": 115,
+                      "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": "mock_types::protocol_types::proof::verification_key::VerificationKey",
+                "fields": [
+                  {
+                    "name": "key",
+                    "type": {
+                      "kind": "array",
+                      "length": 115,
+                      "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": {
+      "14990209321349310352": {
+        "error_kind": "string",
+        "string": "attempt to add with overflow"
+      }
+    }
+  },
+  "bytecode": "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",
+  "debug_symbols": "tZTfioQgFMbfxesuxr9pr7IsYWWDIBZOLSzRu+8psqYLYyD2JtPT9/OcPj0Takw1Pkvr2+6Fiq8JVcE6Z5+l62o92M7D6jRnKE7LIRgDS+gtDqpeB+MHVPjRuQz9aDeuH7167ddx0AGijwwZ38AIwNY6s7zN2aF+pKWY8U2MOd3l/KzHaT0TjG0AJqQ4CPhEIBcZCEVjCjlnOwFzckLQC4TiMiJUjg+E5J/XoVSsQ+XJOniaQIkgG4FSxncCIR97IcT+I1jKi/y2F/K+F+q+F/ltLzD+VzNkLINgnLwYF4eSURJTYJTLUxXfMNO1DadugAgq4ADQ9ckADnK+3NAMiWWYl72C1ZUzW/NoR1+/9ZLht4+R2G360NWmGYNZdlpjsPcf",
+  "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\n/// Asserts the validity of the provided proof and public inputs against the provided verification key and hash.\n///\n/// The ACVM cannot determine whether the provided proof is valid during execution as this requires knowledge of\n/// the backend against which the program is being proven. However if an invalid proof if submitted, the program may\n/// fail to prove or the backend may generate a proof which will subsequently fail to verify.\n///\n/// # Important Note\n///\n/// If you are not developing your own backend such as [Barretenberg](https://github.com/AztecProtocol/barretenberg)\n/// you probably shouldn't need to interact with this function directly. It's easier and safer to use a verification\n/// library which is published by the developers of the backend which will document or enforce any safety requirements.\n///\n/// If you use this directly, you're liable to introduce underconstrainedness bugs and *your circuit will be insecure*.\n///\n/// # Arguments\n/// - verification_key: The verification key of the circuit to be verified.\n/// - proof: The proof to be verified.\n/// - public_inputs: The public inputs associated with `proof`\n/// - key_hash: The hash of `verification_key` of the form expected by the backend.\n/// - proof_type: An identifier for the proving scheme used to generate the proof to be verified. This allows\n///               for a single backend to support verifying multiple proving schemes.\n///\n/// # Constraining `key_hash`\n///\n/// The Noir compiler does not by itself constrain that `key_hash` is a valid hash of `verification_key`.\n/// This is because different backends may differ in how they hash their verification keys.\n/// It is then the responsibility of either the noir developer (by explicitly hashing the verification key\n/// in the correct manner) or by the proving system itself internally asserting the correctness of `key_hash`.\npub fn verify_proof_with_type<let N: u32, let M: u32, let K: u32>(\n    verification_key: [Field; N],\n    proof: [Field; M],\n    public_inputs: [Field; K],\n    key_hash: Field,\n    proof_type: u32,\n) {\n    if !crate::runtime::is_unconstrained() {\n        crate::assert_constant(proof_type);\n    }\n    verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal<let N: u32, let M: u32, let K: u32>(\n    verification_key: [Field; N],\n    proof: [Field; M],\n    public_inputs: [Field; K],\n    key_hash: Field,\n    proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant<T>(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time.\n// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert<T>(predicate: bool, message: T) {}\n\n#[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",
+      "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-tx-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    abis::avm_circuit_public_inputs::AvmCircuitPublicInputs,\n    constants::{\n        AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED,\n        CIVC_PROOF_LENGTH, CIVC_VK_LENGTH_IN_FIELDS, MEGA_VK_LENGTH_IN_FIELDS,\n        NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, PROOF_TYPE_AVM, PROOF_TYPE_CIVC, PROOF_TYPE_OINK,\n        PROOF_TYPE_PG, PROOF_TYPE_PG_FINAL, PROOF_TYPE_PG_TAIL, PROOF_TYPE_ROLLUP_HONK,\n        PROOF_TYPE_ROOT_ROLLUP_HONK,\n    },\n    proof::{\n        traits::SerializeToColumns,\n        verification_key::{RollupHonkVerificationKey, VerificationKey},\n    },\n    traits::Serialize,\n};\n\npub struct TxRequest {\n    pub number_of_calls: u32,\n}\n\npub struct AppPublicInputs {\n    pub commitments: [Field; MAX_COMMITMENTS_PER_CALL],\n    pub read_requests: [Field; MAX_COMMITMENT_READ_REQUESTS_PER_CALL],\n}\n\nimpl Default for AppPublicInputs {\n    fn default() -> Self {\n        Self {\n            commitments: [0; MAX_COMMITMENTS_PER_CALL],\n            read_requests: [0; MAX_COMMITMENT_READ_REQUESTS_PER_CALL],\n        }\n    }\n}\n\npub struct PrivateKernelPublicInputs {\n    pub remaining_calls: u32,\n    pub commitments: [Field; MAX_COMMITMENTS_PER_TX],\n    pub read_requests: [Field; MAX_COMMITMENT_READ_REQUESTS_PER_TX],\n}\n\nimpl Default for PrivateKernelPublicInputs {\n    fn default() -> Self {\n        Self {\n            remaining_calls: 0,\n            commitments: [0; MAX_COMMITMENTS_PER_TX],\n            read_requests: [0; MAX_COMMITMENT_READ_REQUESTS_PER_TX],\n        }\n    }\n}\n\npub struct PrivateKernelPublicInputsBuilder {\n    pub remaining_calls: u32,\n    pub commitments: BoundedVec<Field, MAX_COMMITMENTS_PER_TX>,\n    pub read_requests: BoundedVec<Field, MAX_COMMITMENT_READ_REQUESTS_PER_TX>,\n}\n\nimpl PrivateKernelPublicInputsBuilder {\n    pub fn from_tx(tx: TxRequest) -> Self {\n        Self {\n            remaining_calls: tx.number_of_calls,\n            commitments: BoundedVec::new(),\n            read_requests: BoundedVec::new(),\n        }\n    }\n\n    pub fn from_previous_kernel(prev_kernel_public_inputs: PrivateKernelPublicInputs) -> Self {\n        let mut builder = PrivateKernelPublicInputsBuilder {\n            remaining_calls: prev_kernel_public_inputs.remaining_calls,\n            commitments: BoundedVec::new(),\n            read_requests: BoundedVec::new(),\n        };\n        for i in 0..MAX_COMMITMENTS_PER_TX {\n            if prev_kernel_public_inputs.commitments[i] != 0 {\n                builder.commitments.push(prev_kernel_public_inputs.commitments[i]);\n            }\n        }\n        for i in 0..MAX_COMMITMENT_READ_REQUESTS_PER_TX {\n            if prev_kernel_public_inputs.read_requests[i] != 0 {\n                builder.read_requests.push(prev_kernel_public_inputs.read_requests[i]);\n            }\n        }\n        builder\n    }\n\n    pub fn ingest_app_inputs(&mut self, app_inputs: AppPublicInputs) {\n        for i in 0..MAX_COMMITMENTS_PER_CALL {\n            if app_inputs.commitments[i] != 0 {\n                self.commitments.push(app_inputs.commitments[i]);\n            }\n        }\n\n        for i in 0..MAX_COMMITMENT_READ_REQUESTS_PER_CALL {\n            if app_inputs.read_requests[i] != 0 {\n                self.read_requests.push(app_inputs.read_requests[i]);\n            }\n        }\n\n        self.remaining_calls -= 1;\n    }\n\n    pub fn finish(self) -> PrivateKernelPublicInputs {\n        PrivateKernelPublicInputs {\n            remaining_calls: self.remaining_calls,\n            commitments: self.commitments.storage(),\n            read_requests: self.read_requests.storage(),\n        }\n    }\n}\n\n#[derive(Serialize)]\npub struct KernelPublicInputs {\n    pub commitments: [Field; MAX_COMMITMENTS_PER_TX],\n}\n\nimpl Default for KernelPublicInputs {\n    fn default() -> Self {\n        Self { commitments: [0; MAX_COMMITMENTS_PER_TX] }\n    }\n}\n\n#[derive(Serialize)]\npub struct RollupPublicInputs {\n    accumulated: u32,\n}\n\nimpl RollupPublicInputs {\n    pub fn new(accumulated: u32) -> Self {\n        Self { accumulated }\n    }\n\n    pub fn merge(self, other: Self) -> Self {\n        Self { accumulated: self.accumulated + other.accumulated }\n    }\n}\n\npub struct PreviousRollupData {\n    base_or_merge_public_inputs: RollupPublicInputs,\n    proof: [Field; NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH],\n    vk: RollupHonkVerificationKey,\n}\n\nimpl PreviousRollupData {\n    pub fn verify(self, is_root: bool) {\n        let inputs = self.base_or_merge_public_inputs.serialize();\n\n        std::verify_proof_with_type(\n            self.vk.key,\n            self.proof,\n            inputs,\n            self.vk.hash,\n            if is_root {\n                PROOF_TYPE_ROOT_ROLLUP_HONK\n            } else {\n                PROOF_TYPE_ROLLUP_HONK\n            },\n        );\n    }\n\n    pub fn public_inputs(self) -> RollupPublicInputs {\n        self.base_or_merge_public_inputs\n    }\n}\n\npub struct CivcProofData {\n    pub public_inputs: KernelPublicInputs,\n    pub proof: [Field; CIVC_PROOF_LENGTH],\n    pub vk_data: VerificationKey<CIVC_VK_LENGTH_IN_FIELDS>,\n}\n\nimpl CivcProofData {\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_CIVC,\n        );\n    }\n}\n",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/mock-protocol-circuits/crates/mock-types/src/lib.nr"
+    }
+  },
+  "expression_width": {
+    "Bounded": {
+      "width": 4
+    }
+  },
+  "verificationKey": {
+    "bytes": "0000000000000000000000000000000000000000000000000000000000000015000000000000000000000000000000000000000000000000000000000000001b000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000059abcf87182e6729f05aeb3b4ac7be028600000000000000000000000000000000001500899a4d33fd401acee68e8a5a3e0000000000000000000000000000009a1b50fdb5e6818060fbc3ac1c0f4c52e000000000000000000000000000000000001ce6ac9acfb97accf034bbda74dafc000000000000000000000000000000371ab2674605730be24be08dc0df20d8420000000000000000000000000000000000271b54f7f3722d5ed147464d32b4cf000000000000000000000000000000543c718bcf5d94db5468f60e6fb8145b17000000000000000000000000000000000028f53a3e77cfa786dd31f0b3e820bb00000000000000000000000000000023d64a78fca63ee7a012a6efa962154ade000000000000000000000000000000000024a707f8f8208d7509c33c63341e1f00000000000000000000000000000049f884097824dd94ffbb356addc674f9980000000000000000000000000000000000001cc3b8e5fdc46718903c433554ae000000000000000000000000000000835f0250cd97cc1f77c265b672dd73302400000000000000000000000000000000002382dbbcddb014898ef3f3f51db1ad0000000000000000000000000000008ea3a6a5ffa62f6b35c53413a60fe5993300000000000000000000000000000000002f03dc38b2fd678c89633396bce21c000000000000000000000000000000923189529b0eb62f041b79f55e8a074ab000000000000000000000000000000000000a18cf69d5b7386a7d646f7a080c48000000000000000000000000000000c175d2108ca86b46e3cac52fe68a13ebbc000000000000000000000000000000000018308d52489bedc53198e907a90bd3000000000000000000000000000000b8527ad9d8984babae4688cf300bd6319600000000000000000000000000000000002aa9d8e840595e928d3a243bc85dea000000000000000000000000000000dc67fc3683cbb284a0e95b43d44123e3d8000000000000000000000000000000000027a0db9916ba7b5d7894de897c74cc000000000000000000000000000000d9ad8b5943ead2741efdeb311b8305c9db000000000000000000000000000000000025043141e7a515687c6d80d0853b760000000000000000000000000000003447e05ab4400999c9704862944ef03bb300000000000000000000000000000000000d8d5f85133d06d56249c6463ac023000000000000000000000000000000bce55202bf26d29323e1e379f13a5a6746000000000000000000000000000000000017c00c293fa7846e3b30b556dcb57e000000000000000000000000000000145e8b40b9bfc4781d85f509f8f23a6b16000000000000000000000000000000000011495d6de3b074b509baf044522503000000000000000000000000000000e4db9a2e2c5ff0f4016fd18451225c0bc40000000000000000000000000000000000292c94c1be5c03d13fa689ef528ce40000000000000000000000000000008a509dd04ec942b8d26483d0c728e2f07e00000000000000000000000000000000002ed7420d0bb101accaf46d31ffda1e000000000000000000000000000000d66c062d29cd192373effd60ae47b62c6b00000000000000000000000000000000002168e1af16e9e3fd4e0dc21938734400000000000000000000000000000026e87ceb0dded7698dcdc0438afdc28e2900000000000000000000000000000000000dd59cabac6786c97fca8439831419000000000000000000000000000000e07e7eacfef9a668a3ddce2d0c4046658f000000000000000000000000000000000023d8fca06624138c2d3d3fffc8d5190000000000000000000000000000002e76fff9d84358504934f471f5186c95dc00000000000000000000000000000000000f7cd2abfd7e321c34fad597296f2500000000000000000000000000000071cd06c01cefed741e4b263af1a6afaa920000000000000000000000000000000000166a2d76c9a7d1235eb427d46ad022000000000000000000000000000000306de07f6eb873e66fe05ef4cf68c0394f00000000000000000000000000000000001cdd48c4e4987c45a5bde93bab830a0000000000000000000000000000009d03c3b40afbc779158301f2afccab2049000000000000000000000000000000000013c165c7dddfd70dff9ca5fc4dce4f000000000000000000000000000000eb3776a3d37a8deaa919ff3d5e8a9db49e00000000000000000000000000000000002ee0f08b07e2e90dc8904de59b6fd1000000000000000000000000000000634036234c69fabc691ee39b6d69601e4c0000000000000000000000000000000000202b26b5336682cea5bf93b4142511000000000000000000000000000000bc94441146ad5f33dc81168a6500bf7e0b00000000000000000000000000000000000b22fadd7090ff5cd70cdf9bf234b8000000000000000000000000000000caffd9638f875bb9c73bbcae489b824cd10000000000000000000000000000000000238f743695c099bbdd3fede258b5040000000000000000000000000000009439d415f58b9dc8a7fadfad1ea8477fd000000000000000000000000000000000000fe0537fa0a15c222e0ad7672caa42000000000000000000000000000000bc1ea83364c2676d2ef63637f26d1cf89e00000000000000000000000000000000000591b2fe2ccdca1266fc64de7e694c0000000000000000000000000000001fbd28b0ed0d034e69f7852f11d5ce9ea00000000000000000000000000000000000091a2d0e2ce5029a83138809c463c30000000000000000000000000000009750fdf553d052a4546f378e7b6bd9c9d0000000000000000000000000000000000010115a0d06930ccd8ab058003155fb000000000000000000000000000000d7a6cd3e24b1a0e1305a605a8b3522b309000000000000000000000000000000000006724254be3a841a14f63f48a7d65b0000000000000000000000000000007786956758c54a82c7647080ee170444a5000000000000000000000000000000000029941ad445c8a8a7ee5cd7d6cd13e80000000000000000000000000000007c3abd739420dccccabaed6116c99295a500000000000000000000000000000000002a2adf6d2f794de5b5042cf0f3b477000000000000000000000000000000db9b02ab4e6a895c178e867deb941cebc40000000000000000000000000000000000252ab30222f808ef21bc2efd3dcd5d000000000000000000000000000000b570825037f518f1533db3ed1e0d4c2f6100000000000000000000000000000000002d9bd9bfba8fa50bc39630bf5f8422000000000000000000000000000000fbaacbd8da2f519f6b33e1ceea3847dc7a000000000000000000000000000000000018be9e01d85b28911d46dd5cdc675e0000000000000000000000000000009e944d5d2351b35ed3de7108f3824b9e150000000000000000000000000000000000243d46f289385cef08cec6de6cd0fe00000000000000000000000000000076b967748ded2502ff48aa7fe59387ad7a00000000000000000000000000000000000f81d901e7055cf134e881372dedec00000000000000000000000000000099069eea0a9a10d100f6696e6a4aae9c2000000000000000000000000000000000000903eacaaf517945fc3eb5b280ae9000000000000000000000000000000069b11930f58e0d77781e04a030a215b94800000000000000000000000000000000001dbc81b058edd6546cb7e193400c080000000000000000000000000000008d7d8535416446ebf7fba40d435b1b4f5f00000000000000000000000000000000002896dc0a60028928f74f16a72dbcbc0000000000000000000000000000002b80d6b55199d55c762fbaec636a525f3e0000000000000000000000000000000000217f0ffe90bea51c49a1b331adae9c0000000000000000000000000000000ed2d8303f6f9c83d86d5c13f3fb4e99dd000000000000000000000000000000000009c45c61155d314160b50b20e35c940000000000000000000000000000009cf5a0abb80a3b2fe13b28fe8f315409b70000000000000000000000000000000000188a2ffed7f8cbe84c7a0f1b018cd000000000000000000000000000000085656153a6120eebdf3a488dccad95d00d000000000000000000000000000000000023cd626f5dde3ce81de0e7d4f74dc200000000000000000000000000000052c3cfa63996daa8314b276628262510920000000000000000000000000000000000061998dda79b7c5b9adc0113867766000000000000000000000000000000b3105a6e5e3268bb6240ed2c345f5ff3db0000000000000000000000000000000000225ce8d1f417dd9b831fe8022aa11d000000000000000000000000000000cf91f0cb73295831bc93869fc19cdbad9900000000000000000000000000000000001ee5d0cdde02f62e468b034f988c56000000000000000000000000000000183a142ac675e313630847be47fe912b9100000000000000000000000000000000001558e16ed49142b74e4a2085b222870000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000892e1162932973de701dc8164a1f06ea33000000000000000000000000000000000004c3913621610ca326bc173830c8c9000000000000000000000000000000b405779798c85f7b9c70fdad1e2d64e4ae000000000000000000000000000000000007e57ead88f1e1abc299f1f835d15a",
+    "fields": [
+      "0x0000000000000000000000000000000000000000000000000000000000000015",
+      "0x000000000000000000000000000000000000000000000000000000000000001b",
+      "0x0000000000000000000000000000000000000000000000000000000000000001",
+      "0x00000000000000000000000000000059abcf87182e6729f05aeb3b4ac7be0286",
+      "0x00000000000000000000000000000000001500899a4d33fd401acee68e8a5a3e",
+      "0x0000000000000000000000000000009a1b50fdb5e6818060fbc3ac1c0f4c52e0",
+      "0x00000000000000000000000000000000001ce6ac9acfb97accf034bbda74dafc",
+      "0x000000000000000000000000000000371ab2674605730be24be08dc0df20d842",
+      "0x0000000000000000000000000000000000271b54f7f3722d5ed147464d32b4cf",
+      "0x000000000000000000000000000000543c718bcf5d94db5468f60e6fb8145b17",
+      "0x000000000000000000000000000000000028f53a3e77cfa786dd31f0b3e820bb",
+      "0x00000000000000000000000000000023d64a78fca63ee7a012a6efa962154ade",
+      "0x000000000000000000000000000000000024a707f8f8208d7509c33c63341e1f",
+      "0x00000000000000000000000000000049f884097824dd94ffbb356addc674f998",
+      "0x0000000000000000000000000000000000001cc3b8e5fdc46718903c433554ae",
+      "0x000000000000000000000000000000835f0250cd97cc1f77c265b672dd733024",
+      "0x00000000000000000000000000000000002382dbbcddb014898ef3f3f51db1ad",
+      "0x0000000000000000000000000000008ea3a6a5ffa62f6b35c53413a60fe59933",
+      "0x00000000000000000000000000000000002f03dc38b2fd678c89633396bce21c",
+      "0x000000000000000000000000000000923189529b0eb62f041b79f55e8a074ab0",
+      "0x00000000000000000000000000000000000a18cf69d5b7386a7d646f7a080c48",
+      "0x000000000000000000000000000000c175d2108ca86b46e3cac52fe68a13ebbc",
+      "0x000000000000000000000000000000000018308d52489bedc53198e907a90bd3",
+      "0x000000000000000000000000000000b8527ad9d8984babae4688cf300bd63196",
+      "0x00000000000000000000000000000000002aa9d8e840595e928d3a243bc85dea",
+      "0x000000000000000000000000000000dc67fc3683cbb284a0e95b43d44123e3d8",
+      "0x000000000000000000000000000000000027a0db9916ba7b5d7894de897c74cc",
+      "0x000000000000000000000000000000d9ad8b5943ead2741efdeb311b8305c9db",
+      "0x000000000000000000000000000000000025043141e7a515687c6d80d0853b76",
+      "0x0000000000000000000000000000003447e05ab4400999c9704862944ef03bb3",
+      "0x00000000000000000000000000000000000d8d5f85133d06d56249c6463ac023",
+      "0x000000000000000000000000000000bce55202bf26d29323e1e379f13a5a6746",
+      "0x000000000000000000000000000000000017c00c293fa7846e3b30b556dcb57e",
+      "0x000000000000000000000000000000145e8b40b9bfc4781d85f509f8f23a6b16",
+      "0x000000000000000000000000000000000011495d6de3b074b509baf044522503",
+      "0x000000000000000000000000000000e4db9a2e2c5ff0f4016fd18451225c0bc4",
+      "0x0000000000000000000000000000000000292c94c1be5c03d13fa689ef528ce4",
+      "0x0000000000000000000000000000008a509dd04ec942b8d26483d0c728e2f07e",
+      "0x00000000000000000000000000000000002ed7420d0bb101accaf46d31ffda1e",
+      "0x000000000000000000000000000000d66c062d29cd192373effd60ae47b62c6b",
+      "0x00000000000000000000000000000000002168e1af16e9e3fd4e0dc219387344",
+      "0x00000000000000000000000000000026e87ceb0dded7698dcdc0438afdc28e29",
+      "0x00000000000000000000000000000000000dd59cabac6786c97fca8439831419",
+      "0x000000000000000000000000000000e07e7eacfef9a668a3ddce2d0c4046658f",
+      "0x000000000000000000000000000000000023d8fca06624138c2d3d3fffc8d519",
+      "0x0000000000000000000000000000002e76fff9d84358504934f471f5186c95dc",
+      "0x00000000000000000000000000000000000f7cd2abfd7e321c34fad597296f25",
+      "0x00000000000000000000000000000071cd06c01cefed741e4b263af1a6afaa92",
+      "0x0000000000000000000000000000000000166a2d76c9a7d1235eb427d46ad022",
+      "0x000000000000000000000000000000306de07f6eb873e66fe05ef4cf68c0394f",
+      "0x00000000000000000000000000000000001cdd48c4e4987c45a5bde93bab830a",
+      "0x0000000000000000000000000000009d03c3b40afbc779158301f2afccab2049",
+      "0x000000000000000000000000000000000013c165c7dddfd70dff9ca5fc4dce4f",
+      "0x000000000000000000000000000000eb3776a3d37a8deaa919ff3d5e8a9db49e",
+      "0x00000000000000000000000000000000002ee0f08b07e2e90dc8904de59b6fd1",
+      "0x000000000000000000000000000000634036234c69fabc691ee39b6d69601e4c",
+      "0x0000000000000000000000000000000000202b26b5336682cea5bf93b4142511",
+      "0x000000000000000000000000000000bc94441146ad5f33dc81168a6500bf7e0b",
+      "0x00000000000000000000000000000000000b22fadd7090ff5cd70cdf9bf234b8",
+      "0x000000000000000000000000000000caffd9638f875bb9c73bbcae489b824cd1",
+      "0x0000000000000000000000000000000000238f743695c099bbdd3fede258b504",
+      "0x0000000000000000000000000000009439d415f58b9dc8a7fadfad1ea8477fd0",
+      "0x00000000000000000000000000000000000fe0537fa0a15c222e0ad7672caa42",
+      "0x000000000000000000000000000000bc1ea83364c2676d2ef63637f26d1cf89e",
+      "0x00000000000000000000000000000000000591b2fe2ccdca1266fc64de7e694c",
+      "0x0000000000000000000000000000001fbd28b0ed0d034e69f7852f11d5ce9ea0",
+      "0x0000000000000000000000000000000000091a2d0e2ce5029a83138809c463c3",
+      "0x0000000000000000000000000000009750fdf553d052a4546f378e7b6bd9c9d0",
+      "0x000000000000000000000000000000000010115a0d06930ccd8ab058003155fb",
+      "0x000000000000000000000000000000d7a6cd3e24b1a0e1305a605a8b3522b309",
+      "0x000000000000000000000000000000000006724254be3a841a14f63f48a7d65b",
+      "0x0000000000000000000000000000007786956758c54a82c7647080ee170444a5",
+      "0x000000000000000000000000000000000029941ad445c8a8a7ee5cd7d6cd13e8",
+      "0x0000000000000000000000000000007c3abd739420dccccabaed6116c99295a5",
+      "0x00000000000000000000000000000000002a2adf6d2f794de5b5042cf0f3b477",
+      "0x000000000000000000000000000000db9b02ab4e6a895c178e867deb941cebc4",
+      "0x0000000000000000000000000000000000252ab30222f808ef21bc2efd3dcd5d",
+      "0x000000000000000000000000000000b570825037f518f1533db3ed1e0d4c2f61",
+      "0x00000000000000000000000000000000002d9bd9bfba8fa50bc39630bf5f8422",
+      "0x000000000000000000000000000000fbaacbd8da2f519f6b33e1ceea3847dc7a",
+      "0x000000000000000000000000000000000018be9e01d85b28911d46dd5cdc675e",
+      "0x0000000000000000000000000000009e944d5d2351b35ed3de7108f3824b9e15",
+      "0x0000000000000000000000000000000000243d46f289385cef08cec6de6cd0fe",
+      "0x00000000000000000000000000000076b967748ded2502ff48aa7fe59387ad7a",
+      "0x00000000000000000000000000000000000f81d901e7055cf134e881372dedec",
+      "0x00000000000000000000000000000099069eea0a9a10d100f6696e6a4aae9c20",
+      "0x00000000000000000000000000000000000903eacaaf517945fc3eb5b280ae90",
+      "0x00000000000000000000000000000069b11930f58e0d77781e04a030a215b948",
+      "0x00000000000000000000000000000000001dbc81b058edd6546cb7e193400c08",
+      "0x0000000000000000000000000000008d7d8535416446ebf7fba40d435b1b4f5f",
+      "0x00000000000000000000000000000000002896dc0a60028928f74f16a72dbcbc",
+      "0x0000000000000000000000000000002b80d6b55199d55c762fbaec636a525f3e",
+      "0x0000000000000000000000000000000000217f0ffe90bea51c49a1b331adae9c",
+      "0x0000000000000000000000000000000ed2d8303f6f9c83d86d5c13f3fb4e99dd",
+      "0x000000000000000000000000000000000009c45c61155d314160b50b20e35c94",
+      "0x0000000000000000000000000000009cf5a0abb80a3b2fe13b28fe8f315409b7",
+      "0x0000000000000000000000000000000000188a2ffed7f8cbe84c7a0f1b018cd0",
+      "0x00000000000000000000000000000085656153a6120eebdf3a488dccad95d00d",
+      "0x000000000000000000000000000000000023cd626f5dde3ce81de0e7d4f74dc2",
+      "0x00000000000000000000000000000052c3cfa63996daa8314b27662826251092",
+      "0x0000000000000000000000000000000000061998dda79b7c5b9adc0113867766",
+      "0x000000000000000000000000000000b3105a6e5e3268bb6240ed2c345f5ff3db",
+      "0x0000000000000000000000000000000000225ce8d1f417dd9b831fe8022aa11d",
+      "0x000000000000000000000000000000cf91f0cb73295831bc93869fc19cdbad99",
+      "0x00000000000000000000000000000000001ee5d0cdde02f62e468b034f988c56",
+      "0x000000000000000000000000000000183a142ac675e313630847be47fe912b91",
+      "0x00000000000000000000000000000000001558e16ed49142b74e4a2085b22287",
+      "0x0000000000000000000000000000000000000000000000000000000000000001",
+      "0x0000000000000000000000000000000000000000000000000000000000000000",
+      "0x0000000000000000000000000000000000000000000000000000000000000002",
+      "0x0000000000000000000000000000000000000000000000000000000000000000",
+      "0x000000000000000000000000000000892e1162932973de701dc8164a1f06ea33",
+      "0x000000000000000000000000000000000004c3913621610ca326bc173830c8c9",
+      "0x000000000000000000000000000000b405779798c85f7b9c70fdad1e2d64e4ae",
+      "0x000000000000000000000000000000000007e57ead88f1e1abc299f1f835d15a"
+    ],
+    "hash": "0086ec84c9f67b94f2477b948fa7e7dbc7265aa28f8618547ecdc8f35a8843b4"
+  }
+}

package/dest/prove_native.d.ts

@@ -1,13 +1,13 @@
+import { CIVC_PROOF_LENGTH } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import type { Logger } from '@aztec/foundation/log';
 import type { AvmCircuitInputs, AvmCircuitPublicInputs } from '@aztec/stdlib/avm';
+import { type ProofAndVerificationKey } from '@aztec/stdlib/interfaces/server';
 import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
-import type { ClientIvcProof } from '@aztec/stdlib/proofs';
 import { VerificationKeyAsFields } from '@aztec/stdlib/vks';
-export declare function proveClientIVC(bbBinaryPath: string, bbWorkingDirectory: string, witnessStack: Uint8Array[], bytecodes: string[], vks: string[], logger: Logger): Promise<ClientIvcProof>;
-export declare function proveTube(pathToBB: string, workingDirectory: string, logger: Logger): Promise<import("@aztec/stdlib/interfaces/server").ProofAndVerificationKey<535>>;
-export declare function proveRollupHonk(name: string, pathToBB: string, workingDirectory: string, circuit: NoirCompiledCircuit, witness: Uint8Array, logger: Logger): Promise<import("@aztec/stdlib/interfaces/server").ProofAndVerificationKey<535>>;
-export declare function proveKeccakHonk(name: string, pathToBB: string, workingDirectory: string, circuit: NoirCompiledCircuit, witness: Uint8Array, logger: Logger): Promise<import("@aztec/stdlib/interfaces/server").ProofAndVerificationKey<457>>;
+export declare function proveClientIVC(bbBinaryPath: string, bbWorkingDirectory: string, witnessStack: Uint8Array[], bytecodes: string[], vks: string[], logger: Logger): Promise<ProofAndVerificationKey<typeof CIVC_PROOF_LENGTH>>;
+export declare function proveRollupHonk(name: string, pathToBB: string, workingDirectory: string, circuit: NoirCompiledCircuit, witness: Uint8Array, logger: Logger): Promise<ProofAndVerificationKey<535>>;
+export declare function proveKeccakHonk(name: string, pathToBB: string, workingDirectory: string, circuit: NoirCompiledCircuit, witness: Uint8Array, logger: Logger): Promise<ProofAndVerificationKey<457>>;
 export declare function proveAvm(avmCircuitInputs: AvmCircuitInputs, workingDirectory: string, logger: Logger, skipPublicInputsValidation?: boolean): Promise<{
     vk: VerificationKeyAsFields;
     proof: Fr[];

package/dest/prove_native.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prove_native.d.ts","sourceRoot":"","sources":["../src/prove_native.ts"],"names":[],"mappings":"AAuBA,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;AAElE,OAAO,EAAE,uBAAuB,EAA4B,MAAM,mBAAmB,CAAC;AAMtF,wBAAsB,cAAc,CAClC,YAAY,EAAE,MAAM,EACpB,kBAAkB,EAAE,MAAM,EAC1B,YAAY,EAAE,UAAU,EAAE,EAC1B,SAAS,EAAE,MAAM,EAAE,EACnB,GAAG,EAAE,MAAM,EAAE,EACb,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;AAmCD,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,EACd,0BAA0B,GAAE,OAAe,GAC1C,OAAO,CAAC;IACT,EAAE,EAAE,uBAAuB,CAAC;IAC5B,KAAK,EAAE,EAAE,EAAE,CAAC;IACZ,YAAY,EAAE,sBAAsB,CAAC;CACtC,CAAC,CAsED"}
+{"version":3,"file":"prove_native.d.ts","sourceRoot":"","sources":["../src/prove_native.ts"],"names":[],"mappings":"AAcA,OAAO,EAGL,iBAAiB,EAGlB,MAAM,kBAAkB,CAAC;AAC1B,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;AAClF,OAAO,EAAE,KAAK,uBAAuB,EAA+B,MAAM,iCAAiC,CAAC;AAC5G,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAG9D,OAAO,EAAE,uBAAuB,EAAuB,MAAM,mBAAmB,CAAC;AAqBjF,wBAAsB,cAAc,CAClC,YAAY,EAAE,MAAM,EACpB,kBAAkB,EAAE,MAAM,EAC1B,YAAY,EAAE,UAAU,EAAE,EAC1B,SAAS,EAAE,MAAM,EAAE,EACnB,GAAG,EAAE,MAAM,EAAE,EACb,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,uBAAuB,CAAC,OAAO,iBAAiB,CAAC,CAAC,CA6B5D;AA4DD,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,yCAYf;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,yCAYf;AAED,wBAAsB,QAAQ,CAC5B,gBAAgB,EAAE,gBAAgB,EAClC,gBAAgB,EAAE,MAAM,EACxB,MAAM,EAAE,MAAM,EACd,0BAA0B,GAAE,OAAe,GAC1C,OAAO,CAAC;IACT,EAAE,EAAE,uBAAuB,CAAC;IAC5B,KAAK,EAAE,EAAE,EAAE,CAAC;IACZ,YAAY,EAAE,sBAAsB,CAAC;CACtC,CAAC,CAsED"}

package/dest/prove_native.js

@@ -1,13 +1,25 @@
-import { BB_RESULT, PROOF_FILENAME, PUBLIC_INPUTS_FILENAME, VK_FILENAME, executeBbClientIvcProof, extractVkData, generateAvmProof, generateProof, generateTubeProof, readClientIVCProofFromOutputDirectory, readProofAsFields, verifyAvmProof, verifyProof } from '@aztec/bb-prover';
-import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED, NESTED_RECURSIVE_PROOF_LENGTH, RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, TUBE_PROOF_LENGTH } from '@aztec/constants';
+import { BB_RESULT, PROOF_FILENAME, PUBLIC_INPUTS_FILENAME, VK_FILENAME, executeBbClientIvcProof, extractVkData, generateAvmProof, generateProof, readProofsFromOutputDirectory, verifyAvmProof, verifyProof } from '@aztec/bb-prover';
+import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED, CIVC_PROOF_LENGTH, NESTED_RECURSIVE_PROOF_LENGTH, RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader } from '@aztec/foundation/serialize';
 import { makeProofAndVerificationKey } from '@aztec/stdlib/interfaces/server';
 import { enhanceProofWithPiValidationFlag } from '@aztec/stdlib/rollup';
-import { VerificationKeyAsFields } from '@aztec/stdlib/vks';
+import { VerificationKeyAsFields, VerificationKeyData } from '@aztec/stdlib/vks';
 import * as fs from 'fs/promises';
 import { Encoder } from 'msgpackr';
 import * as path from 'path';
+/**
+ * Converts verification key bytes from a compiled circuit to VerificationKeyData format
+ * @param vkBytes - The verification key bytes from the circuit
+ * @returns The verification key data
+ */ async function convertVkBytesToVkData(vkBytes) {
+    // Convert binary to field elements (32 bytes per field)
+    const numFields = vkBytes.length / Fr.SIZE_IN_BYTES;
+    const reader = BufferReader.asReader(vkBytes);
+    const fields = reader.readArray(numFields, Fr);
+    const vkAsFields = await VerificationKeyAsFields.fromKey(fields);
+    return new VerificationKeyData(vkAsFields, vkBytes);
+}
 export async function proveClientIVC(bbBinaryPath, bbWorkingDirectory, witnessStack, bytecodes, vks, logger) {
     const stepToStruct = (bytecode, index)=>{
         return {
@@ -26,7 +38,9 @@ export async function proveClientIVC(bbBinaryPath, bbWorkingDirectory, witnessSt
     if (provingResult.status === BB_RESULT.FAILURE) {
         throw new Error(provingResult.reason);
     }
-    return readClientIVCProofFromOutputDirectory(bbWorkingDirectory);
+    const vk = await extractVkData(provingResult.vkDirectoryPath);
+    const proof = await readProofsFromOutputDirectory(provingResult.proofPath, vk, CIVC_PROOF_LENGTH, logger);
+    return makeProofAndVerificationKey(proof, vk);
 }
 async function verifyProofWithKey(pathToBB, workingDirectory, verificationKey, proof, flavor, logger) {
     const publicInputsFileName = path.join(workingDirectory, PUBLIC_INPUTS_FILENAME);
@@ -42,25 +56,15 @@ async function verifyProofWithKey(pathToBB, workingDirectory, verificationKey, p
     }
     logger.info(`Successfully verified proof from key in ${result.durationMs} ms`);
 }
-export async function proveTube(pathToBB, workingDirectory, logger) {
-    const tubeResult = await generateTubeProof(pathToBB, workingDirectory, workingDirectory.concat('/vk'), logger.info);
-    if (tubeResult.status != BB_RESULT.SUCCESS) {
-        throw new Error('Failed to prove tube');
-    }
-    const tubeVK = await extractVkData(tubeResult.vkDirectoryPath);
-    const tubeProof = await readProofAsFields(tubeResult.proofPath, tubeVK, TUBE_PROOF_LENGTH, logger);
-    // Sanity check the tube proof
-    await verifyProofWithKey(pathToBB, workingDirectory, tubeVK, tubeProof.binaryProof, 'ultra_rollup_honk', logger);
-    return makeProofAndVerificationKey(tubeProof, tubeVK);
-}
 async function proveRollupCircuit(name, pathToBB, workingDirectory, circuit, witness, logger, flavor, proofLength) {
     await fs.writeFile(path.join(workingDirectory, 'witness.gz'), witness);
-    const proofResult = await generateProof(pathToBB, workingDirectory, name, Buffer.from(circuit.bytecode, 'base64'), path.join(workingDirectory, 'witness.gz'), flavor, logger);
+    const vkBuffer = Buffer.from(circuit.verificationKey.bytes, 'hex');
+    const proofResult = await generateProof(pathToBB, workingDirectory, name, Buffer.from(circuit.bytecode, 'base64'), vkBuffer, path.join(workingDirectory, 'witness.gz'), flavor, logger);
     if (proofResult.status != BB_RESULT.SUCCESS) {
         throw new Error(`Failed to generate proof for ${name} with flavor ${flavor}`);
     }
-    const vk = await extractVkData(proofResult.vkDirectoryPath);
-    const proof = await readProofAsFields(proofResult.proofPath, vk, proofLength, logger);
+    const vk = await convertVkBytesToVkData(vkBuffer);
+    const proof = await readProofsFromOutputDirectory(proofResult.proofPath, vk, proofLength, logger);
     await verifyProofWithKey(pathToBB, workingDirectory, vk, proof.binaryProof, flavor, logger);
     return makeProofAndVerificationKey(proof, vk);
 }
@@ -72,7 +76,7 @@ export function proveKeccakHonk(name, pathToBB, workingDirectory, circuit, witne
 }
 export async function proveAvm(avmCircuitInputs, workingDirectory, logger, skipPublicInputsValidation = false) {
     // The paths for the barretenberg binary and the write path are hardcoded for now.
-    const bbPath = path.resolve('../../barretenberg/cpp/build/bin/bb');
+    const bbPath = path.resolve('../../barretenberg/cpp/build/bin/bb-avm');
     // Then we prove.
     const proofRes = await generateAvmProof(bbPath, workingDirectory, avmCircuitInputs, logger);
     if (proofRes.status === BB_RESULT.FAILURE) {

package/dest/prove_wasm.d.ts

@@ -1,4 +1,4 @@
-import { ClientIvcProof } from '@aztec/stdlib/proofs';
-export declare function proveClientIVC(bytecodes: string[], witnessStack: Uint8Array[], vks: string[], threads?: number): Promise<ClientIvcProof>;
+import { ClientIvcProofWithPublicInputs } from '@aztec/stdlib/proofs';
+export declare function proveClientIVC(bytecodes: string[], witnessStack: Uint8Array[], vks: string[], threads?: number): Promise<ClientIvcProofWithPublicInputs>;
 export declare function proveThenVerifyAztecClient(bytecodes: string[], witnessStack: Uint8Array[], vks: string[], 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":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAWtD,wBAAsB,cAAc,CAClC,SAAS,EAAE,MAAM,EAAE,EACnB,YAAY,EAAE,UAAU,EAAE,EAC1B,GAAG,EAAE,MAAM,EAAE,EACb,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,cAAc,CAAC,CAezB;AAED,wBAAsB,0BAA0B,CAC9C,SAAS,EAAE,MAAM,EAAE,EACnB,YAAY,EAAE,UAAU,EAAE,EAC1B,GAAG,EAAE,MAAM,EAAE,EACb,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,OAAO,CAAC,CAiBlB"}
+{"version":3,"file":"prove_wasm.d.ts","sourceRoot":"","sources":["../src/prove_wasm.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,8BAA8B,EAAE,MAAM,sBAAsB,CAAC;AAWtE,wBAAsB,cAAc,CAClC,SAAS,EAAE,MAAM,EAAE,EACnB,YAAY,EAAE,UAAU,EAAE,EAC1B,GAAG,EAAE,MAAM,EAAE,EACb,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,8BAA8B,CAAC,CAezC;AAED,wBAAsB,0BAA0B,CAC9C,SAAS,EAAE,MAAM,EAAE,EACnB,YAAY,EAAE,UAAU,EAAE,EAC1B,GAAG,EAAE,MAAM,EAAE,EACb,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,OAAO,CAAC,CAiBlB"}

package/dest/prove_wasm.js

@@ -1,5 +1,5 @@
 import { createLogger } from '@aztec/foundation/log';
-import { ClientIvcProof } from '@aztec/stdlib/proofs';
+import { ClientIvcProofWithPublicInputs } from '@aztec/stdlib/proofs';
 import os from 'os';
 import { ungzip } from 'pako';
 const logger = createLogger('ivc-integration:prove_wasm');
@@ -10,11 +10,12 @@ export async function proveClientIVC(bytecodes, witnessStack, vks, 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
+        logger: logger.info,
+        wasmPath: process.env.BB_WASM_PATH
     });
     try {
         const [proof] = await backend.prove(witnessStack.map((arr)=>ungzip(arr)), vks.map((hex)=>new Uint8Array(Buffer.from(hex, 'hex'))));
-        return new ClientIvcProof(Buffer.from(proof));
+        return ClientIvcProofWithPublicInputs.fromBufferArray(proof);
     } finally{
         await backend.destroy();
     }
@@ -23,12 +24,13 @@ export async function proveThenVerifyAztecClient(bytecodes, witnessStack, vks, t
     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
+        logger: logger.info,
+        wasmPath: process.env.BB_WASM_PATH
     });
     try {
         // These are optional - easier not to pass them.
-        const [proof, vk] = await backend.prove(witnessStack.map((arr)=>ungzip(arr)), vks.map((hex)=>new Uint8Array(Buffer.from(hex, 'hex'))));
-        const verified = await backend.verify(proof, vk);
+        const [_, msgpackProof, vk] = await backend.prove(witnessStack.map((arr)=>ungzip(arr)), vks.map((hex)=>new Uint8Array(Buffer.from(hex, 'hex'))));
+        const verified = await backend.verify(msgpackProof, vk);
         return verified;
     } finally{
         await backend.destroy();

package/dest/scripts/generate_declaration_files.js

@@ -6,10 +6,6 @@ import { type NoirCompiledCircuit } from '@aztec/stdlib/noir';
 const circuit: NoirCompiledCircuit;
 export = circuit;
 `;
-const vk = `\
-const vk: { keyAsBytes: string; keyAsFields: string[] };
-export = vk;
-`;
 async function generateDeclarationFor(target, content) {
     const files = await readdir(target);
     for (const file of files){
@@ -23,5 +19,3 @@ async function generateDeclarationFor(target, content) {
 }
 // Generate declaration files for contracts
 await generateDeclarationFor(fileURLToPath(new URL('../../artifacts', import.meta.url).href), contract);
-// Generate declaration files for vks
-await generateDeclarationFor(fileURLToPath(new URL('../../artifacts/keys', import.meta.url).href), vk);

package/dest/scripts/generate_ts_from_abi.js

@@ -11,9 +11,9 @@ const circuits = [
     'mock_private_kernel_inner',
     'mock_private_kernel_reset',
     'mock_private_kernel_tail',
-    'mock_rollup_base_public',
-    'mock_rollup_base_private',
-    'mock_rollup_merge',
+    'mock_rollup_tx_base_public',
+    'mock_rollup_tx_base_private',
+    'mock_rollup_tx_merge',
     'mock_rollup_root'
 ];
 const main = async ()=>{