@aztec/protocol-contracts 0.68.1 → 0.68.2

package/artifacts/ContractInstanceDeployer.json

@@ -3,6 +3,26 @@
   "noir_version": "1.0.0-beta.0+8079d640b38957b4",
   "name": "ContractInstanceDeployer",
   "functions": [
+    {
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [],
+        "return_type": null
+      },
+      "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
+      "debug_symbols": "nZLBCoQgFEX/5a1bpFmmvxJDWFkIomE2MET/PhbN0AxtbPPgyj1341mgk8081Mr0dgJeLaBtK7yyJqRlTaBxSms11OdnSLeD0N6fRmG2OHnhPPAMJyBNB5ykge6VlsALvD4SQDiyn0X2SWQ/j+vjy31GEDsIRkjxZSjbmfwGU9xg6A2mjGeyyz9neVp+mBzTH2YN6SmcEo2Wh1L9bNqTYf41yj/ZRmdb2c1ObtqdjAu3QjTBOMyG6Tc=",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
     {
       "name": "compute_note_hash_and_optionally_a_nullifier",
       "is_unconstrained": true,
@@ -1894,7 +1914,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "7V3bbuM4DP2XPOdBpCSS6q8sFoNeMoMARVv0ssCi6L+PnFay4/gygtMZeco+FHVC0YfnWBJFqcnr5mZ39fLj2/7u+/3T5uKf183t/fXl8/7+Ll69bkAOrz09XN41l0/Pl4/PmwugYLab3d1N/JONedtuvu9vd5sLwrftiTGKlQ9jFGqNwdKAtfUQPqytDzhjDeTAJiTkkLI9sh+yt9k7WCut9aBzg5SMTeOuNf53u4GgzAwzg0aZGWEGlJkRZlCZGWHGKjMjzDhlZoQZr8yMMEPKzAgzrMyMMKM58BgzmgOPMGM1Bx5jRnPgMWY0Bx5jRnPgMWacMjPCjObAY8xoDjzGTPU5sDctM+TmmGHJRIrBRcxUnwP/MWaqz4H/FDNueQ7sjPcfxs4EaGN14XAH+PQ7DOZk1qewHZppihBDUgstzPF5pqHs1Fh8HlPFezPzEAi6bI0dUoatrc9ALBk/zTcgpmcdMLQhWgMD1kSQcJjQwgjv2ljVplptnGpTrTZ+qTacgSO7GeNzTShfRBtSbarVhlWb82oDrTa2w/ewNtC6jhmeP7Ju1BFVp2J1guYDs+qQNVkdgbk1Y163oDB0+B6yjq9icg2uMwrCQR1vVJ2K1QFVp2J1tEJQszpaI6hZHafqVKyOV3UqVodUnYrVYVWnYnVE1alYHa0VVKwOaa2gZnW0VlCzOlorqFkdrRXUrI7T/Z2K1dEzBTWro6cKzqxOMJlvQ/ZInYZvPSnwe/keXs+X3CH2lLYHeZrpb+hcnumdcLYGHjIGTqdKEKTtnCAH7KFq7OgSDsQO8RH7qbEjTg946JgeDs+wqTtMyf2te9ahPEyoOkwb8kFzh673JDJWjd1jNvYk0xIBmaQREPp+oParBOr+nkDZ50mOmRb0UK+cnHBCfxEnwedkCGQBJ6ycnHByhjzLBNdywjOcOJcZdPFnmhPLGboVsF3jBnuoGruElCPacIJdzIqxw4qx44qx2xVjdyvG7leMnVaMnVeMve55dRr7medVmqt1gskliVjBgmnsHrJrj+B62INZMXZYMXZcMXZbNXZ0lLET9bG7FWP3K8ZOK8bOVWOnXFv3DDMTGZNNgTJJfyIL8lUCrXvGFsiBisclgYKpe34vizSk4gYzwEmkdWcD54y07txhPNID+LqThxnwru5VSt59tuL5BHzly/Jp8MP5A+fdPCs48zlHhCZFSgidO7gwuB8aEaX6Mrruou/9c5Hiw1QfpMEJ3EXXSQc79z/vLKmqLtj9pCx8v8HgxOksZ6FtoOkbAAbKHRIDL48aTG2g4tXV4/72dv/j29F3iZjmFwwOInH+gjxM2aNtzAGRTLo5dw5Zvu94gv9c97TcvU09nV3ou+czuMecENm+e/lc92G5+9z/OHDP/cjXipzNPSx2L/lolbj+kzPyBRdl7tMunnjqu7fL3ecRQ07JcWd0H3rdKl7AxNAA+ehX/FN+rceAyxueQDMb42LyBySK4eMtz3iBjenwQYqQl2RBTmaL4XMG002ovAmXN5HyJqG4yfCW5XQTKG+C5U1seZNy9aVcfSlXX8rVl3L1pVz9UK5+KFd/uIwc8jGK0DlFkZrY8iauvIkvb0LlTbi8iRQ2eYuX/10+7i+vbndNEte8+3J3nXK6ePn8/0N6J2V9D4/317ubl8ddk/91Ur/moUDeWmyH/MNLfmtNHmobgQi3jIeMO17EKs42Lt8ilAjnJw==",
+      "debug_symbols": "7V3bbuM4DP2XPOdBJCWS6q8sFoNeMoMARVv0ssCi6L+Pk1aK4/gygtMZeco+FHVC0YfnWBJFqcnr6mZz9fLj2/bu+/3T6uKf19Xt/fXl8/b+rrl6XYHuX3t6uLzbXT49Xz4+ry6Ao1uvNnc3zZ/i3Nt69X17u1ldML6tT4xRST+MUflgDMQ91hQgflhTiDhhDeyBEhL2yNkepdeesncg0oN1r7FDTsZOQtv43/UKojHTzww6Y2aAGTBmBphBY2aAGTJmBpjxxswAM8GYGWCGjZkBZsSYGWDGcuAhZiwHHmCGLAceYsZy4CFmLAceYsZy4CFmvDEzwIzlwEPMWA48xEz1OXBwB2bYTzEjmolUh7OYqT4H/mPMVJ8D/ylm/Pwc2LsQPoy9i3CI1cf9HeDT79Cbk1FIYXt04xQhxqQWEkzxeaah7NRYQx5TNQQ38RAo+myNLVL6rSlkIMQujPMNiOlZB4yHEMn1WTNDwuFiy9bttSHTplptvGlTrTZhrjaSgaP4CeNzTShfRBs2barVRkyb82oDB23oiO9e64PrJsMLR9Y7ddTUqVidaPnApDpMLqujMLVmzOsWVIEW39Tn2iEm1+BboyDs1QnO1KlYHTB1KlbHKgQ1q2M1gprV8aZOxeoEU6diddjUqVgdMXUqVkdNnYrVsVpBxeqw1QpqVsdqBTWrY7WCmtWxWkHN6njb36lYHTtTULM6dqrgzOpEl/l2TEfq7Pi2kwK/l+/+9XzJHajZ7s49KPBEf0Pv80zvVbI1SJ8xSDpVgqCHzgm6xx6rxo4+4UBsEd9gPzX2LOkBjy3T/UFacXWHqbm/tc86lIcJVYdJMR809+g7T6Jg1dgDZuPAOi4RsEsaAWPoBkpfJVD/9wQqIU9yIjyjhwbj5IQT/os4iSEnQ6AzOBHj5ISTM+RZLvoDJzLBifeZQd/8jHNCkqGTArWNd9hj1dg1phyR4gl2dQvGDgvGjgvGTgvG7heMPSwYOy8YuywYe93z6jj2M8+rPFXrBJdLEk0FC8axB8iuA4LvYI9uwdhhwdhxwdipauzoOWNn7mL3C8YeFoydF4xdqsbOubYeBCYmMmFKgQprdyKL+lUCrXvGVsiBasA5gYKre34vizSm4oYIwEmkdWcD54y07txhONI9+LqThwnwvu5VSt59Jg1yAr7yZfk4+P78QfJuHilOfM4Ro0uRMkLrDj727oc2iFJ9GX170ff+uUjNw1QfpN4J3Deukw409T/voqmqrtj+pCx6v0HvxOlJstAUefwGgJFzh8Qo86MGVxuo5urqcXt7u/3x7ei7RNzuF/QOIs38BXmYoqNtzB6RXLq5tA5Zvu94Qvhc9zzfPaWeLj523csZ3GNOiKjrXj/XfZzvPvc/idJxP/C1ImdzD7Pdaz5apb775Ax8wUWZ+7SLp4G77mm++zxi6Ck5/ozuY6dbNRcwMjRAPvrV/Km/1mPA5w1P4ImNcXX5AxLVyfGWZ3OBO9P+gxQxL8minswW/ecMxptweRMpb6LlTWJxk/4ty/EmUN4Ey5tQeZNy9bVcfS1XX8vV13L1tVz9WK5+LFe/v4wc8zGK2DpFkZpQeRNf3iSUN+HyJlLeRAubvDWX/10+bi+vbje7JG737svddcrpmsvn/x/SOynre3i8v97cvDxudvlfK/XbPRQoa8LDkL9/KazJ5aF2JxDjWnCfcTcXTRVn3SzfGigNnJ8=",
       "brillig_names": [
         "decompose_hint",
         "lte_hint",
@@ -1903,26 +1923,6 @@
         "directive_invert"
       ],
       "verification_key": "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"
-    },
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [],
-        "return_type": null
-      },
-      "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
-      "debug_symbols": "nZLBCoQgFEX/5a1bpFmmvxJDWFkIomE2MET/PhbN0AxtbPPgyj1341mgk8081Mr0dgJeLaBtK7yyJqRlTaBxSms11OdnSLeD0N6fRmG2OHnhPPAMJyBNB5ykge6VlsALvD4SQDiyn0X2SWQ/j+vjy31GEDsIRkjxZSjbmfwGU9xg6A2mjGeyyz9neVp+mBzTH2YN6SmcEo2Wh1L9bNqTYf41yj/ZRmdb2c1ObtqdjAu3QjTBOMyG6Tc=",
-      "brillig_names": [
-        "sync_notes"
-      ]
     }
   ],
   "outputs": {
@@ -2390,27 +2390,27 @@
       "path": "std/hash/poseidon2.nr",
       "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = crate::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: &[] }\n    }\n}\n"
     },
-    "272": {
+    "273": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
       "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n///   debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n///   debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n///   debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper<let M: u32, let N: u32>(\n    msg: str<M>,\n    args: [Field; N],\n) {\n    debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle<let M: u32>(_msg: str<M>, args: [Field]) {}\n"
     },
-    "275": {
+    "276": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
       "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::scoped::Scoped,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    traits::{is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::{arrays::array_concat, field::field_from_bytes};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    tx_hash: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: BoundedVec<u8, 160> = BoundedVec::new();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..inputs.len() {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes.push(item_bytes[j]);\n        }\n    }\n\n    sha256_to_field(bytes.storage())\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> std::hash::poseidon2::Poseidon2 {\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: std::hash::poseidon2::Poseidon2,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> std::hash::poseidon2::Poseidon2 {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: std::hash::poseidon2::Poseidon2,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> std::hash::poseidon2::Poseidon2 {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let two_pow_64 = 18446744073709551616;\n    let empty_sponge = std::hash::poseidon2::Poseidon2::new((in_len as Field) * two_pow_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut contructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(contructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == contructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = std::hash::sha256(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
     },
-    "299": {
+    "300": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/address/salted_initialization_hash.nr",
       "source": "use crate::{\n    address::aztec_address::AztecAddress, constants::GENERATOR_INDEX__PARTIAL_ADDRESS,\n    hash::poseidon2_hash_with_separator, traits::ToField,\n};\n\n// Salted initialization hash. Used in the computation of a partial address.\npub struct SaltedInitializationHash {\n    pub inner: Field,\n}\n\nimpl ToField for SaltedInitializationHash {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl SaltedInitializationHash {\n    pub fn from_field(field: Field) -> Self {\n        Self { inner: field }\n    }\n\n    pub fn compute(salt: Field, initialization_hash: Field, deployer: AztecAddress) -> Self {\n        SaltedInitializationHash::from_field(poseidon2_hash_with_separator(\n            [salt, initialization_hash, deployer.to_field()],\n            GENERATOR_INDEX__PARTIAL_ADDRESS,\n        ))\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n"
     },
-    "301": {
+    "302": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/address/partial_address.nr",
       "source": "use crate::{\n    address::{aztec_address::AztecAddress, salted_initialization_hash::SaltedInitializationHash},\n    constants::GENERATOR_INDEX__PARTIAL_ADDRESS,\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    traits::{Deserialize, Serialize, ToField},\n};\n\nglobal PARTIAL_ADDRESS_LENGTH: u32 = 1;\n\n// Partial address\npub struct PartialAddress {\n    pub inner: Field,\n}\n\nimpl ToField for PartialAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl Serialize<PARTIAL_ADDRESS_LENGTH> for PartialAddress {\n    fn serialize(self: Self) -> [Field; PARTIAL_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<PARTIAL_ADDRESS_LENGTH> for PartialAddress {\n    fn deserialize(fields: [Field; PARTIAL_ADDRESS_LENGTH]) -> Self {\n        PartialAddress { inner: fields[0] }\n    }\n}\n\nimpl PartialAddress {\n    pub fn from_field(field: Field) -> Self {\n        Self { inner: field }\n    }\n\n    pub fn compute(\n        contract_class_id: ContractClassId,\n        salt: Field,\n        initialization_hash: Field,\n        deployer: AztecAddress,\n    ) -> Self {\n        PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            SaltedInitializationHash::compute(salt, initialization_hash, deployer),\n        )\n    }\n\n    pub fn compute_from_salted_initialization_hash(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n    ) -> Self {\n        PartialAddress::from_field(poseidon2_hash_with_separator(\n            [contract_class_id.to_field(), salted_initialization_hash.to_field()],\n            GENERATOR_INDEX__PARTIAL_ADDRESS,\n        ))\n    }\n\n    pub fn to_field(self) -> Field {\n        self.inner\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.to_field() == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n"
     },
-    "302": {
+    "303": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
       "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        MAX_FIELD_VALUE,\n    },\n    contract_class_id::ContractClassId,\n    hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n    merkle_tree::membership::MembershipWitness,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n    traits::{Deserialize, Empty, FromField, Serialize, ToField},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse ec::{pow, sqrt};\nuse std::embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key};\n\n// Aztec address\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        FromField::from_field(fields[0])\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secrect can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_private_function(\n        function_selector: FunctionSelector,\n        function_vk_hash: Field,\n        function_leaf_membership_witness: MembershipWitness<FUNCTION_TREE_HEIGHT>,\n        contract_class_artifact_hash: Field,\n        contract_class_public_bytecode_commitment: Field,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let private_functions_root = private_functions_root_from_siblings(\n            function_selector,\n            function_vk_hash,\n            function_leaf_membership_witness.leaf_index,\n            function_leaf_membership_witness.sibling_path,\n        );\n\n        let contract_class_id = ContractClassId::compute(\n            contract_class_artifact_hash,\n            private_functions_root,\n            contract_class_public_bytecode_commitment,\n        );\n\n        // Compute contract address using the preimage which includes the class_id.\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
     },
-    "311": {
+    "312": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/public_keys.nr",
       "source": "use crate::{\n    address::public_keys_hash::PublicKeysHash,\n    constants::{\n        DEFAULT_IVPK_M_X, DEFAULT_IVPK_M_Y, DEFAULT_NPK_M_X, DEFAULT_NPK_M_Y, DEFAULT_OVPK_M_X,\n        DEFAULT_OVPK_M_Y, DEFAULT_TPK_M_X, DEFAULT_TPK_M_Y, GENERATOR_INDEX__PUBLIC_KEYS_HASH,\n    },\n    hash::poseidon2_hash_with_separator,\n    point::POINT_LENGTH,\n    traits::{Deserialize, Hash, Serialize},\n};\n\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse std::default::Default;\n\npub global PUBLIC_KEYS_LENGTH: u32 = 12;\n\npub struct PublicKeys {\n    pub npk_m: NpkM,\n    pub ivpk_m: IvpkM,\n    pub ovpk_m: OvpkM,\n    pub tpk_m: TpkM,\n}\n\npub trait ToPoint {\n    fn to_point(self) -> Point;\n}\n\npub struct NpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for NpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for NpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\n// Note: If we store npk_m_hash directly we can remove this trait implementation. See #8091\nimpl Hash for NpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\npub struct IvpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for IvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for IvpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\npub struct OvpkM {\n    pub inner: Point,\n}\n\nimpl Hash for OvpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\nimpl ToPoint for OvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for OvpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\npub struct TpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for TpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for TpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\nimpl Default for PublicKeys {\n    fn default() -> Self {\n        PublicKeys {\n            npk_m: NpkM {\n                inner: Point { x: DEFAULT_NPK_M_X, y: DEFAULT_NPK_M_Y, is_infinite: false },\n            },\n            ivpk_m: IvpkM {\n                inner: Point { x: DEFAULT_IVPK_M_X, y: DEFAULT_IVPK_M_Y, is_infinite: false },\n            },\n            ovpk_m: OvpkM {\n                inner: Point { x: DEFAULT_OVPK_M_X, y: DEFAULT_OVPK_M_Y, is_infinite: false },\n            },\n            tpk_m: TpkM {\n                inner: Point { x: DEFAULT_TPK_M_X, y: DEFAULT_TPK_M_Y, is_infinite: false },\n            },\n        }\n    }\n}\n\nimpl Eq for PublicKeys {\n    fn eq(self, other: PublicKeys) -> bool {\n        (self.npk_m.inner == other.npk_m.inner)\n            & (self.ivpk_m.inner == other.ivpk_m.inner)\n            & (self.ovpk_m.inner == other.ovpk_m.inner)\n            & (self.tpk_m.inner == other.tpk_m.inner)\n    }\n}\n\nimpl PublicKeys {\n    pub fn hash(self) -> PublicKeysHash {\n        PublicKeysHash::from_field(poseidon2_hash_with_separator(\n            self.serialize(),\n            GENERATOR_INDEX__PUBLIC_KEYS_HASH as Field,\n        ))\n    }\n}\n\nimpl Serialize<PUBLIC_KEYS_LENGTH> for PublicKeys {\n    fn serialize(self) -> [Field; PUBLIC_KEYS_LENGTH] {\n        [\n            self.npk_m.inner.x,\n            self.npk_m.inner.y,\n            self.npk_m.inner.is_infinite as Field,\n            self.ivpk_m.inner.x,\n            self.ivpk_m.inner.y,\n            self.ivpk_m.inner.is_infinite as Field,\n            self.ovpk_m.inner.x,\n            self.ovpk_m.inner.y,\n            self.ovpk_m.inner.is_infinite as Field,\n            self.tpk_m.inner.x,\n            self.tpk_m.inner.y,\n            self.tpk_m.inner.is_infinite as Field,\n        ]\n    }\n}\n\nimpl Deserialize<PUBLIC_KEYS_LENGTH> for PublicKeys {\n    fn deserialize(serialized: [Field; PUBLIC_KEYS_LENGTH]) -> PublicKeys {\n        PublicKeys {\n            npk_m: NpkM {\n                inner: Point {\n                    x: serialized[0],\n                    y: serialized[1],\n                    is_infinite: serialized[2] as bool,\n                },\n            },\n            ivpk_m: IvpkM {\n                inner: Point {\n                    x: serialized[3],\n                    y: serialized[4],\n                    is_infinite: serialized[5] as bool,\n                },\n            },\n            ovpk_m: OvpkM {\n                inner: Point {\n                    x: serialized[6],\n                    y: serialized[7],\n                    is_infinite: serialized[8] as bool,\n                },\n            },\n            tpk_m: TpkM {\n                inner: Point {\n                    x: serialized[9],\n                    y: serialized[10],\n                    is_infinite: serialized[11] as bool,\n                },\n            },\n        }\n    }\n}\n\npub struct AddressPoint {\n    pub inner: Point,\n}\n\nimpl ToPoint for AddressPoint {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\n#[test]\nunconstrained fn compute_public_keys_hash() {\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n        ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n        ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n        tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n    };\n\n    let actual = keys.hash();\n    let expected_public_keys_hash =\n        0x0fecd9a32db731fec1fded1b9ff957a1625c069245a3613a2538bd527068b0ad;\n\n    assert(actual.to_field() == expected_public_keys_hash);\n}\n\n#[test]\nunconstrained fn compute_default_hash() {\n    let keys = PublicKeys::default();\n\n    let actual = keys.hash();\n    let test_data_default_hash = 0x1d3bf1fb93ae0e9cda83b203dd91c3bfb492a9aecf30ec90e1057eced0f0e62d;\n\n    assert(actual.to_field() == test_data_default_hash);\n}\n\n#[test]\nunconstrained fn test_public_keys_serialization() {\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n        ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n        ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n        tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n    };\n\n    let serialized = keys.serialize();\n    let deserialized = PublicKeys::deserialize(serialized);\n\n    assert_eq(keys.npk_m.inner.x, deserialized.npk_m.inner.x);\n    assert_eq(keys.npk_m.inner.y, deserialized.npk_m.inner.y);\n    assert_eq(keys.ivpk_m.inner.x, deserialized.ivpk_m.inner.x);\n    assert_eq(keys.ivpk_m.inner.y, deserialized.ivpk_m.inner.y);\n    assert_eq(keys.ovpk_m.inner.x, deserialized.ovpk_m.inner.x);\n    assert_eq(keys.ovpk_m.inner.y, deserialized.ovpk_m.inner.y);\n    assert_eq(keys.tpk_m.inner.x, deserialized.tpk_m.inner.x);\n    assert_eq(keys.tpk_m.inner.y, deserialized.tpk_m.inner.y);\n}\n"
     },