@aztec/protocol-contracts 0.65.2 → 0.67.0

package/artifacts/ContractInstanceDeployer.json

@@ -1,98 +1,8 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.0+d9e6d430f90682f49805eba18941129678cf1930-x8664",
+  "noir_version": "1.0.0-beta.0+b3f4ad661c8c6f88544d714fd5b7b6f58a8ce4ad-x8664",
   "name": "ContractInstanceDeployer",
   "functions": [
-    {
-      "name": "compute_note_hash_and_optionally_a_nullifier",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "16541607464495309456": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 16
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [
-          {
-            "name": "contract_address",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "nonce",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "storage_slot",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "note_type_id",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "compute_nullifier",
-            "type": {
-              "kind": "boolean"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "serialized_note",
-            "type": {
-              "kind": "array",
-              "length": 0,
-              "type": {
-                "kind": "field"
-              }
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": {
-          "abi_type": {
-            "kind": "array",
-            "length": 4,
-            "type": {
-              "kind": "field"
-            }
-          },
-          "visibility": "public"
-        }
-      },
-      "bytecode": "H4sIAAAAAAAA/9VZ227aQBBdsI2xiQmFP4jUt1ayCdc3pF7yHSiBL+gH+KEv7VeXFTv2YTypkJipykjRGs/6zNkz4931pufONjz99cJ1HNqB6xr12YW2vM0qRazSkmfvTnj274RndCc8Y0WePYGnb+l9S9z5nUvd+X3sOPFhn+gI/O5vQCzo79Bmoe2DXzExVSYMVgt/Uy5eM3dpyvyfs4CZ2uAvCX9og18S7y91i49jobhRaF/qVssXeMZbEa6xiAmXfH3wfWW+CHzfmA9r+DvzYd0TJ9JtAGNRrKuNdV5obCmMrfdO61yrHd4jrXNnWqMV5TxjfDh/4lNQn7rlM2C+GHwZ8yXgI/19+wT9eO5T6PcZ7vOajFy3hslPOUetLWoqNsA/2ULSneckri9jow91j0HPJ6aPxVqB+ljo7/WZvcOfrr2ltWssYnqiRqTZEPszXwa+uL6Mk4ffMcRBLOKRsP6fwu/H0A7gGXp+IsQfsPgXvIV7qBHHioR71N+/kx/D9cid6+cn9XfdeUpvU71aSHO2Hv66wc9s+B8JP7fBXxH+yAa/2cs8mODPS8IvbPhvCX9sUz/NXvLRhv+B8Ccm+IsDrbsfXGvN/BCup3Bfb+6uqmv2RBg/Z1yt9kRTxofrg+uv980ErhPBx3M4E+LMhDgSVqaI9aCI9fifjnGoiDVSxBorYmnmMVXE0tQrV8QqFLE0615TL8qjtE/ztgtteaNJ+zRF/Erap2l+u5PWVF+xoCGOL2H9fzCdRyY8qzmtOfSuUwyMXRjFvna9pviFwId454LvlkPZw3Jz3G6W29OWrFrNt00+C8aV38NvIpyPsb+09kv7PkWtS+m7fwy6eovBVzBfAj7iKH33j434X6M/xp8IPr7+X5vLqeuuhyM2bjzj2qmMuT3/k87mjeev5bXvJsXPXXe+/lfni6gP30vnAteJ4OP7k1yIkwtx7hGLn9Gjhr6uSae4bv1auVxv2n9w0VyUuMtzf8fiJ6z/r/Abx0btLXP+cb2vjs/74365f3tbvO6nDN9bH3T6A/vRhmkVHwAA",
-      "debug_symbols": "tdfNaoQwFAXgd8k6i9z8TIyvUsoQNQ6BECVqoYjv3jhM26GzLGcj3HD9IpJDuDsbQrfdrjGP08Lat52lqfdrnHKt9oOzrsSU4u36vMzE+XDq3r/MPp/lsvqyslZJzkIeWKtFfXuMKdQ1aw7+0mm/O6396TR0vHPmNEw2MPkCky1MbmCyQ8kkBI4mHC1xtMLRGkcbHH3B0RZHNzgal0bCpZFwaSRcGgmXRsKlkXBppH+m0alHZ/21L7YF2g3QdjhbCqBNQFsCbQW0NdA2QBuYSwnMpQTmUqJyedTqw5fouxQeg9W45f5pzlo/5/Bn5JrL1IdhK+Ecvn7nrvMsK821vl/ttaD6gaRs3aRu9AU=",
-      "brillig_names": [
-        "compute_note_hash_and_optionally_a_nullifier"
-      ]
-    },
     {
       "name": "deploy",
       "is_unconstrained": false,
@@ -101,22 +11,10 @@
       ],
       "abi": {
         "error_types": {
-          "14514982005979867414": {
-            "error_kind": "string",
-            "string": "attempt to bit-shift with overflow"
-          },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
           },
-          "2920182694213909827": {
-            "error_kind": "string",
-            "string": "attempt to subtract with overflow"
-          },
           "5019202896831570965": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
@@ -124,10 +22,6 @@
           "6485997221020871071": {
             "error_kind": "string",
             "string": "call to assert_max_bit_size"
-          },
-          "7233212735005103307": {
-            "error_kind": "string",
-            "string": "attempt to multiply with overflow"
           }
         },
         "parameters": [
@@ -473,7 +367,7 @@
                       }
                     ],
                     "kind": "struct",
-                    "path": "aztec::protocol_types::header::Header"
+                    "path": "aztec::protocol_types::block_header::BlockHeader"
                   }
                 },
                 {
@@ -1085,7 +979,7 @@
                 "name": "private_call_requests",
                 "type": {
                   "kind": "array",
-                  "length": 4,
+                  "length": 5,
                   "type": {
                     "fields": [
                       {
@@ -1269,7 +1163,7 @@
                       }
                     ],
                     "kind": "struct",
-                    "path": "aztec::protocol_types::abis::side_effect::Counted"
+                    "path": "aztec::protocol_types::abis::side_effect::counted::Counted"
                   }
                 }
               },
@@ -1384,46 +1278,29 @@
                 }
               },
               {
-                "name": "start_side_effect_counter",
-                "type": {
-                  "kind": "integer",
-                  "sign": "unsigned",
-                  "width": 32
-                }
-              },
-              {
-                "name": "end_side_effect_counter",
-                "type": {
-                  "kind": "integer",
-                  "sign": "unsigned",
-                  "width": 32
-                }
-              },
-              {
-                "name": "note_encrypted_logs_hashes",
+                "name": "private_logs",
                 "type": {
                   "kind": "array",
                   "length": 16,
                   "type": {
                     "fields": [
                       {
-                        "name": "value",
-                        "type": {
-                          "kind": "field"
-                        }
-                      },
-                      {
-                        "name": "counter",
+                        "name": "log",
                         "type": {
-                          "kind": "integer",
-                          "sign": "unsigned",
-                          "width": 32
-                        }
-                      },
-                      {
-                        "name": "length",
-                        "type": {
-                          "kind": "field"
+                          "fields": [
+                            {
+                              "name": "fields",
+                              "type": {
+                                "kind": "array",
+                                "length": 18,
+                                "type": {
+                                  "kind": "field"
+                                }
+                              }
+                            }
+                          ],
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::abis::log::Log"
                         }
                       },
                       {
@@ -1433,25 +1310,6 @@
                           "sign": "unsigned",
                           "width": 32
                         }
-                      }
-                    ],
-                    "kind": "struct",
-                    "path": "aztec::protocol_types::abis::log_hash::NoteLogHash"
-                  }
-                }
-              },
-              {
-                "name": "encrypted_logs_hashes",
-                "type": {
-                  "kind": "array",
-                  "length": 4,
-                  "type": {
-                    "fields": [
-                      {
-                        "name": "value",
-                        "type": {
-                          "kind": "field"
-                        }
                       },
                       {
                         "name": "counter",
@@ -1460,22 +1318,10 @@
                           "sign": "unsigned",
                           "width": 32
                         }
-                      },
-                      {
-                        "name": "length",
-                        "type": {
-                          "kind": "field"
-                        }
-                      },
-                      {
-                        "name": "randomness",
-                        "type": {
-                          "kind": "field"
-                        }
                       }
                     ],
                     "kind": "struct",
-                    "path": "aztec::protocol_types::abis::log_hash::EncryptedLogHash"
+                    "path": "aztec::protocol_types::abis::private_log::PrivateLogData"
                   }
                 }
               },
@@ -1512,6 +1358,22 @@
                   }
                 }
               },
+              {
+                "name": "start_side_effect_counter",
+                "type": {
+                  "kind": "integer",
+                  "sign": "unsigned",
+                  "width": 32
+                }
+              },
+              {
+                "name": "end_side_effect_counter",
+                "type": {
+                  "kind": "integer",
+                  "sign": "unsigned",
+                  "width": 32
+                }
+              },
               {
                 "name": "historical_header",
                 "type": {
@@ -1788,7 +1650,7 @@
                     }
                   ],
                   "kind": "struct",
-                  "path": "aztec::protocol_types::header::Header"
+                  "path": "aztec::protocol_types::block_header::BlockHeader"
                 }
               },
               {
@@ -1899,21 +1761,107 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "7V3bbuM4DP2XPOdBpC4k+yuLwaCXzCBA0Ra9LLAo+u8rp5XsOnK8Qjw78pR9KOqEpA/PsSXqUvt1c7O7evn5fX/34/5pc/HX6+b2/vryeX9/F49eN8CHz54eLu+6w6fny8fnzQUEMdvN7u4m/knGvG03P/a3u82FZfe2PbJGtvxhjRx6ayBfsLYe5MPaesEZa5Ycm8VDjwSgYA02xwZrOVtjKBkbDMnYdCfvjb9tNyBKTJEYNEpMmRhQYsrEoBJTJsYqMWVinBJTJsYrMWVighJTJoaUmDIxWvlOEKOVb5kYq5XvBDFa+U4Qo5XvBDFa+U4Q45SYMjFa+U4Qo5XvBDHNV77kMzEsc8QQ24SbDZ5FTPOV7+8ipvnK9zcR4xaofJ3xCbwz0rcD4f0M8MvPUKzFrM9522D8zBkAMYkLKH3rBFwSIARIahkZSEslaT0ksdh7MyMto8vWKHNtqvUpRYfm9GWAKOl6RAtz18xybbWzKk674jgVp11xvIozLw5lOpDcjPGS/WZQcdoVhxYQB3px7JDwojjQx46VjZ+x/urysMrTsjzFsZIN1mR5GGbHSrlgRyYYNFclPNYgptjgeECh0bJgLI83Kk/L8oDK07I8qPK0LI9VeVqWx6k8LcvjVZ6W5QkqT8vykMrTsjys8rQsj84atCxP0FmDpuXRWYOm5dFZg6bl0VmDpuVxKk/D6z1BZw2almeJWQMxmXAT7Iw8X51wUsL/X8IXGNnH5PsmxYcZwtG53BM6poF1CTxzBi9moCUfwEvb4CU3zCA03GNUMHaB0rUigzyly5NM03miMWl7FBp0Z+QJbecJualAsDK6GAnbBh+tkzGyPS0SWE4qgTN+nKn9Mpm6PyhTb3On4Yc4qu9Sr6QckxL+JFLyP8SAl3P6LVJSjklZouIy4npSaIYU5zKFLv6cJsVSxm4ZhtXzAby0DZ4lVSJWjsCzWTN4WDN4XDN4u2bwbs3g/ZrBhzWDpzWDb7yHPQ1+6R42zM0Ig3GmnyCC0+A95NAewY3Ai1kzeFgzeFwzeNs2eHQhgw9hDN6tGbxfM/iwZvDUNvhAqZPyBDM9GgWbMqXA4x5N+Mtk2njfzZAzZY/nZAqm8Z6+LlVJUx5EAEepNl4XLJlq41XEdKoH9I2XETPoXeOjlrzybflT6Hf0rQ/VT6MvVxIknJ1w7jlJIS6DflgHhP4UobwdLAbJc89uMAp8f6xSvJqaQ1Tsxl0MnFSws08OIE6z8zxYJ+6eIXA4Q7H7dJayzlbCzBkAJeRbEoXOzRpMY5jiwdXj/vZ2//P7p1eOmO4XFNuQ2INBbqXspzXOgkQmnZsG2xTfl0PB/9rw4fzweTmP3HiBHmiB8JhrovFmlIl3viwWXs4Pn+8+EhqFn3j/yGLh4ezwnLcxsRtfORPvwqgLnx8C+Hkd+NvkGyWqwucGg4/JcQuGl9FtFQ/gRNMAea9c/JP/2x0DLq+EQphZM2fjU9PHhj6vhcYD7EzLuywkD8uEj/qK8h6E0y6h3oXqXbjeRapdyiuZp12g3gXrXWy9S736XK8+16vP9epzvfpcr77Uqy/16pdnlCXvr5DB9orkYutdXL2Lr3cJ9S5U78KVLm/x8O/Lx/3l1e2uK+K6b1/urlNNFw+f/3lI36Sq7+Hx/np38/K46+q/QenXXRRIW4t9k3/4yG+tyU1tJ1DALeGh3o4HcSJnGwdvEUqE8y8=",
       "brillig_names": [
         "decompose_hint",
         "lte_hint",
         "debug_log_oracle_wrapper",
-        "build_msg_block",
-        "attach_len_to_msg_block",
-        "emit_encrypted_event_log_oracle_wrapper",
         "directive_integer_quotient",
-        "directive_invert",
-        "directive_to_radix"
+        "directive_invert"
       ],
-      "verification_key": "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",
-      "artifact_hash": "74acc0382b362be946a173c5740463f2803bc3a9-05152910ff6aab0585f576effcbf3428-mega-honk-true"
+      "verification_key": "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",
+      "artifact_hash": "ff6671ddb572df3d961df43ed4c3adf75a7d3763-9c72798556c70ede200529a4ac20eb09-client-ivc-true"
+    },
+    {
+      "name": "compute_note_hash_and_optionally_a_nullifier",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "16541607464495309456": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 16
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [
+          {
+            "name": "contract_address",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "nonce",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "storage_slot",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "note_type_id",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "compute_nullifier",
+            "type": {
+              "kind": "boolean"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "serialized_note",
+            "type": {
+              "kind": "array",
+              "length": 0,
+              "type": {
+                "kind": "field"
+              }
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": {
+          "abi_type": {
+            "kind": "array",
+            "length": 4,
+            "type": {
+              "kind": "field"
+            }
+          },
+          "visibility": "public"
+        }
+      },
+      "bytecode": "H4sIAAAAAAAA/9VZ227aQBBdsI2xiQmFP4jUt1ayCdc3pF7yHSiBL+gH+KEv7VeXFTv2YTypkJipykjRGs/6zNkz4931pufONjz99cJ1HNqB6xr12YW2vM0qRazSkmfvTnj274RndCc8Y0WePYGnb+l9S9z5nUvd+X3sOPFhn+gI/O5vQCzo79Bmoe2DXzExVSYMVgt/Uy5eM3dpyvyfs4CZ2uAvCX9og18S7y91i49jobhRaF/qVssXeMZbEa6xiAmXfH3wfWW+CHzfmA9r+DvzYd0TJ9JtAGNRrKuNdV5obCmMrfdO61yrHd4jrXNnWqMV5TxjfDh/4lNQn7rlM2C+GHwZ8yXgI/19+wT9eO5T6PcZ7vOajFy3hslPOUetLWoqNsA/2ULSneckri9jow91j0HPJ6aPxVqB+ljo7/WZvcOfrr2ltWssYnqiRqTZEPszXwa+uL6Mk4ffMcRBLOKRsP6fwu/H0A7gGXp+IsQfsPgXvIV7qBHHioR71N+/kx/D9cid6+cn9XfdeUpvU71aSHO2Hv66wc9s+B8JP7fBXxH+yAa/2cs8mODPS8IvbPhvCX9sUz/NXvLRhv+B8Ccm+IsDrbsfXGvN/BCup3Bfb+6uqmv2RBg/Z1yt9kRTxofrg+uv980ErhPBx3M4E+LMhDgSVqaI9aCI9fifjnGoiDVSxBorYmnmMVXE0tQrV8QqFLE0615TL8qjtE/ztgtteaNJ+zRF/Erap2l+u5PWVF+xoCGOL2H9fzCdRyY8qzmtOfSuUwyMXRjFvna9pviFwId454LvlkPZw3Jz3G6W29OWrFrNt00+C8aV38NvIpyPsb+09kv7PkWtS+m7fwy6eovBVzBfAj7iKH33j434X6M/xp8IPr7+X5vLqeuuhyM2bjzj2qmMuT3/k87mjeev5bXvJsXPXXe+/lfni6gP30vnAteJ4OP7k1yIkwtx7hGLn9Gjhr6uSae4bv1auVxv2n9w0VyUuMtzf8fiJ6z/r/Abx0btLXP+cb2vjs/74365f3tbvO6nDN9bH3T6A/vRhmkVHwAA",
+      "debug_symbols": "tdfBioMwEAbgd8k5h0wSG+OrLEuJGksgRIm6sIjvvrF029Iey38RJoxfRPITZmO9b9fLOaRhnFnztbE4dm4JYyrVtnPW5hBjuJyfl5k4HlZd++fJpaOcF5cX1ijJmU89a7Qobw8h+rJW652/dZr/TmPunZXcvzmzGiZXMPkEkw1MrmGyRckkBI4mHC1xtMLRGkdXOPqEow2OrnE0Lo2ESyPh0ki4NBIujYRLI+HSSB+m0apbZ/m1b7YB2jXQtjhbCqBNQFsCbQW0NdCugDYwlxKYSwnMpUTlci/Vj8vBtdHfBqthTd3TnLX8Tv5l5Jry2Pl+zf4Yvh5z13GWleZaX6/2UlD5QFKmbFI2+gM=",
+      "brillig_names": [
+        "compute_note_hash_and_optionally_a_nullifier"
+      ]
     },
     {
       "name": "sync_notes",
@@ -1930,7 +1878,7 @@
         "return_type": null
       },
       "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
-      "debug_symbols": "ndLNCoQgEAfwd5lzh9S0j1eJJawsBNEwW1iid1+LdmmXLnoZmMHfzMH/Cr1ol7GRejAzVPUKynTcSaN9t24JtFYqJcfmOoZ0Lwgd7+eJ672dHbcOKoITELqHKku9HqQSfpbT7ZEAwqGAhIIsFNBAgG8vlBQXJykppV+EMDoQjUEsBuUxqIhA5Pb3S4byD2KE/aLNt09uJW+VONM1LLq7hM29JvGXu8maTvSLFXsCL+Hztfa3MPZr/eo3",
+      "debug_symbols": "ndJLCoMwEAbgu8zahXmp8SpSJGqUQEgkxkIR794ottjiJm4GZsg3Wcy/QCebeaiV6e0EZbWAtq3wyprQLWsCjVNaq6E+jyHdCkL7+2kUZmsnL5yHkuAEpOmgpGnQvdIyzAq6PhJAOBaQWEBjAYsE+PIHTnh2EE4x+SKOdsNumOyGyW+YIt6Qy8NzWrCPYSn9MWvonsIp0Wh55KqfTXuKmX+N8i9xo7Ot7GYnt+ydYhdqhfIE47A2rH4D",
       "brillig_names": [
         "sync_notes"
       ]
@@ -2391,63 +2339,51 @@
     },
     "26": {
       "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        if message_size == N {\n            Poseidon2::hash_internal(input, N, false)\n        } else {\n            Poseidon2::hash_internal(input, message_size, true)\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"
-    },
-    "27": {
-      "path": "std/hash/sha256.nr",
-      "source": "use crate::runtime::is_unconstrained;\n\n// Implementation of SHA-256 mapping a byte array of variable length to\n// 32 bytes.\n\n// A message block is up to 64 bytes taken from the input.\nglobal BLOCK_SIZE: u32 = 64;\n\n// The first index in the block where the 8 byte message size will be written.\nglobal MSG_SIZE_PTR: u32 = 56;\n\n// Size of the message block when packed as 4-byte integer array.\nglobal INT_BLOCK_SIZE: u32 = 16;\n\n// A `u32` integer consists of 4 bytes.\nglobal INT_SIZE: u32 = 4;\n\n// Index of the integer in the `INT_BLOCK` where the length is written.\nglobal INT_SIZE_PTR: u32 = MSG_SIZE_PTR / INT_SIZE;\n\n// Magic numbers for bit shifting.\n// Works with actual bit shifting as well as the compiler turns them into * and /\n// but circuit execution appears to be 10% faster this way.\nglobal TWO_POW_8: u32 = 256;\nglobal TWO_POW_16: u32 = TWO_POW_8 * 256;\nglobal TWO_POW_24: u32 = TWO_POW_16 * 256;\nglobal TWO_POW_32: u64 = TWO_POW_24 as u64 * 256;\n\n// Index of a byte in a 64 byte block; ie. 0..=63\ntype BLOCK_BYTE_PTR = u32;\n\n// The foreign function to compress blocks works on 16 pieces of 4-byte integers, instead of 64 bytes.\ntype INT_BLOCK = [u32; INT_BLOCK_SIZE];\n\n// A message block is a slice of the original message of a fixed size,\n// potentially padded with zeros, with neighbouring 4 bytes packed into integers.\ntype MSG_BLOCK = INT_BLOCK;\n\n// The hash is 32 bytes.\ntype HASH = [u8; 32];\n\n// The state accumulates the blocks.\n// Its overall size is the same as the `HASH`.\ntype STATE = [u32; 8];\n\n// Deprecated in favour of `sha256_var`\n// docs:start:sha256\npub fn sha256<let N: u32>(input: [u8; N]) -> HASH\n// docs:end:sha256\n{\n    digest(input)\n}\n\n#[foreign(sha256_compression)]\npub fn sha256_compression(_input: INT_BLOCK, _state: STATE) -> STATE {}\n\n// SHA-256 hash function\n#[no_predicates]\npub fn digest<let N: u32>(msg: [u8; N]) -> HASH {\n    sha256_var(msg, N as u64)\n}\n\n// Variable size SHA-256 hash\npub fn sha256_var<let N: u32>(msg: [u8; N], message_size: u64) -> HASH {\n    let message_size = message_size as u32;\n    let num_blocks = N / BLOCK_SIZE;\n    let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n    // Intermediate hash, starting with the canonical initial value\n    let mut h: STATE = [\n        1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635,\n        1541459225,\n    ];\n    // Pointer into msg_block on a 64 byte scale\n    let mut msg_byte_ptr = 0;\n    for i in 0..num_blocks {\n        let msg_start = BLOCK_SIZE * i;\n        let (new_msg_block, new_msg_byte_ptr) =\n            unsafe { build_msg_block(msg, message_size, msg_start) };\n\n        if msg_start < message_size {\n            msg_block = new_msg_block;\n        }\n\n        if !is_unconstrained() {\n            // Verify the block we are compressing was appropriately constructed\n            let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n            if msg_start < message_size {\n                msg_byte_ptr = new_msg_byte_ptr;\n            }\n        } else if msg_start < message_size {\n            msg_byte_ptr = new_msg_byte_ptr;\n        }\n\n        // If the block is filled, compress it.\n        // An un-filled block is handled after this loop.\n        if (msg_start < message_size) & (msg_byte_ptr == BLOCK_SIZE) {\n            h = sha256_compression(msg_block, h);\n        }\n    }\n\n    let modulo = N % BLOCK_SIZE;\n    // Handle setup of the final msg block.\n    // This case is only hit if the msg is less than the block size,\n    // or our message cannot be evenly split into blocks.\n    if modulo != 0 {\n        let msg_start = BLOCK_SIZE * num_blocks;\n        let (new_msg_block, new_msg_byte_ptr) =\n            unsafe { build_msg_block(msg, message_size, msg_start) };\n\n        if msg_start < message_size {\n            msg_block = new_msg_block;\n        }\n\n        if !is_unconstrained() {\n            let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n            if msg_start < message_size {\n                msg_byte_ptr = new_msg_byte_ptr;\n                verify_msg_block_padding(msg_block, msg_byte_ptr);\n            }\n        } else if msg_start < message_size {\n            msg_byte_ptr = new_msg_byte_ptr;\n        }\n    }\n\n    // If we had modulo == 0 then it means the last block was full,\n    // and we can reset the pointer to zero to overwrite it.\n    if msg_byte_ptr == BLOCK_SIZE {\n        msg_byte_ptr = 0;\n    }\n\n    // Pad the rest such that we have a [u32; 2] block at the end representing the length\n    // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n    // Here we rely on the fact that everything beyond the available input is set to 0.\n    msg_block = update_block_item(\n        msg_block,\n        msg_byte_ptr,\n        |msg_item| set_item_byte_then_zeros(msg_item, msg_byte_ptr, 1 << 7),\n    );\n    msg_byte_ptr = msg_byte_ptr + 1;\n    let last_block = msg_block;\n\n    // If we don't have room to write the size, compress the block and reset it.\n    if msg_byte_ptr > MSG_SIZE_PTR {\n        h = sha256_compression(msg_block, h);\n        // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n        msg_byte_ptr = 0;\n    }\n\n    msg_block = unsafe { attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size) };\n\n    if !is_unconstrained() {\n        verify_msg_len(msg_block, last_block, msg_byte_ptr, message_size);\n    }\n\n    hash_final_block(msg_block, h)\n}\n\n// Take `BLOCK_SIZE` number of bytes from `msg` starting at `msg_start`.\n// Returns the block and the length that has been copied rather than padded with zeros.\nunconstrained fn build_msg_block<let N: u32>(\n    msg: [u8; N],\n    message_size: u32,\n    msg_start: u32,\n) -> (MSG_BLOCK, BLOCK_BYTE_PTR) {\n    let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n\n    // We insert `BLOCK_SIZE` bytes (or up to the end of the message)\n    let block_input = if msg_start + BLOCK_SIZE > message_size {\n        if message_size < msg_start {\n            // This function is sometimes called with `msg_start` past the end of the message.\n            // In this case we return an empty block and zero pointer to signal that the result should be ignored.\n            0\n        } else {\n            message_size - msg_start\n        }\n    } else {\n        BLOCK_SIZE\n    };\n\n    // Figure out the number of items in the int array that we have to pack.\n    // e.g. if the input is [0,1,2,3,4,5] then we need to pack it as 2 items: [0123, 4500]\n    let mut int_input = block_input / INT_SIZE;\n    if block_input % INT_SIZE != 0 {\n        int_input = int_input + 1;\n    };\n\n    for i in 0..int_input {\n        let mut msg_item: u32 = 0;\n        // Always construct the integer as 4 bytes, even if it means going beyond the input.\n        for j in 0..INT_SIZE {\n            let k = i * INT_SIZE + j;\n            let msg_byte = if k < block_input {\n                msg[msg_start + k]\n            } else {\n                0\n            };\n            msg_item = lshift8(msg_item, 1) + msg_byte as u32;\n        }\n        msg_block[i] = msg_item;\n    }\n\n    // Returning the index as if it was a 64 byte array.\n    // We have to project it down to 16 items and bit shifting to get a byte back if we need it.\n    (msg_block, block_input)\n}\n\n// Verify the block we are compressing was appropriately constructed by `build_msg_block`\n// and matches the input data. Returns the index of the first unset item.\n// If `message_size` is less than `msg_start` then this is called with the old non-empty block;\n// in that case we can skip verification, ie. no need to check that everything is zero.\nfn verify_msg_block<let N: u32>(\n    msg: [u8; N],\n    message_size: u32,\n    msg_block: MSG_BLOCK,\n    msg_start: u32,\n) -> BLOCK_BYTE_PTR {\n    let mut msg_byte_ptr = 0;\n    let mut msg_end = msg_start + BLOCK_SIZE;\n    if msg_end > N {\n        msg_end = N;\n    }\n    // We might have to go beyond the input to pad the fields.\n    if msg_end % INT_SIZE != 0 {\n        msg_end = msg_end + INT_SIZE - msg_end % INT_SIZE;\n    }\n\n    // Reconstructed packed item.\n    let mut msg_item: u32 = 0;\n\n    // Inclusive at the end so that we can compare the last item.\n    let mut i: u32 = 0;\n    for k in msg_start..=msg_end {\n        if k % INT_SIZE == 0 {\n            // If we consumed some input we can compare against the block.\n            if (msg_start < message_size) & (k > msg_start) {\n                assert_eq(msg_block[i], msg_item as u32);\n                i = i + 1;\n                msg_item = 0;\n            }\n        }\n        // Shift the accumulator\n        msg_item = lshift8(msg_item, 1);\n        // If we have input to consume, add it at the rightmost position.\n        if k < message_size & k < msg_end {\n            msg_item = msg_item + msg[k] as u32;\n            msg_byte_ptr = msg_byte_ptr + 1;\n        }\n    }\n\n    msg_byte_ptr\n}\n\n// Verify the block we are compressing was appropriately padded with zeros by `build_msg_block`.\n// This is only relevant for the last, potentially partially filled block.\nfn verify_msg_block_padding(msg_block: MSG_BLOCK, msg_byte_ptr: BLOCK_BYTE_PTR) {\n    // Check all the way to the end of the block.\n    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_BLOCK_SIZE);\n}\n\n// Verify that a region of ints in the message block are (partially) zeroed,\n// up to an (exclusive) maximum which can either be the end of the block\n// or just where the size is to be written.\nfn verify_msg_block_zeros(\n    msg_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n    max_int_byte_ptr: u32,\n) {\n    // This variable is used to get around the compiler under-constrained check giving a warning.\n    // We want to check against a constant zero, but if it does not come from the circuit inputs\n    // or return values the compiler check will issue a warning.\n    let zero = msg_block[0] - msg_block[0];\n\n    // First integer which is supposed to be (partially) zero.\n    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n    // Check partial zeros.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        let zeros = INT_SIZE - modulo;\n        let mask = if zeros == 3 {\n            TWO_POW_24\n        } else if zeros == 2 {\n            TWO_POW_16\n        } else {\n            TWO_POW_8\n        };\n        assert_eq(msg_block[int_byte_ptr] % mask, zero);\n        int_byte_ptr = int_byte_ptr + 1;\n    }\n\n    // Check the rest of the items.\n    for i in 0..max_int_byte_ptr {\n        if i >= int_byte_ptr {\n            assert_eq(msg_block[i], zero);\n        }\n    }\n}\n\n// Verify that up to the byte pointer the two blocks are equal.\n// At the byte pointer the new block can be partially zeroed.\nfn verify_msg_block_equals_last(\n    msg_block: MSG_BLOCK,\n    last_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n) {\n    // msg_byte_ptr is the position at which they are no longer have to be the same.\n    // First integer which is supposed to be (partially) zero contains that pointer.\n    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n    // Check partial zeros.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        // Reconstruct the partially zero item from the last block.\n        let last_field = last_block[int_byte_ptr];\n        let mut msg_item: u32 = 0;\n        // Reset to where they are still equal.\n        msg_byte_ptr = msg_byte_ptr - modulo;\n        for i in 0..INT_SIZE {\n            msg_item = lshift8(msg_item, 1);\n            if i < modulo {\n                msg_item = msg_item + get_item_byte(last_field, msg_byte_ptr) as u32;\n                msg_byte_ptr = msg_byte_ptr + 1;\n            }\n        }\n        assert_eq(msg_block[int_byte_ptr], msg_item);\n    }\n\n    for i in 0..INT_SIZE_PTR {\n        if i < int_byte_ptr {\n            assert_eq(msg_block[i], last_block[i]);\n        }\n    }\n}\n\n// Apply a function on the block item which the pointer indicates.\nfn update_block_item<Env>(\n    mut msg_block: MSG_BLOCK,\n    msg_byte_ptr: BLOCK_BYTE_PTR,\n    f: fn[Env](u32) -> u32,\n) -> MSG_BLOCK {\n    let i = msg_byte_ptr / INT_SIZE;\n    msg_block[i] = f(msg_block[i]);\n    msg_block\n}\n\n// Set the rightmost `zeros` number of bytes to 0.\nfn set_item_zeros(item: u32, zeros: u8) -> u32 {\n    lshift8(rshift8(item, zeros), zeros)\n}\n\n// Replace one byte in the item with a value, and set everything after it to zero.\nfn set_item_byte_then_zeros(msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR, msg_byte: u8) -> u32 {\n    let zeros = INT_SIZE - msg_byte_ptr % INT_SIZE;\n    let zeroed_item = set_item_zeros(msg_item, zeros as u8);\n    let new_item = byte_into_item(msg_byte, msg_byte_ptr);\n    zeroed_item + new_item\n}\n\n// Get a byte of a message item according to its overall position in the `BLOCK_SIZE` space.\nfn get_item_byte(mut msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR) -> u8 {\n    // How many times do we have to shift to the right to get to the position we want?\n    let max_shifts = INT_SIZE - 1;\n    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n    msg_item = rshift8(msg_item, shifts as u8);\n    // At this point the byte we want is in the rightmost position.\n    msg_item as u8\n}\n\n// Project a byte into a position in a field based on the overall block pointer.\n// For example putting 1 into pointer 5 would be 100, because overall we would\n// have [____, 0100] with indexes [0123,4567].\nfn byte_into_item(msg_byte: u8, msg_byte_ptr: BLOCK_BYTE_PTR) -> u32 {\n    let mut msg_item = msg_byte as u32;\n    // How many times do we have to shift to the left to get to the position we want?\n    let max_shifts = INT_SIZE - 1;\n    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n    lshift8(msg_item, shifts as u8)\n}\n\n// Construct a field out of 4 bytes.\nfn make_item(b0: u8, b1: u8, b2: u8, b3: u8) -> u32 {\n    let mut item = b0 as u32;\n    item = lshift8(item, 1) + b1 as u32;\n    item = lshift8(item, 1) + b2 as u32;\n    item = lshift8(item, 1) + b3 as u32;\n    item\n}\n\n// Shift by 8 bits to the left between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise multiplies by 256.\nfn lshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        if item == 0 {\n            0\n        } else {\n            // Brillig wouldn't shift 0<<4 without overflow.\n            item << (8 * shifts)\n        }\n    } else {\n        // We can do a for loop up to INT_SIZE or an if-else.\n        if shifts == 0 {\n            item\n        } else if shifts == 1 {\n            item * TWO_POW_8\n        } else if shifts == 2 {\n            item * TWO_POW_16\n        } else if shifts == 3 {\n            item * TWO_POW_24\n        } else {\n            // Doesn't make sense, but it's most likely called on 0 anyway.\n            0\n        }\n    }\n}\n\n// Shift by 8 bits to the right between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise divides by 256.\nfn rshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        item >> (8 * shifts)\n    } else {\n        // Division wouldn't work on `Field`.\n        if shifts == 0 {\n            item\n        } else if shifts == 1 {\n            item / TWO_POW_8\n        } else if shifts == 2 {\n            item / TWO_POW_16\n        } else if shifts == 3 {\n            item / TWO_POW_24\n        } else {\n            0\n        }\n    }\n}\n\n// Zero out all bytes between the end of the message and where the length is appended,\n// then write the length into the last 8 bytes of the block.\nunconstrained fn attach_len_to_msg_block(\n    mut msg_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n    message_size: u32,\n) -> MSG_BLOCK {\n    // We assume that `msg_byte_ptr` is less than 57 because if not then it is reset to zero before calling this function.\n    // In any case, fill blocks up with zeros until the last 64 bits (i.e. until msg_byte_ptr = 56).\n    // There can be one item which has to be partially zeroed.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        // Index of the block in which we find the item we need to partially zero.\n        let i = msg_byte_ptr / INT_SIZE;\n        let zeros = INT_SIZE - modulo;\n        msg_block[i] = set_item_zeros(msg_block[i], zeros as u8);\n        msg_byte_ptr = msg_byte_ptr + zeros;\n    }\n\n    // The rest can be zeroed without bit shifting anything.\n    for i in (msg_byte_ptr / INT_SIZE)..INT_SIZE_PTR {\n        msg_block[i] = 0;\n    }\n\n    // Set the last two 4 byte ints as the first/second half of the 8 bytes of the length.\n    let len = 8 * message_size;\n    let len_bytes: [u8; 8] = (len as Field).to_be_bytes();\n    for i in 0..=1 {\n        let shift = i * 4;\n        msg_block[INT_SIZE_PTR + i] = make_item(\n            len_bytes[shift],\n            len_bytes[shift + 1],\n            len_bytes[shift + 2],\n            len_bytes[shift + 3],\n        );\n    }\n    msg_block\n}\n\n// Verify that the message length was correctly written by `attach_len_to_msg_block`,\n// and that everything between the byte pointer and the size pointer was zeroed,\n// and that everything before the byte pointer was untouched.\nfn verify_msg_len(\n    msg_block: MSG_BLOCK,\n    last_block: MSG_BLOCK,\n    msg_byte_ptr: BLOCK_BYTE_PTR,\n    message_size: u32,\n) {\n    // Check zeros up to the size pointer.\n    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_SIZE_PTR);\n\n    // Check that up to the pointer we match the last block.\n    verify_msg_block_equals_last(msg_block, last_block, msg_byte_ptr);\n\n    // We verify the message length was inserted correctly by reversing the byte decomposition.\n    let mut reconstructed_len: u64 = 0;\n    for i in INT_SIZE_PTR..INT_BLOCK_SIZE {\n        reconstructed_len = reconstructed_len * TWO_POW_32;\n        reconstructed_len = reconstructed_len + msg_block[i] as u64;\n    }\n    let len = 8 * message_size as u64;\n    assert_eq(reconstructed_len, len);\n}\n\n// Perform the final compression, then transform the `STATE` into `HASH`.\nfn hash_final_block(msg_block: MSG_BLOCK, mut state: STATE) -> HASH {\n    let mut out_h: HASH = [0; 32]; // Digest as sequence of bytes\n    // Hash final padded block\n    state = sha256_compression(msg_block, state);\n\n    // Return final hash as byte array\n    for j in 0..8 {\n        let h_bytes: [u8; 4] = (state[j] as Field).to_be_bytes();\n        for k in 0..4 {\n            out_h[4 * j + k] = h_bytes[k];\n        }\n    }\n\n    out_h\n}\n\nmod tests {\n    use super::{\n        attach_len_to_msg_block, build_msg_block, byte_into_item, get_item_byte, make_item,\n        set_item_byte_then_zeros, set_item_zeros,\n    };\n    use super::INT_BLOCK;\n    use super::sha256_var;\n\n    #[test]\n    fn smoke_test() {\n        let input = [0xbd];\n        let result = [\n            0x68, 0x32, 0x57, 0x20, 0xaa, 0xbd, 0x7c, 0x82, 0xf3, 0x0f, 0x55, 0x4b, 0x31, 0x3d,\n            0x05, 0x70, 0xc9, 0x5a, 0xcc, 0xbb, 0x7d, 0xc4, 0xb5, 0xaa, 0xe1, 0x12, 0x04, 0xc0,\n            0x8f, 0xfe, 0x73, 0x2b,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_just_over_block() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116,\n        ];\n        let result = [\n            91, 122, 146, 93, 52, 109, 133, 148, 171, 61, 156, 70, 189, 238, 153, 7, 222, 184, 94,\n            24, 65, 114, 192, 244, 207, 199, 87, 232, 192, 224, 171, 207,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_multiple_over_block() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116, 61, 117, 115, 45, 97, 115,\n            99, 105, 105, 13, 10, 109, 105, 109, 101, 45, 118, 101, 114, 115, 105, 111, 110, 58, 49,\n            46, 48, 32, 40, 77, 97, 99, 32, 79, 83, 32, 88, 32, 77, 97, 105, 108, 32, 49, 54, 46,\n            48, 32, 92, 40, 51, 55, 51, 49, 46, 53, 48, 48, 46, 50, 51, 49, 92, 41, 41, 13, 10, 115,\n            117, 98, 106, 101, 99, 116, 58, 72, 101, 108, 108, 111, 13, 10, 109, 101, 115, 115, 97,\n            103, 101, 45, 105, 100, 58, 60, 56, 70, 56, 49, 57, 68, 51, 50, 45, 66, 54, 65, 67, 45,\n            52, 56, 57, 68, 45, 57, 55, 55, 70, 45, 52, 51, 56, 66, 66, 67, 52, 67, 65, 66, 50, 55,\n            64, 109, 101, 46, 99, 111, 109, 62, 13, 10, 100, 97, 116, 101, 58, 83, 97, 116, 44, 32,\n            50, 54, 32, 65, 117, 103, 32, 50, 48, 50, 51, 32, 49, 50, 58, 50, 53, 58, 50, 50, 32,\n            43, 48, 52, 48, 48, 13, 10, 116, 111, 58, 122, 107, 101, 119, 116, 101, 115, 116, 64,\n            103, 109, 97, 105, 108, 46, 99, 111, 109, 13, 10, 100, 107, 105, 109, 45, 115, 105, 103,\n            110, 97, 116, 117, 114, 101, 58, 118, 61, 49, 59, 32, 97, 61, 114, 115, 97, 45, 115,\n            104, 97, 50, 53, 54, 59, 32, 99, 61, 114, 101, 108, 97, 120, 101, 100, 47, 114, 101,\n            108, 97, 120, 101, 100, 59, 32, 100, 61, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109,\n            59, 32, 115, 61, 49, 97, 49, 104, 97, 105, 59, 32, 116, 61, 49, 54, 57, 51, 48, 51, 56,\n            51, 51, 55, 59, 32, 98, 104, 61, 55, 120, 81, 77, 68, 117, 111, 86, 86, 85, 52, 109, 48,\n            87, 48, 87, 82, 86, 83, 114, 86, 88, 77, 101, 71, 83, 73, 65, 83, 115, 110, 117, 99, 75,\n            57, 100, 74, 115, 114, 99, 43, 118, 85, 61, 59, 32, 104, 61, 102, 114, 111, 109, 58, 67,\n            111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58, 77, 105, 109, 101, 45, 86, 101,\n            114, 115, 105, 111, 110, 58, 83, 117, 98, 106, 101, 99,\n        ];\n        let result = [\n            116, 90, 151, 31, 78, 22, 138, 180, 211, 189, 69, 76, 227, 200, 155, 29, 59, 123, 154,\n            60, 47, 153, 203, 129, 157, 251, 48, 2, 79, 11, 65, 47,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_just_under_block() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59,\n        ];\n        let result = [\n            143, 140, 76, 173, 222, 123, 102, 68, 70, 149, 207, 43, 39, 61, 34, 79, 216, 252, 213,\n            165, 74, 16, 110, 74, 29, 64, 138, 167, 30, 1, 9, 119,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_big_not_block_multiple() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116, 61, 117, 115, 45, 97, 115,\n            99, 105, 105, 13, 10, 109, 105, 109, 101, 45, 118, 101, 114, 115, 105, 111, 110, 58, 49,\n            46, 48, 32, 40, 77, 97, 99, 32, 79, 83, 32, 88, 32, 77, 97, 105, 108, 32, 49, 54, 46,\n            48, 32, 92, 40, 51, 55, 51, 49, 46, 53, 48, 48, 46, 50, 51, 49, 92, 41, 41, 13, 10, 115,\n            117, 98, 106, 101, 99, 116, 58, 72, 101, 108, 108, 111, 13, 10, 109, 101, 115, 115, 97,\n            103, 101, 45, 105, 100, 58, 60, 56, 70, 56, 49, 57, 68, 51, 50, 45, 66, 54, 65, 67, 45,\n            52, 56, 57, 68, 45, 57, 55, 55, 70, 45, 52, 51, 56, 66, 66, 67, 52, 67, 65, 66, 50, 55,\n            64, 109, 101, 46, 99, 111, 109, 62, 13, 10, 100, 97, 116, 101, 58, 83, 97, 116, 44, 32,\n            50, 54, 32, 65, 117, 103, 32, 50, 48, 50, 51, 32, 49, 50, 58, 50, 53, 58, 50, 50, 32,\n            43, 48, 52, 48, 48, 13, 10, 116, 111, 58, 122, 107, 101, 119, 116, 101, 115, 116, 64,\n            103, 109, 97, 105, 108, 46, 99, 111, 109, 13, 10, 100, 107, 105, 109, 45, 115, 105, 103,\n            110, 97, 116, 117, 114, 101, 58, 118, 61, 49, 59, 32, 97, 61, 114, 115, 97, 45, 115,\n            104, 97, 50, 53, 54, 59, 32, 99, 61, 114, 101, 108, 97, 120, 101, 100, 47, 114, 101,\n            108, 97, 120, 101, 100, 59, 32, 100, 61, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109,\n            59, 32, 115, 61, 49, 97, 49, 104, 97, 105, 59, 32, 116, 61, 49, 54, 57, 51, 48, 51, 56,\n            51, 51, 55, 59, 32, 98, 104, 61, 55, 120, 81, 77, 68, 117, 111, 86, 86, 85, 52, 109, 48,\n            87, 48, 87, 82, 86, 83, 114, 86, 88, 77, 101, 71, 83, 73, 65, 83, 115, 110, 117, 99, 75,\n            57, 100, 74, 115, 114, 99, 43, 118, 85, 61, 59, 32, 104, 61, 102, 114, 111, 109, 58, 67,\n            111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58, 77, 105, 109, 101, 45, 86, 101,\n            114, 115, 105, 111, 110, 58, 83, 117, 98, 106, 101, 99, 116, 58, 77, 101, 115, 115, 97,\n            103, 101, 45, 73, 100, 58, 68, 97, 116, 101, 58, 116, 111, 59, 32, 98, 61,\n        ];\n        let result = [\n            112, 144, 73, 182, 208, 98, 9, 238, 54, 229, 61, 145, 222, 17, 72, 62, 148, 222, 186,\n            55, 192, 82, 220, 35, 66, 47, 193, 200, 22, 38, 26, 186,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_big_with_padding() {\n        let input = [\n            48, 130, 1, 37, 2, 1, 0, 48, 11, 6, 9, 96, 134, 72, 1, 101, 3, 4, 2, 1, 48, 130, 1, 17,\n            48, 37, 2, 1, 1, 4, 32, 176, 223, 31, 133, 108, 84, 158, 102, 70, 11, 165, 175, 196, 12,\n            201, 130, 25, 131, 46, 125, 156, 194, 28, 23, 55, 133, 157, 164, 135, 136, 220, 78, 48,\n            37, 2, 1, 2, 4, 32, 190, 82, 180, 235, 222, 33, 79, 50, 152, 136, 142, 35, 116, 224, 6,\n            242, 156, 141, 128, 248, 10, 61, 98, 86, 248, 45, 207, 210, 90, 232, 175, 38, 48, 37, 2,\n            1, 3, 4, 32, 0, 194, 104, 108, 237, 246, 97, 230, 116, 198, 69, 110, 26, 87, 17, 89,\n            110, 199, 108, 250, 36, 21, 39, 87, 110, 102, 250, 213, 174, 131, 171, 174, 48, 37, 2,\n            1, 11, 4, 32, 136, 155, 87, 144, 111, 15, 152, 127, 85, 25, 154, 81, 20, 58, 51, 75,\n            193, 116, 234, 0, 60, 30, 29, 30, 183, 141, 72, 247, 255, 203, 100, 124, 48, 37, 2, 1,\n            12, 4, 32, 41, 234, 106, 78, 31, 11, 114, 137, 237, 17, 92, 71, 134, 47, 62, 78, 189,\n            233, 201, 214, 53, 4, 47, 189, 201, 133, 6, 121, 34, 131, 64, 142, 48, 37, 2, 1, 13, 4,\n            32, 91, 222, 210, 193, 62, 222, 104, 82, 36, 41, 138, 253, 70, 15, 148, 208, 156, 45,\n            105, 171, 241, 195, 185, 43, 217, 162, 146, 201, 222, 89, 238, 38, 48, 37, 2, 1, 14, 4,\n            32, 76, 123, 216, 13, 51, 227, 72, 245, 59, 193, 238, 166, 103, 49, 23, 164, 171, 188,\n            194, 197, 156, 187, 249, 28, 198, 95, 69, 15, 182, 56, 54, 38, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n        ];\n        let result = [\n            32, 85, 108, 174, 127, 112, 178, 182, 8, 43, 134, 123, 192, 211, 131, 66, 184, 240, 212,\n            181, 240, 180, 106, 195, 24, 117, 54, 129, 19, 10, 250, 53,\n        ];\n        let message_size = 297;\n        assert_eq(sha256_var(input, message_size), result);\n    }\n\n    #[test]\n    fn msg_big_no_padding() {\n        let input = [\n            48, 130, 1, 37, 2, 1, 0, 48, 11, 6, 9, 96, 134, 72, 1, 101, 3, 4, 2, 1, 48, 130, 1, 17,\n            48, 37, 2, 1, 1, 4, 32, 176, 223, 31, 133, 108, 84, 158, 102, 70, 11, 165, 175, 196, 12,\n            201, 130, 25, 131, 46, 125, 156, 194, 28, 23, 55, 133, 157, 164, 135, 136, 220, 78, 48,\n            37, 2, 1, 2, 4, 32, 190, 82, 180, 235, 222, 33, 79, 50, 152, 136, 142, 35, 116, 224, 6,\n            242, 156, 141, 128, 248, 10, 61, 98, 86, 248, 45, 207, 210, 90, 232, 175, 38, 48, 37, 2,\n            1, 3, 4, 32, 0, 194, 104, 108, 237, 246, 97, 230, 116, 198, 69, 110, 26, 87, 17, 89,\n            110, 199, 108, 250, 36, 21, 39, 87, 110, 102, 250, 213, 174, 131, 171, 174, 48, 37, 2,\n            1, 11, 4, 32, 136, 155, 87, 144, 111, 15, 152, 127, 85, 25, 154, 81, 20, 58, 51, 75,\n            193, 116, 234, 0, 60, 30, 29, 30, 183, 141, 72, 247, 255, 203, 100, 124, 48, 37, 2, 1,\n            12, 4, 32, 41, 234, 106, 78, 31, 11, 114, 137, 237, 17, 92, 71, 134, 47, 62, 78, 189,\n            233, 201, 214, 53, 4, 47, 189, 201, 133, 6, 121, 34, 131, 64, 142, 48, 37, 2, 1, 13, 4,\n            32, 91, 222, 210, 193, 62, 222, 104, 82, 36, 41, 138, 253, 70, 15, 148, 208, 156, 45,\n            105, 171, 241, 195, 185, 43, 217, 162, 146, 201, 222, 89, 238, 38, 48, 37, 2, 1, 14, 4,\n            32, 76, 123, 216, 13, 51, 227, 72, 245, 59, 193, 238, 166, 103, 49, 23, 164, 171, 188,\n            194, 197, 156, 187, 249, 28, 198, 95, 69, 15, 182, 56, 54, 38,\n        ];\n        let result = [\n            32, 85, 108, 174, 127, 112, 178, 182, 8, 43, 134, 123, 192, 211, 131, 66, 184, 240, 212,\n            181, 240, 180, 106, 195, 24, 117, 54, 129, 19, 10, 250, 53,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn same_msg_len_variable_padding() {\n        let input = [\n            29, 81, 165, 84, 243, 114, 101, 37, 242, 146, 127, 99, 69, 145, 39, 72, 213, 39, 253,\n            179, 218, 37, 217, 201, 172, 93, 198, 50, 249, 70, 15, 30, 162, 112, 187, 40, 140, 9,\n            236, 53, 32, 44, 38, 163, 113, 254, 192, 197, 44, 89, 71, 130, 169, 242, 17, 211, 214,\n            72, 19, 178, 186, 168, 147, 127, 99, 101, 252, 227, 8, 147, 150, 85, 97, 158, 17, 107,\n            218, 244, 82, 113, 247, 91, 208, 214, 60, 244, 87, 137, 173, 201, 130, 18, 66, 56, 198,\n            149, 207, 189, 175, 120, 123, 224, 177, 167, 251, 159, 143, 110, 68, 183, 189, 70, 126,\n            32, 35, 164, 44, 30, 44, 12, 65, 18, 62, 239, 242, 2, 248, 104, 2, 178, 64, 28, 126, 36,\n            137, 24, 14, 116, 91, 98, 90, 159, 218, 102, 45, 11, 110, 223, 245, 184, 52, 99, 59,\n            245, 136, 175, 3, 72, 164, 146, 145, 116, 22, 66, 24, 49, 193, 121, 3, 60, 37, 41, 97,\n            3, 190, 66, 195, 225, 63, 46, 3, 118, 4, 208, 15, 1, 40, 254, 235, 151, 123, 70, 180,\n            170, 44, 172, 90, 4, 254, 53, 239, 116, 246, 67, 56, 129, 61, 22, 169, 213, 65, 27, 216,\n            116, 162, 239, 214, 207, 126, 177, 20, 100, 25, 48, 143, 84, 215, 70, 197, 53, 65, 70,\n            86, 172, 61, 62, 9, 212, 167, 169, 133, 41, 126, 213, 196, 33, 192, 238, 0, 63, 246,\n            215, 58, 128, 110, 101, 92, 3, 170, 214, 130, 149, 52, 81, 125, 118, 233, 3, 118, 193,\n            104, 207, 120, 115, 77, 253, 191, 122, 0, 107, 164, 207, 113, 81, 169, 36, 201, 228, 74,\n            134, 131, 218, 178, 35, 30, 216, 101, 2, 103, 174, 87, 95, 50, 50, 215, 157, 5, 210,\n            188, 54, 211, 78, 45, 199, 96, 121, 241, 241, 176, 226, 194, 134, 130, 89, 217, 210,\n            186, 32, 140, 39, 91, 103, 212, 26, 87, 32, 72, 144, 228, 230, 117, 99, 188, 50, 15, 69,\n            79, 179, 50, 12, 106, 86, 218, 101, 73, 142, 243, 29, 250, 122, 228, 233, 29, 255, 22,\n            121, 114, 125, 103, 41, 250, 241, 179, 126, 158, 198, 116, 209, 65, 94, 98, 228, 175,\n            169, 96, 3, 9, 233, 133, 214, 55, 161, 164, 103, 80, 85, 24, 186, 64, 167, 92, 131, 53,\n            101, 202, 47, 25, 104, 118, 155, 14, 12, 12, 25, 116, 45, 221, 249, 28, 246, 212, 200,\n            157, 167, 169, 56, 197, 181, 4, 245, 146, 1, 140, 234, 191, 212, 228, 125, 87, 81, 86,\n            119, 30, 63, 129, 143, 32, 96,\n        ];\n\n        // Prepare inputs of different lengths\n        let mut input_511 = [0; 511];\n        let mut input_512 = [0; 512]; // Next block\n        let mut input_575 = [0; 575];\n        let mut input_576 = [0; 576]; // Next block\n        for i in 0..input.len() {\n            input_511[i] = input[i];\n            input_512[i] = input[i];\n            input_575[i] = input[i];\n            input_576[i] = input[i];\n        }\n\n        // Compute hashes of all inputs (with same message length)\n        let fixed_length_hash = super::sha256(input);\n        let var_full_length_hash = sha256_var(input, input.len() as u64);\n        let var_length_hash_511 = sha256_var(input_511, input.len() as u64);\n        let var_length_hash_512 = sha256_var(input_512, input.len() as u64);\n        let var_length_hash_575 = sha256_var(input_575, input.len() as u64);\n        let var_length_hash_576 = sha256_var(input_576, input.len() as u64);\n\n        // All of the above should have produced the same hash\n        assert_eq(var_full_length_hash, fixed_length_hash);\n        assert_eq(var_length_hash_511, fixed_length_hash);\n        assert_eq(var_length_hash_512, fixed_length_hash);\n        assert_eq(var_length_hash_575, fixed_length_hash);\n        assert_eq(var_length_hash_576, fixed_length_hash);\n    }\n\n    #[test]\n    fn test_get_item_byte() {\n        let fld = make_item(10, 20, 30, 40);\n        assert_eq(fld, 0x0a141e28);\n        assert_eq(get_item_byte(fld, 0), 10);\n        assert_eq(get_item_byte(fld, 4), 10);\n        assert_eq(get_item_byte(fld, 6), 30);\n    }\n\n    #[test]\n    fn test_byte_into_item() {\n        let fld = make_item(0, 20, 0, 0);\n        assert_eq(byte_into_item(20, 1), fld);\n        assert_eq(byte_into_item(20, 5), fld);\n    }\n\n    #[test]\n    fn test_set_item_zeros() {\n        let fld0 = make_item(10, 20, 30, 40);\n        let fld1 = make_item(10, 0, 0, 0);\n        assert_eq(set_item_zeros(fld0, 3), fld1);\n        assert_eq(set_item_zeros(fld0, 4), 0);\n        assert_eq(set_item_zeros(0, 4), 0);\n    }\n\n    #[test]\n    fn test_set_item_byte_then_zeros() {\n        let fld0 = make_item(10, 20, 30, 40);\n        let fld1 = make_item(10, 50, 0, 0);\n        assert_eq(set_item_byte_then_zeros(fld0, 1, 50), fld1);\n    }\n\n    #[test]\n    fn test_build_msg_block_start_0() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48,\n        ];\n        assert_eq(input.len(), 22);\n        let (msg_block, msg_byte_ptr) = unsafe { build_msg_block(input, input.len(), 0) };\n        assert_eq(msg_byte_ptr, input.len());\n        assert_eq(msg_block[0], make_item(input[0], input[1], input[2], input[3]));\n        assert_eq(msg_block[1], make_item(input[4], input[5], input[6], input[7]));\n        assert_eq(msg_block[5], make_item(input[20], input[21], 0, 0));\n        assert_eq(msg_block[6], 0);\n    }\n\n    #[test]\n    fn test_build_msg_block_start_1() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116,\n        ];\n        assert_eq(input.len(), 68);\n        let (msg_block, msg_byte_ptr) = unsafe { build_msg_block(input, input.len(), 64) };\n        assert_eq(msg_byte_ptr, 4);\n        assert_eq(msg_block[0], make_item(input[64], input[65], input[66], input[67]));\n        assert_eq(msg_block[1], 0);\n    }\n\n    #[test]\n    fn test_attach_len_to_msg_block() {\n        let input: INT_BLOCK = [\n            2152555847, 1397309779, 1936618851, 1262052426, 1936876331, 1985297723, 543702374,\n            1919905082, 1131376244, 1701737517, 1417244773, 978151789, 1697470053, 1920166255,\n            1849316213, 1651139939,\n        ];\n        let msg_block = unsafe { attach_len_to_msg_block(input, 1, 448) };\n        assert_eq(msg_block[0], ((1 << 7) as u32) * 256 * 256 * 256);\n        assert_eq(msg_block[1], 0);\n        assert_eq(msg_block[15], 3584);\n    }\n}\n"
+      "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"
     },
-    "51": {
+    "52": {
       "path": "std/panic.nr",
       "source": "pub fn panic<T, U, let N: u32>(message: fmtstr<N, T>) -> U {\n    assert(false, message);\n    crate::mem::zeroed()\n}\n"
     },
-    "102": {
+    "66": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
-      "source": "use crate::{\n    context::{inputs::PrivateContextInputs, packed_returns::PackedReturns},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        arguments,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        header::get_header_at,\n        key_validation_request::get_key_validation_request,\n        logs::{emit_encrypted_event_log, emit_encrypted_note_log},\n        returns::pack_returns,\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log_hash::{EncryptedLogHash, LogHash, NoteLogHash},\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENCRYPTED_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_ENCRYPTED_LOGS_PER_CALL, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,\n        MAX_NOTE_HASHES_PER_CALL, MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, PUBLIC_DISPATCH_SELECTOR,\n    },\n    header::Header,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: Header,\n\n    pub note_encrypted_logs_hashes: BoundedVec<NoteLogHash, MAX_NOTE_ENCRYPTED_LOGS_PER_CALL>,\n    pub encrypted_logs_hashes: BoundedVec<EncryptedLogHash, MAX_ENCRYPTED_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            note_encrypted_logs_hashes: BoundedVec::new(),\n            encrypted_logs_hashes: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: self.next_counter(),\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_header(self) -> Header {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_header_at(self, block_number: u32) -> Header {\n        get_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        pack_returns(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            note_encrypted_logs_hashes: self.note_encrypted_logs_hashes.storage(),\n            encrypted_logs_hashes: self.encrypted_logs_hashes.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert(request.pk_m.hash() == pk_m_hash);\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    // NB: A randomness value of 0 signals that the kernels should not mask the contract address\n    // used in siloing later on e.g. 'handshaking' contract w/ known address.\n    pub fn emit_raw_event_log_with_masked_address<let M: u32>(\n        &mut self,\n        randomness: Field,\n        log: [u8; M],\n        log_hash: Field,\n    ) {\n        let counter = self.next_counter();\n        let contract_address = self.this_address();\n        let len = log.len() as Field + 4;\n        let side_effect = EncryptedLogHash { value: log_hash, counter, length: len, randomness };\n        self.encrypted_logs_hashes.push(side_effect);\n\n        emit_encrypted_event_log(contract_address, randomness, log, counter);\n    }\n\n    pub fn emit_raw_note_log<let M: u32>(\n        &mut self,\n        note_hash_counter: u32,\n        log: [u8; M],\n        log_hash: Field,\n    ) {\n        let counter = self.next_counter();\n        let len = log.len() as Field + 4;\n        let side_effect = NoteLogHash { value: log_hash, counter, length: len, note_hash_counter };\n        self.note_encrypted_logs_hashes.push(side_effect);\n\n        emit_encrypted_note_log(note_hash_counter, log, counter);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> PackedReturns {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // The oracle simulates the private call and returns the value of the side effects counter after execution of\n        // the call (which means that end_side_effect_counter - start_side_effect_counter is the number of side effects\n        // that took place), along with the hash of the return values. We validate these by requesting a private kernel\n        // iteration in which the return values are constrained to hash to `returns_hash` and the side effects counter\n        // to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        PackedReturns::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = enqueue_public_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.set_public_teardown_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = set_public_teardown_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: Header::empty(),\n            note_encrypted_logs_hashes: BoundedVec::new(),\n            encrypted_logs_hashes: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
+      "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, packed_returns::PackedReturns},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        arguments,\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        key_validation_request::get_key_validation_request,\n        returns::pack_returns,\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: self.next_counter(),\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        pack_returns(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert(request.pk_m.hash() == pk_m_hash);\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> PackedReturns {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // The oracle simulates the private call and returns the value of the side effects counter after execution of\n        // the call (which means that end_side_effect_counter - start_side_effect_counter is the number of side effects\n        // that took place), along with the hash of the return values. We validate these by requesting a private kernel\n        // iteration in which the return values are constrained to hash to `returns_hash` and the side effects counter\n        // to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        PackedReturns::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = enqueue_public_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.set_public_teardown_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = set_public_teardown_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
     },
-    "121": {
+    "91": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
-      "source": "use crate::note::{note_header::NoteHeader, note_interface::NoteInterface};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n    utils::arr_copy_slice,\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let header = NoteHeader { contract_address, nonce, storage_slot, note_hash_counter };\n            let serialized_note = arr_copy_slice(fields, [0; N], read_offset + 2);\n            let mut note = Note::deserialize_content(serialized_note);\n            note.set_header(header);\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_app_tagging_secret_as_sender`, except it returns the derived tag as an array of bytes, ready to be included in a\n/// log.\npub unconstrained fn get_app_tag_bytes_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> [u8; 32] {\n    let tag = get_app_tagging_secret_as_sender(sender, recipient).compute_tag(recipient);\n    tag.to_be_bytes()\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivpsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_app_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_app_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getAppTaggingSecretAsSender)]\nunconstrained fn get_app_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
+      "source": "use crate::{note::{note_header::NoteHeader, note_interface::NoteInterface}, utils::array};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let note_content = array::subarray(fields, read_offset + 2);\n\n            let mut note = Note::deserialize_content(note_content);\n            note.set_header(NoteHeader { contract_address, nonce, storage_slot, note_hash_counter });\n\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_app_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_app_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivpsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_app_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_app_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getAppTaggingSecretAsSender)]\nunconstrained fn get_app_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
     },
-    "128": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/logs.nr",
-      "source": "use dep::protocol_types::address::AztecAddress;\n\n/// Informs the simulator that an encrypted note log has been emitted, helping it keep track of side-effects and easing\n/// debugging.\npub fn emit_encrypted_note_log<let M: u32>(\n    note_hash_counter: u32,\n    encrypted_note: [u8; M],\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        emit_encrypted_note_log_oracle_wrapper(note_hash_counter, encrypted_note, counter)\n    }\n}\n\n/// Informs the simulator that an encrypted event log has been emitted, helping it keep track of side-effects and easing\n/// debugging.\npub fn emit_encrypted_event_log<let M: u32>(\n    contract_address: AztecAddress,\n    randomness: Field,\n    encrypted_event: [u8; M],\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        emit_encrypted_event_log_oracle_wrapper(\n            contract_address,\n            randomness,\n            encrypted_event,\n            counter,\n        )\n    }\n}\n\nunconstrained fn emit_encrypted_note_log_oracle_wrapper<let M: u32>(\n    note_hash_counter: u32,\n    encrypted_note: [u8; M],\n    counter: u32,\n) {\n    emit_encrypted_note_log_oracle(note_hash_counter, encrypted_note, counter)\n}\n\nunconstrained fn emit_encrypted_event_log_oracle_wrapper<let M: u32>(\n    contract_address: AztecAddress,\n    randomness: Field,\n    encrypted_event: [u8; M],\n    counter: u32,\n) {\n    emit_encrypted_event_log_oracle(contract_address, randomness, encrypted_event, counter)\n}\n\n/// Temporary substitute that is used for handling contract class registration. This\n/// variant returns the log hash, which would be too large to compute inside a circuit.\npub unconstrained fn emit_contract_class_unencrypted_log_private<let N: u32>(\n    contract_address: AztecAddress,\n    message: [Field; N],\n    counter: u32,\n) -> Field {\n    emit_contract_class_unencrypted_log_private_oracle(contract_address, message, counter)\n}\n\n// = 480 + 32 * N bytes\n#[oracle(emitEncryptedNoteLog)]\nunconstrained fn emit_encrypted_note_log_oracle<let M: u32>(\n    _note_hash_counter: u32,\n    _encrypted_note: [u8; M],\n    _counter: u32,\n) {}\n\n#[oracle(emitEncryptedEventLog)]\nunconstrained fn emit_encrypted_event_log_oracle<let M: u32>(\n    _contract_address: AztecAddress,\n    _randomness: Field,\n    _encrypted_event: [u8; M],\n    _counter: u32,\n) {}\n\n#[oracle(emitContractClassLog)]\nunconstrained fn emit_contract_class_unencrypted_log_private_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    message: [Field; N],\n    counter: u32,\n) -> Field {}\n"
-    },
-    "151": {
+    "175": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/hash.nr",
       "source": "use crate::utils::to_bytes::{arr_to_be_bytes_arr, str_to_be_bytes_arr};\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::Hash,\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_unencrypted_log_hash<let N: u32>(\n    contract_address: AztecAddress,\n    log: [u8; N],\n) -> Field {\n    let mut hash_bytes = [0; N + 36];\n    // Address is converted to 32 bytes in ts\n    let address_bytes: [u8; 32] = contract_address.to_field().to_be_bytes();\n    for i in 0..32 {\n        hash_bytes[i] = address_bytes[i];\n    }\n    let len_bytes: [u8; 4] = (N as Field).to_be_bytes();\n    for i in 0..4 {\n        hash_bytes[32 + i] = len_bytes[i];\n    }\n    for i in 0..N {\n        hash_bytes[36 + i] = log[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_array() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = [\n        0x20660de09f35f876e3e69d227b2a35166ad05f09d82d06366ec9b6f65a51fec2,\n        0x1b52bfe3b8689761916f76dc3d38aa8810860db325cd39ca611eed980091f01c,\n        0x2e559c4045c378a56ad13b9edb1e8de4e7ad3b3aa35cc7ba9ec77f7a68fa43a4,\n        0x25d0f689c4a4178a29d59306f2675824d19be6d25e44fa03b03f49c263053dd2,\n        0x2d513a722d6f352dc0961f156afdc5e31495b9f0e35cb069261a8e55e2df67fd,\n    ];\n    let serialized_log = arr_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0095b2d17ab72f4b27a341f7ac63e49ec73935ae8c9181a0ac02023eb12f3284);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_addr() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = AztecAddress::from_field(\n        0x26aa302d4715fd8a687453cb26d616b0768027bd54bcae56b09d908ecd9f8303,\n    );\n    let serialized_log: [u8; 32] = log.to_field().to_be_bytes();\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0083ab647dfb26e7ddee90a0f4209d049d4660cab42000c544b986aaa84c55a3);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"dummy\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x00629e88ebd6374f44aa6cfe07e251ecf07213ebc7267e8f6b578ae57ffd6c20);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_longer_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"Hello this is a string\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0098637962f7d34fa202b7ffad8a07a238c5d1fd897b82a108f7f467fa73b841);\n}\n"
     },
-    "165": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/utils/to_bytes.nr",
-      "source": "pub fn arr_to_be_bytes_arr<let L: u32>(fields: [Field; L]) -> [u8; L * 32] {\n    let mut bytes = [0 as u8; L * 32];\n    for i in 0..L {\n        // Note that bytes.append() results in bound error\n        let to_add: [u8; 32] = fields[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[i * 32 + j] = to_add[j];\n        }\n    }\n    bytes\n}\n\n// each character of a string is converted into a byte\n// then an ACVM field via the oracle => we recreate here\npub fn str_to_be_bytes_arr<let L: u32>(string: str<L>) -> [u8; L * 32] {\n    let chars_bytes: [u8; L] = string.as_bytes();\n    let mut bytes = [0 as u8; L * 32];\n    for i in 0..L {\n        let to_add: [u8; 32] = (chars_bytes[i] as Field).to_be_bytes();\n        for j in 0..32 {\n            bytes[i * 32 + j] = to_add[j];\n        }\n    }\n    bytes\n}\n"
-    },
-    "192": {
-      "path": "/usr/src/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"
-    },
-    "200": {
-      "path": "/usr/src/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"
+    "176": {
+      "path": "/usr/src/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"
     },
-    "202": {
+    "177": {
       "path": "/usr/src/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"
     },
-    "203": {
+    "181": {
       "path": "/usr/src/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"
     },
-    "204": {
-      "path": "/usr/src/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    utils,\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    pub fn conditional_assign(predicate: bool, lhs: Self, rhs: Self) -> Self {\n        let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n        Self { inner: result }\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"
+    "309": {
+      "path": "/usr/src/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"
+    },
+    "310": {
+      "path": "/usr/src/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"
     },
-    "229": {
+    "311": {
       "path": "/usr/src/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, ScopedEncryptedLogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\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::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, note_hash: Field) -> Field {\n    let inputs = [nonce, note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, unique_note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), unique_note_hash],\n        GENERATOR_INDEX__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, tx_hash: Field, note_index_in_tx: u32) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n        let unique_note_hash = compute_unique_note_hash(nonce, note_hash.value());\n        compute_siloed_note_hash(note_hash.contract_address, unique_note_hash)\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 silo_encrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    // We assume contract address has already been masked\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        accumulate_sha256(\n            [log_hash.contract_address.to_field(), log_hash.log_hash.value],\n        )\n    }\n}\n\npub fn mask_encrypted_log_hash(scoped_log: ScopedEncryptedLogHash) -> AztecAddress {\n    if scoped_log.contract_address.is_zero() {\n        AztecAddress::from_field(0)\n    } else if (scoped_log.log_hash.randomness == 0) {\n        scoped_log.contract_address\n    } else {\n        AztecAddress::from_field(poseidon2_hash_with_separator(\n            [scoped_log.contract_address.to_field(), scoped_log.log_hash.randomness],\n            0,\n        ))\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    // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of N + 1\n    let in_len = N + 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\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    // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of Math.ceil(N/31)\n    let mut in_len = N / 31;\n    let mut has_padding = false;\n    if N % 31 != 0 {\n        in_len += 1;\n        has_padding = true;\n    }\n\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\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            sponge.absorb(field_from_bytes(current_field, false));\n            current_field = [0; 31];\n        }\n    }\n    if has_padding {\n        sponge.absorb(field_from_bytes(current_field, false));\n    }\n\n    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"
+      "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\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 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"
     },
-    "375": {
+    "384": {
       "path": "/usr/src/noir-projects/noir-contracts/contracts/contract_instance_deployer_contract/src/main.nr",
-      "source": "use dep::aztec::macros::aztec;\n\n#[aztec]\ncontract ContractInstanceDeployer {\n    use dep::aztec::{\n        macros::{events::event, functions::private},\n        utils::to_bytes::arr_to_be_bytes_arr,\n    };\n    use dep::aztec::protocol_types::{\n        address::{AztecAddress, PartialAddress, PublicKeysHash},\n        constants::DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE,\n        contract_class_id::ContractClassId,\n        hash::sha256_to_field,\n        public_keys::PublicKeys,\n        traits::Serialize,\n    };\n    use std::meta::derive;\n\n    #[event]\n    #[derive(Serialize)]\n    struct ContractInstanceDeployed {\n        DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE: Field,\n        address: AztecAddress,\n        version: u8,\n        salt: Field,\n        contract_class_id: ContractClassId,\n        initialization_hash: Field,\n        public_keys: PublicKeys,\n        deployer: AztecAddress,\n    }\n\n    // We need to impl this separately because ts deserializes a point as two fields only.\n    // We had issues that:\n    // Notice how the 'is_infinite' field is deserialized as the next point.\n    // {\n    //     masterNullifierPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000012>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000000034>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // },\n    // masterIncomingViewingPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000000>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000000056>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // },\n    // masterOutgoingViewingPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000078>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000000000>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // },\n    // masterTaggingPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000910>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000001112>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // }\n    impl Serialize<15> for ContractInstanceDeployed {\n        fn serialize(self) -> [Field; 15] {\n            [\n                self.DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE,\n                self.address.to_field(),\n                self.version.to_field(),\n                self.salt,\n                self.contract_class_id.to_field(),\n                self.initialization_hash,\n                self.public_keys.npk_m.serialize()[0],\n                self.public_keys.npk_m.serialize()[1],\n                self.public_keys.ivpk_m.serialize()[0],\n                self.public_keys.ivpk_m.serialize()[1],\n                self.public_keys.ovpk_m.serialize()[0],\n                self.public_keys.ovpk_m.serialize()[1],\n                self.public_keys.tpk_m.serialize()[0],\n                self.public_keys.tpk_m.serialize()[1],\n                self.deployer.to_field(),\n            ]\n        }\n    }\n\n    #[private]\n    fn deploy(\n        salt: Field,\n        contract_class_id: ContractClassId,\n        initialization_hash: Field,\n        public_keys: PublicKeys,\n        universal_deploy: bool,\n    ) {\n        // TODO(@spalladino): assert nullifier_exists silo(contract_class_id, ContractClassRegisterer)\n        let deployer = if universal_deploy {\n            AztecAddress::zero()\n        } else {\n            context.msg_sender()\n        };\n\n        let partial_address =\n            PartialAddress::compute(contract_class_id, salt, initialization_hash, deployer);\n\n        let address = AztecAddress::compute(public_keys, partial_address);\n\n        // Emit the address as a nullifier to be able to prove that this instance has been (not) deployed\n        context.push_nullifier(address.to_field());\n\n        // Broadcast the event\n        let event = ContractInstanceDeployed {\n            DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE,\n            contract_class_id,\n            address,\n            public_keys,\n            initialization_hash,\n            salt,\n            deployer,\n            version: 1,\n        };\n\n        let payload = event.serialize();\n        dep::aztec::oracle::debug_log::debug_log_format(\"ContractInstanceDeployed: {}\", payload);\n\n        // @todo This is very inefficient, we are doing a lot of back and forth conversions.\n        let serialized_log = arr_to_be_bytes_arr(payload);\n        let log_hash = sha256_to_field(serialized_log);\n\n        // Note: we are cheating a bit here because this is actually not encrypted\n        // but needs to be emitted from private, where we have removed unencrypted_logs,\n        // and has 15 fields (the max enc log len is 8).\n        // TODO(Miranda): split into 2 logs\n        context.emit_raw_event_log_with_masked_address(0, serialized_log, log_hash);\n    }\n}\n"
+      "source": "use dep::aztec::macros::aztec;\n\n#[aztec]\ncontract ContractInstanceDeployer {\n    use dep::aztec::macros::{events::event, functions::private};\n    use dep::aztec::protocol_types::{\n        address::{AztecAddress, PartialAddress},\n        constants::DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE,\n        contract_class_id::ContractClassId,\n        public_keys::PublicKeys,\n        traits::Serialize,\n        utils::arrays::array_concat,\n    };\n    use std::meta::derive;\n\n    #[derive(Serialize)]\n    #[event]\n    struct ContractInstanceDeployed {\n        DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE: Field,\n        address: AztecAddress,\n        version: u8,\n        salt: Field,\n        contract_class_id: ContractClassId,\n        initialization_hash: Field,\n        public_keys: PublicKeys,\n        deployer: AztecAddress,\n    }\n\n    // We need to impl this separately because ts deserializes a point as two fields only.\n    // We had issues that:\n    // Notice how the 'is_infinite' field is deserialized as the next point.\n    // {\n    //     masterNullifierPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000012>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000000034>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // },\n    // masterIncomingViewingPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000000>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000000056>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // },\n    // masterOutgoingViewingPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000078>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000000000>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // },\n    // masterTaggingPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000910>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000001112>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // }\n\n    impl Serialize<15> for ContractInstanceDeployed {\n        fn serialize(self) -> [Field; 15] {\n            [\n                self.DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE,\n                self.address.to_field(),\n                self.version.to_field(),\n                self.salt,\n                self.contract_class_id.to_field(),\n                self.initialization_hash,\n                self.public_keys.npk_m.serialize()[0],\n                self.public_keys.npk_m.serialize()[1],\n                self.public_keys.ivpk_m.serialize()[0],\n                self.public_keys.ivpk_m.serialize()[1],\n                self.public_keys.ovpk_m.serialize()[0],\n                self.public_keys.ovpk_m.serialize()[1],\n                self.public_keys.tpk_m.serialize()[0],\n                self.public_keys.tpk_m.serialize()[1],\n                self.deployer.to_field(),\n            ]\n        }\n    }\n\n    #[private]\n    fn deploy(\n        salt: Field,\n        contract_class_id: ContractClassId,\n        initialization_hash: Field,\n        public_keys: PublicKeys,\n        universal_deploy: bool,\n    ) {\n        // TODO(@spalladino): assert nullifier_exists silo(contract_class_id, ContractClassRegisterer)\n        let deployer = if universal_deploy {\n            AztecAddress::zero()\n        } else {\n            context.msg_sender()\n        };\n\n        let partial_address =\n            PartialAddress::compute(contract_class_id, salt, initialization_hash, deployer);\n\n        let address = AztecAddress::compute(public_keys, partial_address);\n\n        // Emit the address as a nullifier to be able to prove that this instance has been (not) deployed\n        context.push_nullifier(address.to_field());\n\n        // Broadcast the event\n        let event = ContractInstanceDeployed {\n            DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE,\n            contract_class_id,\n            address,\n            public_keys,\n            initialization_hash,\n            salt,\n            deployer,\n            version: 1,\n        };\n\n        let payload = event.serialize();\n        dep::aztec::oracle::debug_log::debug_log_format(\"ContractInstanceDeployed: {}\", payload);\n\n        let padded_log = array_concat(payload, [0; 3]);\n        context.emit_private_log(padded_log);\n    }\n}\n"
     }
   }
 }