@aztec/protocol-contracts 0.85.0 → 0.86.0

package/artifacts/ContractInstanceDeployer.json

@@ -43,8 +43,8 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "get_update_delay"
       ]
@@ -118,34 +118,12 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "public_dispatch"
       ]
     },
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "aztec::macros::functions::utility"
-      ],
-      "abi": {
-        "parameters": [],
-        "return_type": null,
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        }
-      },
-      "bytecode": "H4sIAAAAAAAA/7WTPQ+CMBCGi2KUjzjgoD+jBAyM+LG4OLpXCkpUSAB3frqQXENtwKjAJU17FJ5736OVUB0SzDLqEAyyglmBecTtj8vhQY67hakIdfvku9i2lQZ/Peq3FGBKw/Ax4w/UfzwFzr6o+bwXVndWDo1b66g+H0P5Z/9vSP+LD5418GpAXnmew/oS5Nt74t+Oz8c5SNnXTR1EgnIxdK5CSd0lcZ4SP99QmgZZJhJGDWTUQlU56pVE8YG26fmRdgrSLEpikSZ/Sav6yu6lXLyr8eA57hCOizHTMAb+BDV3X+b2+feXkKuCJ+bT+1Nn6BAztEhI1oRS2yeGwK+CP38vlizs4eEFAAA=",
-      "debug_symbols": "rZLLqoMwEIbfZdYucr/4KuVQosYSCFGiHijiuzeWWKSWduNmyISP4Uvmn6Gx1XS7utB2A5SXGXxXm9F1IXXzUkAVnffudt1fA1oLpk9+6E1Y22E0cYQSI4ZVATY0z7OUaUbrvIVS86U44FKJDCvEXqggH1BOeEY5Ry8UU7n8FYDZCTKKyk2G6+8yjOqMMqEOMvwMGcU2Ga2+ywi0/Ywg4iAjTpDRhGRYU/5DRqGMSvS2piW1/yY6U3mb49VOod6lbbz39i14fexq20zRrhHcpS/VS3oCoWlsGv0A",
-      "brillig_names": [
-        "sync_notes"
-      ]
-    },
     {
       "name": "update",
       "is_unconstrained": true,
@@ -207,12 +185,34 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "7V3bbt22Ev0XP/uBMySHnPxKcRAkaVoYMJIiSQ9wUOTfj/ZORMnmSOxmKJsi+VLENZdn1uJtOLzon7vfP77/+8+3D5/++Pz17s1v/9w9fv7w7tvD50/TT/98v797/+Xh8fHhz7fr/32nLv8BtlfA17/efbr8/PXbuy/f7t4459393cdPv9+98QBu+hN/PDx+vHvD9vt/7icQ3w5CZTJAoHJAWZZyOKHNAeVY0jmcdI4loyWQNVb9BFlDPoCs+n4fFTZem5+FjTcYCpNU2FuHszvWu3XhqztedGdyYnbHEiXcIYLZHXIq5Y6ywR2E5+5YWR2rILiDdt8dsG7WH0jrfXfY8vyXmbR57g5B0h3itTtXEGeAnNgALVk9g8i5lyPuMeWOM+o5B1Y5ILGPW28CyHOKuKK5MAAsxMEaUaa5aaNa+o4GEso6NnNrdczLX0bHQmnt5j5sVoqi5DIizH8YcVVXeBVlcmaIEomCMESJRRndRxCFhyiRKHKI07soo6XEomyEqJ2L4oYokSh2TMmCKGNKFkQZA20sCo2BVhDFD1EiURwOUWJRxio5FsWPKVkQZUzJgihjSo5FYTNEiUUZU3IkilFjShZEGavkWBQYU7IgypiSY1FQDVFiUcaULIgypuRYFD3yKYIofU7JGmaXUSM9F8X0GbwlROkzn7Iviu1zSk6I0ueUnBClzyl5XxQaA60gymgpsSiuz+AtIcpoKbEofowpgigjzI9F4T4zbwlR+sy8JUTpczNsVxSrxpQsiDIG2liUTrc4EqKMfEosSqe3OBKi9DklOzOXRWfNc1F0n5m3hChmiBKL0ucqeV+UTrc4EqL0OSXvi9LpFkdClDElx6LQaCmCKGNKFkQpMCWD97MoaGxCFGt59oc8Lv6wl/4021kVYLdoCHR9pMOWuFnwet57c2bvGU/tfTI7xBb3vUfrZu+RlHpiIi5tCHjus2RMorSbPJmHA1KLMuIbIQ7Dyx3TP8268ESVFPRDlbqhCv3UKvRTq9hPraZzac1Q1f3Uqu6nr6YTN+1Q7Sdasrofqv3UKvXTV11TtepVoOqfv0JJ6fuuJ6KqKSSAtHtO1anaG7BbqKLap6rBz4kxjbjkCPSUy7pyrT2GKMi1+mVcSa61R/y3cMWQjNIazBOuUt7Yhbyx8sujslpMdPngtV9ld+WyBCEnpulJ2YviWHsw057itc++zSmuW5oZz6H4aOMvrLhpKUo4h+I8FH9ZxatPvByoePgwwyS+ipXpeLzdV6b6tM7rKTPazIYybrSZLWVGm9lQxnccfyWU6Tins68Mq6HMhjJmKLOhTMerjl1lvKppdXB1qKbJ8uIQ1BTXXB16+W2csHI1TvlEaSA9f3BvKrBa54K+uv8KR7GKum/P7T6f2n19bvWNOrf7J1f/3G3/FRJ5t7kfvvsKDnzsvj+1+6+QEivqfu1Bw777rvaBM+F+7QPnvvv+3Oqn74PV7X7lA6ezHNz35on7QmkIjzUDrL6GjE6JC2MK62L7pOxFGK58THstYVhV3l+nTNVM1a/SHS8gTO1d6bWEgcqjG69VEMbQ8yGSwZ3afTy3+gefzbuYOPim19UEHW7i4OX/1YQ53gQfbuLgpe7VxPGN9uAl49VEgUZLGoIJqxNjgbU4zyPWWkiUvvGmhg/3bwzifmEA7Wg1+/G6+EWZEscRblQm3KmxhKktH4RAFoHjMbXEmYFXdN9Xrv7k//y30drY/crVR3DBfYoyhcy2bve1Cn9bAzx3H1SJ9cur+n9y/aF2/TF88EnHifLJ/9r1RxP8dzr2v8T1oiP9N2reqEADkv/+3P7rk+uva9cfw/RlrI/9N7XrH2JgNE4YPy1U7j+H6McqQX9L5/afTq4/Va6/xTD+rNeAwX9Xuf4Ww9+2ZAX/uXL/WS9JARP7X2LD61X9P7n+XLn+tKx+yQjjD1euPy3LX6J4/AFV+fJ92fCdVu8u9h8qz54k/T+5/li5/onxB7Dy+CGlv648fkj6f3L9Te3x8/76F0zl+Z9E/A+28vxb0v+T608l9PchR+kgtR9PKpSmKfoKpcWtL+/17L739vnG1+S9Lew9P/H+asOpF7DxAjxKnGx0hoMNl2qp02ZZ+GyAUquxa9rBvHg0tftf94iXvsM2Zo3kj7fhXoBHievDSRsF5nKm0EJ4Nd/KLcSb8GEJb57sboDYnlTYBmcDT0pf/Wc4uf+VH51+rUOeoKs/5fl6yow2s6EMjDazpcxoMxvKoKpoBvnhkanOI1+bRwWeb9QqPJ2slbOpNYwNf3pKyqZaP4eDgcyr9Rqj5IfX4f1bHx93mri6drgyzn9ZT6FpzNU0VK9Jrh3Va4EzA+fhajviyv1wTX8JsiGuHdVrgVzOebg2NOf4kP2cuMbnXLRvM0ZkTQLXlmIJu7RhL9QrtxQjeg5chb1KzS3V6z5Xo/qpV1PgYzWn4VogK3cerqYjri3FiAmu2FG9Fsj2nYZrS3nEydM5464UCFxbiv1DPDxxxZhrQ3lEo5YHUxUpgWs79ToRNIGrE+rVtlSvKa4d1Su1kx9Oc20nP5zm2k6MmOTqTEdcO6pX305+OM21pTkn3AObuMY5U9NSHnEdDzthndNQHtGo8IygAYzzw7ahPOJEMMT+0+aNwLWhek1xhY7qFdrJDye5Yjv54TRX0xHXhmLEFFfdUb3qdvLDSa5N5RHDveppmwoFrm3mh6fEd8y1pTwihDt3BpUSuDYUI6IKsT+C0IapoXpNcu2oXl1D+eEk14byw0muDcWIKa4F3q06D9eO6pUbyg8nubaUbwp3DieucexPLZ1HXMXDGH+EaeLaUL0aF87BGB/fpyNoKJZIcm0oj5jiih3VK3ZUr7qjetUNxf5Jrg3FiCmuBT5cdB6uDeWHU1xtQ7F/kutZY8Sr96c9YfjD+7PO91fvXd07vKB0+DClspToJ47N7IljXvYW0LHktwvJeb0ogxJFxPCsDaLW68JXFbnuFnwWFevuSedQ0anRo0uoaIaKBVSsex1xEhUrv7l6FhXrXvucREWsO/N+FhVHpFNART0inRIqjtmlhIpjdimgoqk7Z3cWFevOBp5ExcrfxTyLiiPSKaAijUinhIpmqFhAxZHTKaBi5S+bnkXFEekUULHy11jPouKIdAqoyCPSKaFi3WfVzqLiiHR+XUWvRqRTQsWRXyygIo62+K9UtIuKRJGKlZ+YrUVFFz6Uhc6aWMUxuxRQsfJTvmdRcayjC6hY+Tnms6g41i4lVByzSwEVK3839iwqjrZYQMXK37o9i4o1RTpXj6q6O/LDo5oy2ReP+OXvNBBC8Mgkv4mswhe1p0TN0ppJdETbuYVO/+QnHeUHWdMTWe6ILPRUs9BTzWJPNfvyX6F6RbIv/xmq1yTrOiJroCey1BFZ21O4+PLftH9Fsq72mg2PuXll/T5Z55Y1sDO0LnzlevDC8IcN+wI2xECQNM5VTXr1DrRow/tZVgbYV3Vavtq58GUpu6wmka+vpaCSF1i5DqF6VnOTAT7YABzNAI5mIO/ElzTgDzagj2agj2Ygv6Bf0oA72IB8R6ekATrYAB3NQN5OK2jAHc3AHV0HXh1t4Og68EcP13z0hMMHD3ag9NEGCgx2YZ+DMREps/Nz1MUeKPIGsCpvqtIGoSpvqCZvdFXa6Nozjbcs9zzNH7103vmI68vffT+Sq9W7XJuqV68C19XjnDNX21S9Jrh2VK9U+8bATVw1B66sEhmWqfvObgNYjIdtaqoZbEpz5erHccV/cyxHo/tZFqfM7rrwVcVx7a+IiqMtllBxHFf8VyqCDiri80tCOCX/hooFVBzX/gqoWPnnyc+i4njgoICKlX9S/SwqjtmlhIpjdimgoh4XM0qoONpiARXNiHQKqGh/fQWI1s3ZfiSV0sUQhA+ekjGJ0s6Gb/o4UjaRv8IljYn+yeGpK1fSDXE1MKcBnUGBq2+Iq2ba4+paqlft9cIVvyfS09qFA4BgFMfStNS9dRitnXZxMyiQnj4NV8aOuLpuuGrV1FCW4NrUFLXPFTqqV+iovxb42vdZuJqNdJ6Zd5is8c+XF2YjebWP4dsxOsOOzrBjMuxsnADaxdgMOzaDz8YLRLsYl9EO3EZCfV7DWI8RxqsMjM3AyCeKw/OKFL2uiIZ1BsbfjLFKZ2Ay7ECGnY2TrrsYzLCDGXzk8SCBub0dWGNvx8hXNvcxcl8AFV6AAbU6txVQJgsl6g1gQz4LXNSLrPySSgJFymShOAclt3GAcNQdUEVqkNySwIRTWLBepgeUz0HJKc0kinJQcitMorJ4UZaH8m2bqZJDLdtVlBJQLge10VNSKM5ByUeXEqiNbx0nUXm2NnjxHNXC1JkiFLgclPyVzRRKqyyUzUJlqSGfcU+isjSUr+6B1gGlbdS/nHwfL4myWSjOQcmJ3STK5aB8lho+S3nOssVZynOO8hsv2SdRG8qH2yCgfTTa+I15OYGSV6NJlM1BachCUQ5KXmEmUTnzsreYhcqZzT1l2ZL78v7Lh+g3+jKFZAg4FdvamM0TKDk7nUCxwiyUrLzjeekN65tlMwogC2WzUJyDkleFSZTLQeksNXSW8ibLlslS3mQpb7OUt1nKU5YalKUGZanhZFu8zHpsYpT8Wu0+SquNXjm1zwW13O7RFn7COAsm52GTMPlFuDTMJWGru0gBZmwWzOosGEEeTBwJLg8fzDOSYhvD5Oe1kzD5e3VpmNuAwQKjGMaYB8uyBgpkmMMAc16A2SwYqDxYnjXMs4aZ1jgLJg/jUxw0D5LTPxcY+B8oud8kUZSDcmKD9IzhUuM0W65RwvaaD7tal8AwNuEON+GPZyGvQ4uakBetZU0czgIVHG/ieBZwPAs5Yihrgg83IWf8ipowx9cFbYxR4Rjw9E+MUPJeKKtwcJSfnHn+iZKvJ6ds8UZr8WF4X59qDije8NAED1E9R01xYhYqy5ac006h5Jx2EpVlS9sclFEbKFxQEKNsDspm2bImidIxL7tRyzq8vaNM1A41mWRPWR+1mVEbtoxf+lfsoduo5XB8QuqV2mNGX9be5aDkiT6B2thrdhRO5NPzPJ0mOZRnmhfO7CjG8O0YOcOcwLjbMfJpsP399gllc1BaZaGybJksWybLls2yZbNsUVZ9UZYtl8VLThskUT4HJY8xSRTloOQxZn+0kPe/GMPQbiLMxq75bi92ci/et4MZvsnh7z5GvoCZwNw+kjn5JEoCk2FHftWWwz2uJ3fhZgzdjqEMO5SanQSMy2hv8tnIfYzXGRh/O0aO6xOY22dor0wG5nY+HjADc3v9bOxOb2O+Tz/9992Xh3fvHz9+nRCXX/796cO3h8+ffv747X9/zb95/+Xh8fHhz7d/ffn84ePvf3/5+Pbx84fL7+7Uz//8RsT3xGry5dLwndX3zsHlp8svDZl7Q3z58cdv1b2zOPkw+fF/",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "update"
       ]
     },
+    {
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "aztec::macros::functions::utility"
+      ],
+      "abi": {
+        "parameters": [],
+        "return_type": null,
+        "error_types": {
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        }
+      },
+      "bytecode": "H4sIAAAAAAAA/7WTPQ+CMBCGi2KUjzjgoD+jBAyM+LG4OLpXCkpUSAB3frqQXENtwKjAJU17FJ5736OVUB0SzDLqEAyyglmBecTtj8vhQY67hakIdfvku9i2lQZ/Peq3FGBKw/Ax4w/UfzwFzr6o+bwXVndWDo1b66g+H0P5Z/9vSP+LD5418GpAXnmew/oS5Nt74t+Oz8c5SNnXTR1EgnIxdK5CSd0lcZ4SP99QmgZZJhJGDWTUQlU56pVE8YG26fmRdgrSLEpikSZ/Sav6yu6lXLyr8eA57hCOizHTMAb+BDV3X+b2+feXkKuCJ+bT+1Nn6BAztEhI1oRS2yeGwK+CP38vlizs4eEFAAA=",
+      "debug_symbols": "rZJLioQwFEX38sYZ5P9xK0VTRI1FIESJ2tCIe+9YxELKpnri5JEXDpdDchdoXT0/7j52/QjVbYHQN3byfczbsiKokw/BP+7Ha8DbIOzJj4ON2zpONk1QEcwJQ+Bi+zwrmjM6HxxURqzohCstC6wxf6GS/oEKKgoqBH6hhKn1CwHhF8hopnYZYT7LcGYKyqU+yYgrZDTfZYz+LCPx/jKSypOMvEDGUFpgw8Q/MhoXVOG3b1rz+m2Tt3VwpV7dHJtD26afwb0Vb0h949o5ua2Ch/bleSMaUZZjc/Qv",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
     {
       "name": "set_update_delay",
       "is_unconstrained": true,
@@ -267,8 +267,8 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "JwACBAEoAAABBIBMJwAABAMnAgIEAScCAwQAHxgAAwACgEsdAIBLgEsELgiASwABJQAAAEwlAAAAhSgCAAEEgEwnAgIEADsNAAEAAigAgEMEABkoAIBEBAADKACARQEAACgAgEYEAAAoAIBHAQABKACASAQAASgAgEkAAAEoAIBKBAAEJiUAAAjeHgIAAwEeAgAEADM4AAMABAAFJAIABQAAAKklAAAJBw0oAAGAQwAECygABIBFAAUkAgAFAAAAxiUAAAkZJwIEAAAtCAEFJwIGBAQAEAEGAScDBQQBACgFAgYtDAYHLQ4EBwAoBwIHLQ4EBwAoBwIHLQ4EBysCAAYAAAAAAAAAAAIAAAAAAAAAAC0IAQcnAggEBQAQAQgBJwMHBAEAKAcCCC0MCAktDgQJACgJAgktDgQJACgJAgktDgQJACgJAgktDgYJLQgBBgAAAQIBLQ4FBi0IAQUAAAECAS0OBwUtCAEHAAABAgEuCoBGAActCAEIAAABAgEuCoBFAAgnAgkECi0IAAotDAYLLQwFDC0MBw0tDAgOLgiASQAPABAACQAlAAAJKy0EAAAnAgkECi0IAAotDAYLLQwFDC0MBw0tDAgOLQwDDwAQAAkAJQAACSstBAAAJwIJBAotCAAKLQwGCy0MBQwtDAcNLQwIDgAQAAkAJQAAClQtBAAALQwLAwo4AwQFCygABYBFAAYkAgAGAAACIiUAAArILwwAAwAFHAwFBwQcDAcGAAI4BQYHLAIABQAtXgmLgro3tDuZoTFhGP0g1C9RZsnp8T+16mWpbR4KbQQ4BwUGHAwGCAQcDAgHABwMBwgEAjgGBwkEOAkFBhwMBgkBHAwJBwAcDAcJAQI4BgcKLAIABgAwM+okblBuiY6X9XDK/9cEywu0YDE/tyCynhOeXBAAAQQ4CgYLHAwLDAQcDAwKABwMCgwEAjgLCg0EOA0FChwMCgsBHAwLBQAcDAULAQI4CgUNBDgNBgocDAoNBBwMDQYAHAwGCgQWDAsGHAwFDQQcDAYOBAQ4DQoGFgwJChwMBw0EHAwKDwQEOA0MCi0IAQwAAAECAS0OCwwtCAELAAABAgEtDgYLLQgBDQAAAQIBLQ4JDS0IAQkAAAECAS0OCgktCAEQAAABAgEtDggQHgIAEQUcDBETBBwMExIAHAwSEQQMOBEIEigCAAgEDhAkAgASAAADqiMAAAONHAwHBQQEOAUKBgQ4DwgFADgGBQctDAcCIwAAA8ccDAUHBAQ4BwYFBDgOCAYAOAUGBy0MBwIjAAADxww4AgEGJAIABgAAA/kjAAAD2QI4AgEGDjgBAgckAgAHAAAD8CUAAAraLQwGBSMAAAQELgiARgAFIwAABAQAOBEFBw44EQcIJAIACAAABBslAAAK7C4KgEcADC0OAgsuCoBHAA0tDgEJLQ4HEC0IAQEnAgIEBAAQAQIBJwMBBAEAKAECAi0MAgUtDgQFACgFAgUtDgQFACgFAgUtDgQFLQgBAgAAAQIBLQ4BAi4IgEYABiMAAAR9DSgABoBEAAEkAgABAAAIjyMAAASSLQ0CBQEoAAWASAAGLQ0GAicCBgQCADgFBggtDQgHASgABYBEAAotDQoILQgBBScCCgQEABABCgEnAwUEAQAoBQIKLQwKDi0OAg4AKA4CDi0OBw4AKA4CDi0OCA4tDQUHACgHAgctDgcFJwIIBBEtCAARLQwFEi4IgEgAEwAQAAgAJQAACv4tBAAALQwSBy0NBQgAKAgCCC0OCAUnAgoEES0IABEtDAUSLQwGEwAQAAoAJQAACv4tBAAALQwSCAEoAAeASAAGLQ0GBQEoAAiASAAHLQ0HBhwMAggEHAwIBwAtDQwCLQ0LCC0NDQotDQkLLQ0QCRwMCQwAJwIJAAInAg0AICcCDwQQLQgAEC0MCREtDA0SABAADwAlAAALfi0EAAAtDBEOBDgMDg0AOAcNDBwMCgcAJwIKAEAnAg4EDy0IAA8tDAkQLQwKEQAQAA4AJQAAC34tBAAALQwQDQQ4Bw0KADgMCgccDAsKACcCCwBIJwINBA4tCAAOLQwJDy0MCxAAEAANACUAAAt+LQQAAC0MDwwEOAoMCwA4BwsKHAwCBwAnAgIAaCcCDAQNLQgADS0MCQ4tDAIPABAADAAlAAALfi0EAAAtDA4LBDgHCwIAOAoCBxwMCAIAJwIIAHAnAgsEDC0IAAwtDAkNLQwIDgAQAAsAJQAAC34tBAAALQwNCgQ4AgoIADgHCAItCAEHJwIIBAQAEAEIAScDBwQBACgHAggtDAgJLQ4ECQAoCQIJLQ4ECQAoCQIJLQ4ECSsCAAgAAAAAAAAAAAMAAAAAAAAAAC0IAQknAgoEBQAQAQoBJwMJBAEAKAkCCi0MCgstDgQLACgLAgstDgQLACgLAgstDgQLACgLAgstDggLLQgBBAAAAQIBLQ4HBC0IAQcAAAECAS0OCQctCAEIAAABAgEuCoBGAAgtCAEJAAABAgEuCoBFAAknAgoECy0IAAstDAQMLQwHDS0MCA4tDAkPLQwCEAAQAAoAJQAACSstBAAAJwIKBAstCAALLQwEDC0MBw0tDAgOLQwJDy0MBRAAEAAKACUAAAkrLQQAACcCCgQLLQgACy0MBAwtDAcNLQwIDi0MCQ8tDAYQABAACgAlAAAJKy0EAAAnAgsEDC0IAAwtDAQNLQwHDi0MCA8tDAkQABAACwAlAAAKVC0EAAAtDA0KLQgBBCcCBwQFABABBwEnAwQEAQAoBAIHLQwHCC0OAggAKAgCCC0OBQgAKAgCCC0OBggAKAgCCC0OCgguCIBGAAEjAAAISg0oAAGASgACJAIAAgAACGAjAAAIXyYcDAECAAA4AwIFACgEAgYAOAYBBy0NBwIwDAACAAUBKAABgEgAAi0MAgEjAAAISi0NAgEcDAYFAAA4AwUHLwwABwAFLgQAAYADKACABAQABCUAAAx+LgiABQAHACgHAggAOAgGCi0OBQotDgcCASgABoBIAAEtDAEGIwAABH0oAIAEBHgADQAAAIAEgAMkAIADAAAJBioBAAEF96Hzr6Wt1Mo8AQECJioBAAEFiw4hFpDjtVY8AQECJioBAAEF2CGPRyp21fM8AQECJiUAAAjeLQ0DBi0NBAcLKAAHgEUACCQCAAgAAAlRJwIJBAA8CQEJCygABoBEAAckAgAHAAAJ4CMAAAlmLQ0BBi0NAgctDQMILQ0ECQ0oAAiARAAKJAIACgAACYslAAANDC4EAAaAAygAgAQEAAQlAAAMfi4IgAUACgAoCgILADgLCAwtDgUMASgACIBIAAUOOAgFBiQCAAYAAAnLJQAACuwtDgoBLQ4HAi0OBQMtDgkEIwAAClMnAgYEBy0IAActDAEILQwCCS0MAwotDAQLABAABgAlAAANHi0EAAAtDQEGLQ0CBy0NBAguBAAGgAMoAIAEBAAEJQAADH4uCIAFAAkAKAkCCgEoAAqARgALLQ4FCy0OCQEtDgcCLgqASAADLQ4IBCMAAApTJiUAAAjeLQ0EBQsoAAWARQAGJAIABgAACnYnAgcEADwJAQcnAgUEBi0IAAYtDAEHLQwCCC0MAwktDAQKABAABQAlAAANHi0EAAAtDQEFLQ0CBi0NAwctDgUBLQ4GAi0OBwMuCoBHAAQBKAAGgEgAAi0NAgEmKgEAAQUC3G4ngHYSnTwBAQImKgEAAQUohpKwR9z9QzwBAQImKgEAAQVFp8pxGUHkFTwBAQImJQAACN4BKAACgEgAAw44AgMEJAIABAAACx0lAAAK7A0wgEQAAwAECygABIBFAAMkAgADAAALOiUAAA4sDSgAAoBEAAMkAgADAAALTyUAAA0MACgBAgQAOAQCBS0NBQMtCAEBJwICBAIAEAECAScDAQQBACgBAgItDAIELQ4DBCYlAAAI3i0IAQQAAAECAS4KgEkABCcCBgQCJwIHAQEtCAEFJwIIBCEAEAEIAScDBQQBACgFAggnAgkEIEMD8AACAAYACQAHAAgnAgoEIC4EAAiAAy4EAAqABCUAAA4+JwICBCEnAgYEIC4IgEgAAyMAAAvxDDgDAgckAgAHAAAMCCMAAAwDLQ0EASYtDQQHBDgHBwgCOAYDBw44AwYJJAIACQAADCglAAAK2gw4BwYJJAIACQAADDolAAANDAAoBQIKADgKBwstDQsJHAwJBwAEOAgBCQQ4BwkKAzCASQAHAAkEOAkIBwA4CgcILQ4IBAEoAAOASAAHLQwHAyMAAAvxLgGAA4AGCwCABgACgAckAIAHAAAMmSMAAAykLgCAA4AFIwAADQsuAAABgAUBAAABgAQAAQEAgAOABIAJLgCAA4AKLgCABYALCwCACoAJgAwkAIAMAAAM9y4BgAqACC4CgAiACwEAgAoAAoAKAQCACwACgAsjAAAMxigBgAUEAAEDAIAGAAKABiMAAA0LJioBAAEFxWvEWg4QAAI8AQECJiUAAAjeLgiARgAFIwAADS4NKAAFgEQABiQCAAYAAA2ZIwAADUMtDQEFLQ0CBi0NAwctDQQILQ0GCQAoCQIJLQ4JBi0IAQknAgoEBQAQAQoBJwMJBAEAKAYCCicCCwQEACgJAgw/DwAKAAwtDgUBLQ4JAi0OBwMtDggEJi0NAwYMOAUGBwEoAAWASAAGJAIABwAADbcjAAAOIy0NAQctDQIILQ0DCS0NBAoAKAgCDAA4DAUNLQ0NCwAoBwINADgNBQ4tDQ4MADgLDA0uBAAIgAMoAIAEBAAFJQAADH4uCIAFAAsAKAsCDAA4DAUOLQ4NDi0OBwEtDgsCLQ4JAy0OCgQjAAAOIy0MBgUjAAANLioBAAEF9C7lhLv0IdE8AQECJigAgAYEAAIHAIAEgAaABS4AgASACCgAgAkEAAANAIAJgAWAChcAgAqACiQAgAoAAA69AwCACAACgAgBAIADgAmACy4BgAuABgEAgAOACIALLgGAC4AHAQCAA4AJgAsuAoAHgAsBAIADgAiACy4CgAaACwEAgAkAAoAJIwAADlom",
+      "debug_symbols": "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",
       "brillig_names": [
         "set_update_delay"
       ]
@@ -2045,8 +2045,8 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "store_in_execution_cache_oracle_wrapper",
         "call_private_function_internal",
@@ -2056,7 +2056,7 @@
         "debug_log_oracle_wrapper",
         "directive_invert"
       ],
-      "verification_key": "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"
+      "verification_key": "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"
     }
   ],
   "outputs": {
@@ -2102,6 +2102,71 @@
     },
     "structs": {
       "events": [
+        {
+          "fields": [
+            {
+              "name": "DEPLOYER_CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE",
+              "type": {
+                "kind": "field"
+              }
+            },
+            {
+              "name": "address",
+              "type": {
+                "fields": [
+                  {
+                    "name": "inner",
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                ],
+                "kind": "struct",
+                "path": "aztec::protocol_types::address::aztec_address::AztecAddress"
+              }
+            },
+            {
+              "name": "prev_contract_class_id",
+              "type": {
+                "fields": [
+                  {
+                    "name": "inner",
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                ],
+                "kind": "struct",
+                "path": "aztec::protocol_types::contract_class_id::ContractClassId"
+              }
+            },
+            {
+              "name": "new_contract_class_id",
+              "type": {
+                "fields": [
+                  {
+                    "name": "inner",
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                ],
+                "kind": "struct",
+                "path": "aztec::protocol_types::contract_class_id::ContractClassId"
+              }
+            },
+            {
+              "name": "block_of_change",
+              "type": {
+                "kind": "integer",
+                "sign": "unsigned",
+                "width": 32
+              }
+            }
+          ],
+          "kind": "struct",
+          "path": "ContractInstanceDeployer::ContractInstanceUpdated"
+        },
         {
           "fields": [
             {
@@ -2331,71 +2396,6 @@
           ],
           "kind": "struct",
           "path": "ContractInstanceDeployer::ContractInstanceDeployed"
-        },
-        {
-          "fields": [
-            {
-              "name": "DEPLOYER_CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE",
-              "type": {
-                "kind": "field"
-              }
-            },
-            {
-              "name": "address",
-              "type": {
-                "fields": [
-                  {
-                    "name": "inner",
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "aztec::protocol_types::address::aztec_address::AztecAddress"
-              }
-            },
-            {
-              "name": "prev_contract_class_id",
-              "type": {
-                "fields": [
-                  {
-                    "name": "inner",
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "aztec::protocol_types::contract_class_id::ContractClassId"
-              }
-            },
-            {
-              "name": "new_contract_class_id",
-              "type": {
-                "fields": [
-                  {
-                    "name": "inner",
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "aztec::protocol_types::contract_class_id::ContractClassId"
-              }
-            },
-            {
-              "name": "block_of_change",
-              "type": {
-                "kind": "integer",
-                "sign": "unsigned",
-                "width": 32
-              }
-            }
-          ],
-          "kind": "struct",
-          "path": "ContractInstanceDeployer::ContractInstanceUpdated"
         }
       ],
       "functions": [
@@ -2406,21 +2406,28 @@
               "type": {
                 "fields": [
                   {
-                    "name": "new_update_delay",
+                    "name": "new_contract_class_id",
                     "type": {
-                      "kind": "integer",
-                      "sign": "unsigned",
-                      "width": 32
+                      "fields": [
+                        {
+                          "name": "inner",
+                          "type": {
+                            "kind": "field"
+                          }
+                        }
+                      ],
+                      "kind": "struct",
+                      "path": "aztec::protocol_types::contract_class_id::ContractClassId"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "ContractInstanceDeployer::set_update_delay_parameters"
+                "path": "ContractInstanceDeployer::update_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "ContractInstanceDeployer::set_update_delay_abi"
+          "path": "ContractInstanceDeployer::update_abi"
         },
         {
           "fields": [
@@ -2630,28 +2637,21 @@
               "type": {
                 "fields": [
                   {
-                    "name": "new_contract_class_id",
+                    "name": "new_update_delay",
                     "type": {
-                      "fields": [
-                        {
-                          "name": "inner",
-                          "type": {
-                            "kind": "field"
-                          }
-                        }
-                      ],
-                      "kind": "struct",
-                      "path": "aztec::protocol_types::contract_class_id::ContractClassId"
+                      "kind": "integer",
+                      "sign": "unsigned",
+                      "width": 32
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "ContractInstanceDeployer::update_parameters"
+                "path": "ContractInstanceDeployer::set_update_delay_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "ContractInstanceDeployer::update_abi"
+          "path": "ContractInstanceDeployer::set_update_delay_abi"
         },
         {
           "fields": [
@@ -2719,9 +2719,9 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/with_hash.nr",
       "source": "use crate::{\n    context::{PublicContext, UtilityContext},\n    history::public_storage::PublicStorageHistoricalRead,\n    oracle,\n};\nuse dep::protocol_types::{\n    address::AztecAddress, block_header::BlockHeader, hash::poseidon2_hash, traits::Packable,\n};\n\n/// A struct that allows for efficient reading of value `T` from public storage in private.\n///\n/// The efficient reads are achieved by verifying large values through a single hash check\n/// and then proving inclusion only of the hash in public storage. This reduces the number\n/// of required tree inclusion proofs from `N` to 1.\n///\n/// # Type Parameters\n/// - `T`: The underlying type being wrapped, must implement `Packable<N>`\n/// - `N`: The number of field elements required to pack values of type `T`\npub struct WithHash<T, let N: u32> {\n    value: T,\n    packed: [Field; N],\n    hash: Field,\n}\n\nimpl<T, let N: u32> WithHash<T, N>\nwhere\n    T: Packable<N> + Eq,\n{\n    pub fn new(value: T) -> Self {\n        let packed = value.pack();\n        Self { value, packed, hash: poseidon2_hash(packed) }\n    }\n\n    pub fn get_value(self) -> T {\n        self.value\n    }\n\n    pub fn get_hash(self) -> Field {\n        self.hash\n    }\n\n    pub fn public_storage_read(context: PublicContext, storage_slot: Field) -> T {\n        context.storage_read(storage_slot)\n    }\n\n    pub unconstrained fn utility_public_storage_read(\n        context: UtilityContext,\n        storage_slot: Field,\n    ) -> T {\n        context.storage_read(storage_slot)\n    }\n\n    pub fn historical_public_storage_read(\n        header: BlockHeader,\n        address: AztecAddress,\n        storage_slot: Field,\n    ) -> T {\n        let historical_block_number = header.global_variables.block_number as u32;\n\n        // We could simply produce historical inclusion proofs for each field in `packed`, but that would require one\n        // full sibling path per storage slot (since due to kernel siloing the storage is not contiguous). Instead, we\n        // get an oracle to provide us the values, and instead we prove inclusion of their hash, which is both a much\n        // smaller proof (a single slot), and also independent of the size of T (except in that we need to pack and hash T).\n        let hint = WithHash::new(\n            // Safety: We verify that a hash of the hint/packed data matches the stored hash.\n            unsafe {\n                oracle::storage::storage_read(address, storage_slot, historical_block_number)\n            },\n        );\n\n        let hash = header.public_storage_historical_read(storage_slot + N as Field, address);\n\n        if hash != 0 {\n            assert_eq(hash, hint.get_hash(), \"Hint values do not match hash\");\n        } else {\n            // The hash slot can only hold a zero if it is uninitialized. Therefore, the hints must then be zero\n            // (i.e. the default value for public storage) as well.\n            assert_eq(\n                hint.get_value(),\n                T::unpack(std::mem::zeroed()),\n                \"Non-zero hint for zero hash\",\n            );\n        };\n\n        hint.get_value()\n    }\n}\n\nimpl<T, let N: u32> Packable<N + 1> for WithHash<T, N>\nwhere\n    T: Packable<N>,\n{\n    fn pack(self) -> [Field; N + 1] {\n        let mut result: [Field; N + 1] = std::mem::zeroed();\n        for i in 0..N {\n            result[i] = self.packed[i];\n        }\n        result[N] = self.hash;\n\n        result\n    }\n\n    fn unpack(packed: [Field; N + 1]) -> Self {\n        let mut value_packed: [Field; N] = std::mem::zeroed();\n        for i in 0..N {\n            value_packed[i] = packed[i];\n        }\n        let hash = packed[N];\n\n        Self { value: T::unpack(value_packed), packed: value_packed, hash }\n    }\n}\n\nmod test {\n    use crate::{\n        oracle::random::random,\n        test::{\n            helpers::{cheatcodes, test_environment::TestEnvironment},\n            mocks::mock_struct::MockStruct,\n        },\n        utils::with_hash::WithHash,\n    };\n    use dep::protocol_types::hash::poseidon2_hash;\n    use dep::protocol_types::traits::{Packable, ToField};\n    use dep::std::{mem, test::OracleMock};\n\n    global storage_slot: Field = 47;\n\n    #[test]\n    unconstrained fn create_and_recover() {\n        let value = MockStruct { a: 5, b: 3 };\n        let value_with_hash = WithHash::new(value);\n        let recovered = WithHash::unpack(value_with_hash.pack());\n\n        assert_eq(recovered.value, value);\n        assert_eq(recovered.packed, value.pack());\n        assert_eq(recovered.hash, poseidon2_hash(value.pack()));\n    }\n\n    #[test]\n    unconstrained fn read_uninitialized_value() {\n        let mut env = TestEnvironment::new();\n\n        let block_header = env.private().historical_header;\n        let address = env.contract_address();\n\n        let result = WithHash::<MockStruct, _>::historical_public_storage_read(\n            block_header,\n            address,\n            storage_slot,\n        );\n\n        // We should get zeroed value\n        let expected: MockStruct = mem::zeroed();\n        assert_eq(result, expected);\n    }\n\n    #[test]\n    unconstrained fn read_initialized_value() {\n        let mut env = TestEnvironment::new();\n\n        let value = MockStruct { a: 5, b: 3 };\n        let value_with_hash = WithHash::new(value);\n\n        // We write the value with hash to storage\n        cheatcodes::direct_storage_write(\n            env.contract_address(),\n            storage_slot,\n            value_with_hash.pack(),\n        );\n\n        // We advance block by 1 because env.private() currently returns context at latest_block - 1\n        env.advance_block_by(1);\n\n        let result = WithHash::<MockStruct, _>::historical_public_storage_read(\n            env.private().historical_header,\n            env.contract_address(),\n            storage_slot,\n        );\n\n        assert_eq(result, value);\n    }\n\n    #[test(should_fail_with = \"Non-zero hint for zero hash\")]\n    unconstrained fn test_bad_hint_uninitialized_value() {\n        let mut env = TestEnvironment::new();\n\n        env.advance_block_to(6);\n\n        let value_packed = MockStruct { a: 1, b: 1 }.pack();\n\n        let block_header = env.private().historical_header;\n        let address = env.contract_address();\n\n        // Mock the oracle to return a non-zero hint/packed value\n        let _ = OracleMock::mock(\"storageRead\")\n            .with_params((\n                address.to_field(), storage_slot, block_header.global_variables.block_number as u32,\n                value_packed.len(),\n            ))\n            .returns(value_packed)\n            .times(1);\n\n        // This should revert because the hint value is non-zero and the hash is zero (default value of storage)\n        let _ = WithHash::<MockStruct, _>::historical_public_storage_read(\n            block_header,\n            address,\n            storage_slot,\n        );\n    }\n\n    #[test(should_fail_with = \"Hint values do not match hash\")]\n    unconstrained fn test_bad_hint_initialized_value() {\n        let mut env = TestEnvironment::new();\n\n        let value_packed = MockStruct { a: 5, b: 3 }.pack();\n\n        // We write the value to storage\n        cheatcodes::direct_storage_write(env.contract_address(), storage_slot, value_packed);\n\n        // Now we write incorrect hash to the hash storage slot\n        let incorrect_hash = random();\n        let hash_storage_slot = storage_slot + (value_packed.len() as Field);\n        cheatcodes::direct_storage_write(\n            env.contract_address(),\n            hash_storage_slot,\n            [incorrect_hash],\n        );\n\n        // We advance block by 1 because env.private() currently returns context at latest_block - 1\n        env.advance_block_by(1);\n\n        let _ = WithHash::<MockStruct, _>::historical_public_storage_read(\n            env.private().historical_header,\n            env.contract_address(),\n            storage_slot,\n        );\n    }\n}\n"
     },
-    "20": {
-      "path": "std/hash/poseidon2.nr",
-      "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub(crate) 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(crate) 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(crate) 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"
+    "199": {
+      "path": "/home/aztec-dev/nargo/github.com/noir-lang/poseidon/v0.1.0/src/poseidon2.nr",
+      "source": "use std::default::Default;\nuse std::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::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"
     },
     "261": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
@@ -2745,11 +2745,11 @@
     },
     "279": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
-      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        contract_class_log::ContractClassLog,\n        function_selector::FunctionSelector,\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{OrderedValue, 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, TWO_POW_64,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, ToField},\n    utils::{\n        arrays::{array_concat, unsafe_padded_array_length},\n        field::{field_from_bytes, field_from_bytes_32_trunc},\n    },\n};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(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\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, 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    first_nullifier: 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(first_nullifier, 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_contract_class_log_field(\n    contract_address: AztecAddress,\n    first_field: Field,\n) -> Field {\n    poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n    if contract_class_log.contract_address.is_zero() {\n        contract_class_log\n    } else {\n        let mut log = contract_class_log;\n        log.log.fields[0] = compute_siloed_contract_class_log_field(\n            contract_class_log.contract_address,\n            log.log.fields[0],\n        );\n        log\n    }\n}\n\npub fn compute_contract_class_log_hash(contract_class_log: ContractClassLog) -> Field {\n    let array = contract_class_log.log.fields;\n    // Safety: The below length is constrained in the base rollup.\n    let length = unsafe { unsafe_padded_array_length(array) };\n    if length == 0 {\n        0\n    } else {\n        poseidon2_hash(array)\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: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\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[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\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\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(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        contract_class_log::ContractClassLog,\n        function_selector::FunctionSelector,\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{OrderedValue, 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, TWO_POW_64,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, ToField},\n    utils::{\n        arrays::{array_concat, unsafe_padded_array_length},\n        field::{field_from_bytes, field_from_bytes_32_trunc},\n    },\n};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(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\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, 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    first_nullifier: 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(first_nullifier, 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_contract_class_log_field(\n    contract_address: AztecAddress,\n    first_field: Field,\n) -> Field {\n    poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n    if contract_class_log.contract_address.is_zero() {\n        contract_class_log\n    } else {\n        let mut log = contract_class_log;\n        log.log.fields[0] = compute_siloed_contract_class_log_field(\n            contract_class_log.contract_address,\n            log.log.fields[0],\n        );\n        log\n    }\n}\n\npub fn compute_contract_class_log_hash(contract_class_log: ContractClassLog) -> Field {\n    let array = contract_class_log.log.fields;\n    // Safety: The below length is constrained in the base rollup.\n    let length = unsafe { unsafe_padded_array_length(array) };\n    if length == 0 {\n        0\n    } else {\n        poseidon2_hash(array)\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: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\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[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\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\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    poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as poseidon::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(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"
     },
     "293": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/meta/mod.nr",
-      "source": "use super::traits::{Deserialize, Packable, Serialize};\n\n/// Returns the typed expression of a trait method implementation.\n///\n/// This helper function is preferred over directly inlining with `$typ::target_method()` in a quote,\n/// as direct inlining would result in missing import warnings in the generated code (specifically,\n/// warnings that the trait implementation is not in scope).\n///\n/// # Note\n/// A copy of this function exists in `aztec-nr/aztec/src/macros/utils.nr`. We maintain separate copies\n/// because importing it there from here would cause the `target_trait` to be interpreted in the context\n/// of this crate, making it impossible to compile code for traits from that crate (e.g. NoteType).\ncomptime fn get_trait_impl_method(\n    typ: Type,\n    target_trait: Quoted,\n    target_method: Quoted,\n) -> TypedExpr {\n    let trait_constraint = target_trait.as_trait_constraint();\n    typ\n        .get_trait_impl(trait_constraint)\n        .expect(f\"Could not find impl for {target_trait} for type {typ}\")\n        .methods()\n        .filter(|m| m.name() == target_method)[0]\n        .as_typed_expr()\n}\n\n/// Generates code that deserializes a struct, primitive type, array or string from a field array.\n///\n/// # Parameters\n/// - `name`: The name of the current field being processed, used to identify fields for replacement.\n/// - `typ`: The type of the struct or field being deserialized (e.g., a custom struct, array, or primitive).\n/// - `field_array_name`: The name of the field array containing serialized field data (e.g., `\"values\"`).\n/// - `num_already_consumed`: The number of fields already processed in previous recursion calls.\n/// - `should_unpack`: A boolean indicating whether the type should be unpacked (see description of `Packable`\n/// and `Serialize` trait for more information about the difference between packing and serialization).\n///\n/// # Returns\n/// A tuple containing:\n/// - `Quoted`: A code that deserializes a given struct, primitive type, array, or string from the field array.\n/// - `u32`: The total number of fields consumed during deserialization (used for recursion).\n///\n/// # Nested Struct Example\n/// Given the following setup:\n/// ```\n/// struct UintNote {\n///     value: u128,\n///     owner: AztecAddress,\n///     randomness: Field,\n/// }\n///\n/// struct AztecAddress {\n///     inner: Field,\n/// }\n/// ```\n///\n/// If `UintNote` is the input type, the function will generate the following deserialization code:\n/// ```\n/// UintNote {\n///     value: fields[0] as u128,\n///     owner: AztecAddress {\n///         inner: fields[1],\n///     },\n///     randomness: fields[2],\n/// }\n/// ```\n/// # Nested Struct Example with Unpacking\n/// - given the same setup as above and given that u128, AztecAddress and Field implement the `Packable` trait\n///   the result we get is:\n/// ```\n/// UintNote {\n///     value: aztec::protocol_types::traits::Packable::unpack([fields[0]]),\n///     owner: aztec::protocol_types::traits::Packable::unpack([fields[1]]),\n///     randomness: aztec::protocol_types::traits::Packable::unpack([fields[2]]),\n/// }\n/// ```\n///\n/// # Panics\n/// - If the deserialization logic encounters a type it does not support.\n/// - If an incorrect number of fields are consumed when deserializing a string.\npub comptime fn generate_deserialize_from_fields(\n    name: Quoted,\n    typ: Type,\n    field_array_name: Quoted,\n    num_already_consumed: u32,\n    should_unpack: bool,\n) -> (Quoted, u32) {\n    let mut result = quote {};\n    // Counter for the number of fields consumed\n    let mut consumed_counter: u32 = 0;\n\n    // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n    let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n    let packable_constraint = quote { Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n    if (should_unpack & typ.implements(packable_constraint)) {\n        // Unpacking is enabled and the given type implements the `Packable` trait so we call the `unpack()`\n        // method, add the resulting field array to `aux_vars` and each field to `fields`.\n        let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n        // We copy the packed fields into a new array and pass that to the unpack function in a quote\n        let mut packed_fields_quotes = &[];\n        for i in 0..packed_len {\n            let index_in_field_array = i + num_already_consumed;\n            packed_fields_quotes =\n                packed_fields_quotes.push_back(quote { $field_array_name[$index_in_field_array] });\n        }\n        let packed_fields = packed_fields_quotes.join(quote {,});\n\n        // Now we call unpack on the type\n        let unpack_method = get_trait_impl_method(typ, quote { Packable<_> }, quote { unpack });\n        result = quote { $unpack_method([ $packed_fields ]) };\n\n        consumed_counter = packed_len;\n    } else if typ.is_field() | typ.as_integer().is_some() | typ.is_bool() {\n        // The field is a primitive so we just reference it in the field array\n        result = quote { $field_array_name[$num_already_consumed] as $typ };\n        consumed_counter = 1;\n    } else if typ.as_data_type().is_some() {\n        // The field is a struct so we iterate over each struct field and recursively call\n        // `generate_deserialize_from_fields`\n        let (nested_def, generics) = typ.as_data_type().unwrap();\n        let nested_name = nested_def.name();\n        let mut deserialized_fields_list = &[];\n\n        // Iterate over each field in the struct\n        for field in nested_def.fields(generics) {\n            let (field_name, field_type) = field;\n            // Recursively call `generate_deserialize_from_fields` for each field in the struct\n            let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n                field_name,\n                field_type,\n                field_array_name,\n                consumed_counter + num_already_consumed,\n                should_unpack,\n            );\n            // We increment the consumed counter by the number of fields consumed in the recursion\n            consumed_counter += num_consumed_in_recursion;\n            // We add the deserialized field to the list of deserialized fields.\n            // E.g. `value: u128 { lo: fields[0], hi: fields[1] }`\n            deserialized_fields_list =\n                deserialized_fields_list.push_back(quote { $field_name: $deserialized_field });\n        }\n\n        // We can construct the struct from the deserialized fields\n        let deserialized_fields = deserialized_fields_list.join(quote {,});\n        result = quote {\n                $nested_name {\n                    $deserialized_fields\n                }\n            };\n    } else if typ.as_array().is_some() {\n        // The field is an array so we iterate over each element and recursively call\n        // `generate_deserialize_from_fields`\n        let (element_type, array_len) = typ.as_array().unwrap();\n        let array_len = array_len.as_constant().unwrap();\n        let mut array_fields_list = &[];\n\n        // Iterate over each element in the array\n        for _ in 0..array_len {\n            // Recursively call `generate_deserialize_from_fields` for each element in the array\n            let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n                name,\n                element_type,\n                field_array_name,\n                consumed_counter + num_already_consumed,\n                should_unpack,\n            );\n            // We increment the consumed counter by the number of fields consumed in the recursion\n            consumed_counter += num_consumed_in_recursion;\n            // We add the deserialized field to the list of deserialized fields.\n            array_fields_list = array_fields_list.push_back(deserialized_field);\n        }\n\n        // We can construct the array from the deserialized fields\n        let array_fields = array_fields_list.join(quote {,});\n        result = quote { [ $array_fields ] };\n    } else if typ.as_str().is_some() {\n        // The field is a string and we expect each byte of the string to be represented as 1 field in the field\n        // array. So we iterate over the string length and deserialize each character as u8 in the recursive call\n        // to `generate_deserialize_from_fields`.\n        let length_type = typ.as_str().unwrap();\n        let str_len = length_type.as_constant().unwrap();\n        let mut byte_list = &[];\n\n        // Iterate over each character in the string\n        for _ in 0..str_len {\n            // Recursively call `generate_deserialize_from_fields` for each character in the string\n            let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n                name,\n                quote {u8}.as_type(),\n                field_array_name,\n                consumed_counter + num_already_consumed,\n                should_unpack,\n            );\n\n            // We should consume just one field in the recursion so we sanity check that\n            assert_eq(\n                num_consumed_in_recursion,\n                1,\n                \"Incorrect number of fields consumed in string deserialization\",\n            );\n\n            // We increment the consumed counter by 1 as we have consumed one field\n            consumed_counter += 1;\n\n            // We add the deserialized field to the list of deserialized fields.\n            // E.g. `fields[6] as u8`\n            byte_list = byte_list.push_back(deserialized_field);\n        }\n\n        // We construct the string from the deserialized fields\n        let bytes = byte_list.join(quote {,});\n        result = quote { [ $bytes ].as_str_unchecked() };\n    } else {\n        panic(\n            f\"Unsupported type for serialization of argument {name} and type {typ}\",\n        )\n    }\n\n    (result, consumed_counter)\n}\n\n/// Generates code that serializes a type into an array of fields. Also generates auxiliary variables if necessary\n/// for serialization. If `should_pack` is true, we check if the type implements the `Packable` trait and pack it\n/// if it does.\n///\n/// # Parameters\n/// - `name`: The base identifier (e.g., `self`, `some_var`).\n/// - `typ`: The type being serialized (e.g., a custom struct, array, or primitive type).\n/// - `omit`: A list of field names (as `Quoted`) to be excluded from the serialized output.\n/// - `should_pack`: A boolean indicating whether the type should be packed.\n///\n/// # Returns\n/// A tuple containing:\n/// - A flattened array of `Quoted` field references representing the serialized fields.\n/// - An array of `Quoted` auxiliary variables needed for serialization, such as byte arrays for strings.\n///\n/// # Examples\n///\n/// ## Struct\n/// Given the following struct:\n/// ```rust\n/// struct MockStruct {\n///     a: Field,\n///     b: Field,\n/// }\n/// ```\n///\n/// Serializing the struct:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_mock_struct }, MockStruct, &[], false)\n/// // Returns:\n/// // ([`my_mock_struct.a`, `my_mock_struct.b`], [])\n/// ```\n///\n/// ## Nested Struct\n/// For a more complex struct:\n/// ```rust\n/// struct NestedStruct {\n///     m1: MockStruct,\n///     m2: MockStruct,\n/// }\n/// ```\n///\n/// Serialization output:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, NestedStruct, &[], false)\n/// // Returns:\n/// // ([`self.m1.a`, `self.m1.b`, `self.m2.a`, `self.m2.b`], [])\n/// ```\n///\n/// ## Array\n/// For an array type:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_array }, [Field; 3], &[], false)\n/// // Returns:\n/// // ([`my_array[0]`, `my_array[1]`, `my_array[2]`], [])\n/// ```\n///\n/// ## String\n/// For a string field, where each character is serialized as a `Field`:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_string }, StringType, &[], false)\n/// // Returns:\n/// // ([`my_string_as_bytes[0] as Field`, `my_string_as_bytes[1] as Field`, ...],\n/// // [`let my_string_as_bytes = my_string.as_bytes()`])\n/// ```\n///\n/// ## Nested Struct with Omitted Field and packing enabled\n/// - u128 has a `Packable` implementation hence it will be packed.\n///\n/// For a more complex struct:\n/// ```rust\n/// struct MyStruct {\n///     value: u128,\n///     value2: Field,\n/// }\n/// ```\n///\n/// Serializing while omitting `value2`:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, MyStruct, &[quote { self.value2 }], true)\n/// // Returns:\n/// // ([`value_packed[0]`], [`let value_packed = self.value.pack()`])\n/// ```\n///\n/// # Panics\n/// - If the type is unsupported for serialization.\n/// - If the provided `typ` contains invalid constants or incompatible structures.\npub comptime fn generate_serialize_to_fields(\n    name: Quoted,\n    typ: Type,\n    omit: [Quoted],\n    should_pack: bool,\n) -> ([Quoted], [Quoted]) {\n    let mut fields = &[];\n    let mut aux_vars = &[];\n\n    // Proceed if none of the omit rules omits this name\n    if !omit.any(|to_omit| to_omit == name) {\n        // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n        let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n        let packable_constraint =\n            quote { crate::traits::Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n        if (should_pack & typ.implements(packable_constraint)) {\n            // Packing is enabled and the given type implements the `Packable` trait so we call the `pack()`\n            // method, add the resulting field array to `aux_vars` and each field to `fields`.\n            let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n            // We collapse the name to a one that gets tokenized as a single token (e.g. \"self.value\" -> \"self_value\").\n            let name_at_one_token = collapse_to_one_token(name);\n            let packed_struct_name = f\"{name_at_one_token}_aux_var\".quoted_contents();\n\n            // We add the individual fields to the fields array\n            let pack_method = get_trait_impl_method(\n                typ,\n                quote { crate::traits::Packable<$packed_len> },\n                quote { pack },\n            );\n            let packed_struct = quote { let $packed_struct_name = $pack_method($name) };\n            for i in 0..packed_len {\n                fields = fields.push_back(quote { $packed_struct_name[$i] });\n            }\n\n            // We add the new auxiliary variable to the aux_vars array\n            aux_vars = aux_vars.push_back(packed_struct);\n        } else if typ.is_field() {\n            // For field we just add the value to fields\n            fields = fields.push_back(name);\n        } else if typ.as_integer().is_some() | typ.is_bool() {\n            // For integer and bool we just cast to Field and add the value to fields\n            fields = fields.push_back(quote { $name as Field });\n        } else if typ.as_data_type().is_some() {\n            // For struct we pref\n            let nested_struct = typ.as_data_type().unwrap();\n            let params = nested_struct.0.fields(nested_struct.1);\n            let struct_flattened = params.map(|(param_name, param_type): (Quoted, Type)| {\n                let maybe_prefixed_name = if name == quote {} {\n                    // Triggered when the param name is of a value available in the current scope (e.g. a function\n                    // argument) --> then we don't prefix the name with anything.\n                    param_name\n                } else {\n                    // Triggered when we want to prefix the param name with the `name` from function input. This\n                    // can typically be `self` when implementing a method on a struct.\n                    quote { $name.$param_name }\n                };\n                generate_serialize_to_fields(\n                    quote {$maybe_prefixed_name},\n                    param_type,\n                    omit,\n                    should_pack,\n                )\n            });\n            let struct_flattened_fields = struct_flattened.fold(\n                &[],\n                |acc: [Quoted], (fields, _): (_, [Quoted])| acc.append(fields),\n            );\n            let struct_flattened_aux_vars = struct_flattened.fold(\n                &[],\n                |acc: [Quoted], (_, aux_vars): ([Quoted], _)| acc.append(aux_vars),\n            );\n            fields = fields.append(struct_flattened_fields);\n            aux_vars = aux_vars.append(struct_flattened_aux_vars);\n        } else if typ.as_array().is_some() {\n            // For array we recursively call `generate_serialize_to_fields(...)` for each element\n            let (element_type, array_len) = typ.as_array().unwrap();\n            let array_len = array_len.as_constant().unwrap();\n            for i in 0..array_len {\n                let (element_fields, element_aux_vars) = generate_serialize_to_fields(\n                    quote { $name[$i] },\n                    element_type,\n                    omit,\n                    should_pack,\n                );\n                fields = fields.append(element_fields);\n                aux_vars = aux_vars.append(element_aux_vars);\n            }\n        } else if typ.as_str().is_some() {\n            // For string we convert the value to bytes, we store the `as_bytes` in an auxiliary variables and\n            // then we add each byte to fields as a Field\n            let length_type = typ.as_str().unwrap();\n            let str_len = length_type.as_constant().unwrap();\n            let as_member = name.as_expr().unwrap().as_member_access();\n            let var_name = if as_member.is_some() {\n                as_member.unwrap().1\n            } else {\n                name\n            };\n            let as_bytes_name = f\"{var_name}_as_bytes\".quoted_contents();\n            let as_bytes = quote { let $as_bytes_name = $name.as_bytes() };\n            for i in 0..str_len {\n                fields = fields.push_back(quote { $as_bytes_name[$i] as Field });\n            }\n            aux_vars = aux_vars.push_back(as_bytes);\n        } else {\n            panic(\n                f\"Unsupported type for serialization of argument {name} and type {typ}\",\n            )\n        }\n    }\n    (fields, aux_vars)\n}\n\n/// From a quote that gets tokenized to a multiple tokens we collapse it to a single token by replacing all `.` with `_`.\n/// E.g. \"self.values[0]\" -> \"self_values_0_\"\ncomptime fn collapse_to_one_token(q: Quoted) -> Quoted {\n    let tokens = q.tokens();\n\n    let mut single_token = quote {};\n    for token in tokens {\n        let new_token = if ((token == quote {.}) | (token == quote {[}) | (token == quote {]})) {\n            quote {_}\n        } else {\n            token\n        };\n        single_token = f\"{single_token}{new_token}\".quoted_contents();\n    }\n    single_token\n}\n\npub(crate) comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let (fields, aux_vars) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n    let aux_vars_for_serialization = if aux_vars.len() > 0 {\n        let joint = aux_vars.join(quote {;});\n        quote { $joint; }\n    } else {\n        quote {}\n    };\n\n    let field_serializations = fields.join(quote {,});\n    let serialized_len = fields.len();\n    quote {\n        impl Serialize<$serialized_len> for $typ {\n            fn serialize(self) -> [Field; $serialized_len] {\n                $aux_vars_for_serialization\n                [ $field_serializations ]\n            }\n        }\n    }\n}\n\npub(crate) comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let (fields, _) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n    let serialized_len = fields.len();\n    let (deserialized, _) =\n        generate_deserialize_from_fields(quote { self }, typ, quote { serialized }, 0, false);\n    quote {\n        impl Deserialize<$serialized_len> for $typ {\n            fn deserialize(serialized: [Field; $serialized_len]) -> Self {\n                $deserialized\n            }\n        }\n    }\n}\n\n/// Generates `Packable` implementation for a given struct and returns the packed length.\n///\n/// Note: We are having this function separate from `derive_packable` because we use this in the note macros to get\n/// the packed length of a note as well as the `Packable` implementation. We need the length to be able to register\n/// the note in the global `NOTES` map. There the length is used to generate partial note helper functions.\npub comptime fn derive_packable_and_get_packed_len(s: TypeDefinition) -> (Quoted, u32) {\n    let packing_enabled = true;\n\n    let typ = s.as_type();\n    let (fields, aux_vars) =\n        generate_serialize_to_fields(quote { self }, typ, &[], packing_enabled);\n    let aux_vars_for_packing = if aux_vars.len() > 0 {\n        let joint = aux_vars.join(quote {;});\n        quote { $joint; }\n    } else {\n        quote {}\n    };\n\n    let (unpacked, _) =\n        generate_deserialize_from_fields(quote { self }, typ, quote { packed }, 0, packing_enabled);\n\n    let field_packings = fields.join(quote {,});\n    let packed_len = fields.len();\n    let packable_trait: TraitConstraint = quote { Packable<$packed_len> }.as_trait_constraint();\n    (\n        quote {\n        impl $packable_trait for $typ {\n            fn pack(self) -> [Field; $packed_len] {\n                $aux_vars_for_packing\n                [ $field_packings ]\n            }\n\n            fn unpack(packed: [Field; $packed_len]) -> Self {\n                $unpacked\n            }\n        }\n    },\n        packed_len,\n    )\n}\n\npub(crate) comptime fn derive_packable(s: TypeDefinition) -> Quoted {\n    let (packable_impl, _) = derive_packable_and_get_packed_len(s);\n    packable_impl\n}\n\n#[derive(Packable, Serialize, Deserialize, Eq)]\npub struct Smol {\n    a: Field,\n    b: Field,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct HasArray {\n    a: [Field; 2],\n    b: bool,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct Fancier {\n    a: Smol,\n    b: [Field; 2],\n    c: [u8; 3],\n    d: str<16>,\n}\n\nfn main() {\n    assert(false);\n}\n\n#[test]\nfn smol_test() {\n    let smol = Smol { a: 1, b: 2 };\n    let serialized = smol.serialize();\n    assert(serialized == [1, 2], serialized);\n    let deserialized = Smol::deserialize(serialized);\n    assert(deserialized == smol);\n\n    // None of the struct members implements the `Packable` trait so the packed and serialized data should be the same\n    let packed = smol.pack();\n    assert_eq(packed, serialized, \"Packed does not match serialized\");\n}\n\n#[test]\nfn has_array_test() {\n    let has_array = HasArray { a: [1, 2], b: true };\n    let serialized = has_array.serialize();\n    assert(serialized == [1, 2, 1], serialized);\n    let deserialized = HasArray::deserialize(serialized);\n    assert(deserialized == has_array);\n}\n\n#[test]\nfn fancier_test() {\n    let fancier =\n        Fancier { a: Smol { a: 1, b: 2 }, b: [0, 1], c: [1, 2, 3], d: \"metaprogramming!\" };\n    let serialized = fancier.serialize();\n    assert(\n        serialized\n            == [\n                1, 2, 0, 1, 1, 2, 3, 0x6d, 0x65, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61,\n                0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x21,\n            ],\n        serialized,\n    );\n    let deserialized = Fancier::deserialize(serialized);\n    assert(deserialized == fancier);\n}\n"
+      "source": "use super::traits::{Deserialize, Packable, Serialize};\n\n/// Returns the typed expression of a trait method implementation.\n///\n/// This helper function is preferred over directly inlining with `$typ::target_method()` in a quote,\n/// as direct inlining would result in missing import warnings in the generated code (specifically,\n/// warnings that the trait implementation is not in scope).\n///\n/// # Note\n/// A copy of this function exists in `aztec-nr/aztec/src/macros/utils.nr`. We maintain separate copies\n/// because importing it there from here would cause the `target_trait` to be interpreted in the context\n/// of this crate, making it impossible to compile code for traits from that crate (e.g. NoteType).\ncomptime fn get_trait_impl_method(\n    typ: Type,\n    target_trait: Quoted,\n    target_method: Quoted,\n) -> TypedExpr {\n    let trait_constraint = target_trait.as_trait_constraint();\n    typ\n        .get_trait_impl(trait_constraint)\n        .expect(f\"Could not find impl for {target_trait} for type {typ}\")\n        .methods()\n        .filter(|m| m.name() == target_method)[0]\n        .as_typed_expr()\n}\n\n/// Generates code that deserializes a struct, primitive type, array or string from a field array.\n///\n/// # Parameters\n/// - `name`: The name of the current field being processed, used to identify fields for replacement.\n/// - `typ`: The type of the struct or field being deserialized (e.g., a custom struct, array, or primitive).\n/// - `field_array_name`: The name of the field array containing serialized field data (e.g., `\"values\"`).\n/// - `num_already_consumed`: The number of fields already processed in previous recursion calls.\n/// - `should_unpack`: A boolean indicating whether the type should be unpacked (see description of `Packable`\n/// and `Serialize` trait for more information about the difference between packing and serialization).\n///\n/// # Returns\n/// A tuple containing:\n/// - `Quoted`: A code that deserializes a given struct, primitive type, array, or string from the field array.\n/// - `u32`: The total number of fields consumed during deserialization (used for recursion).\n///\n/// # Nested Struct Example\n/// Given the following setup:\n/// ```\n/// struct UintNote {\n///     value: u128,\n///     owner: AztecAddress,\n///     randomness: Field,\n/// }\n///\n/// struct AztecAddress {\n///     inner: Field,\n/// }\n/// ```\n///\n/// If `UintNote` is the input type, the function will generate the following deserialization code:\n/// ```\n/// UintNote {\n///     value: fields[0] as u128,\n///     owner: AztecAddress {\n///         inner: fields[1],\n///     },\n///     randomness: fields[2],\n/// }\n/// ```\n/// # Nested Struct Example with Unpacking\n/// - given the same setup as above and given that u128, AztecAddress and Field implement the `Packable` trait\n///   the result we get is:\n/// ```\n/// UintNote {\n///     value: aztec::protocol_types::traits::Packable::unpack([fields[0]]),\n///     owner: aztec::protocol_types::traits::Packable::unpack([fields[1]]),\n///     randomness: aztec::protocol_types::traits::Packable::unpack([fields[2]]),\n/// }\n/// ```\n///\n/// # Panics\n/// - If the deserialization logic encounters a type it does not support.\n/// - If an incorrect number of fields are consumed when deserializing a string.\npub comptime fn generate_deserialize_from_fields(\n    name: Quoted,\n    typ: Type,\n    field_array_name: Quoted,\n    num_already_consumed: u32,\n    should_unpack: bool,\n) -> (Quoted, u32) {\n    let mut result = quote {};\n    // Counter for the number of fields consumed\n    let mut consumed_counter: u32 = 0;\n\n    // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n    let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n    let packable_constraint = quote { Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n    if (should_unpack & typ.implements(packable_constraint)) {\n        // Unpacking is enabled and the given type implements the `Packable` trait so we call the `unpack()`\n        // method, add the resulting field array to `aux_vars` and each field to `fields`.\n        let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n        // We copy the packed fields into a new array and pass that to the unpack function in a quote\n        let mut packed_fields_quotes = &[];\n        for i in 0..packed_len {\n            let index_in_field_array = i + num_already_consumed;\n            packed_fields_quotes =\n                packed_fields_quotes.push_back(quote { $field_array_name[$index_in_field_array] });\n        }\n        let packed_fields = packed_fields_quotes.join(quote {,});\n\n        // Now we call unpack on the type\n        let unpack_method = get_trait_impl_method(typ, quote { Packable<_> }, quote { unpack });\n        result = quote { $unpack_method([ $packed_fields ]) };\n\n        consumed_counter = packed_len;\n    } else if typ.is_field() | typ.as_integer().is_some() | typ.is_bool() {\n        // The field is a primitive so we just reference it in the field array\n        result = quote { $field_array_name[$num_already_consumed] as $typ };\n        consumed_counter = 1;\n    } else if typ.as_data_type().is_some() {\n        // The field is a struct so we iterate over each struct field and recursively call\n        // `generate_deserialize_from_fields`\n        let (nested_def, generics) = typ.as_data_type().unwrap();\n        let nested_name = nested_def.name();\n        let mut deserialized_fields_list = &[];\n\n        // Iterate over each field in the struct\n        for field in nested_def.fields(generics) {\n            let (field_name, field_type) = field;\n            // Recursively call `generate_deserialize_from_fields` for each field in the struct\n            let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n                field_name,\n                field_type,\n                field_array_name,\n                consumed_counter + num_already_consumed,\n                should_unpack,\n            );\n            // We increment the consumed counter by the number of fields consumed in the recursion\n            consumed_counter += num_consumed_in_recursion;\n            // We add the deserialized field to the list of deserialized fields.\n            // E.g. `value: u128 { lo: fields[0], hi: fields[1] }`\n            deserialized_fields_list =\n                deserialized_fields_list.push_back(quote { $field_name: $deserialized_field });\n        }\n\n        // We can construct the struct from the deserialized fields\n        let deserialized_fields = deserialized_fields_list.join(quote {,});\n        result = quote {\n                $nested_name {\n                    $deserialized_fields\n                }\n            };\n    } else if typ.as_array().is_some() {\n        // The field is an array so we iterate over each element and recursively call\n        // `generate_deserialize_from_fields`\n        let (element_type, array_len) = typ.as_array().unwrap();\n        let array_len = array_len.as_constant().unwrap();\n        let mut array_fields_list = &[];\n\n        // Iterate over each element in the array\n        for _ in 0..array_len {\n            // Recursively call `generate_deserialize_from_fields` for each element in the array\n            let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n                name,\n                element_type,\n                field_array_name,\n                consumed_counter + num_already_consumed,\n                should_unpack,\n            );\n            // We increment the consumed counter by the number of fields consumed in the recursion\n            consumed_counter += num_consumed_in_recursion;\n            // We add the deserialized field to the list of deserialized fields.\n            array_fields_list = array_fields_list.push_back(deserialized_field);\n        }\n\n        // We can construct the array from the deserialized fields\n        let array_fields = array_fields_list.join(quote {,});\n        result = quote { [ $array_fields ] };\n    } else if typ.as_str().is_some() {\n        // The field is a string and we expect each byte of the string to be represented as 1 field in the field\n        // array. So we iterate over the string length and deserialize each character as u8 in the recursive call\n        // to `generate_deserialize_from_fields`.\n        let length_type = typ.as_str().unwrap();\n        let str_len = length_type.as_constant().unwrap();\n        let mut byte_list = &[];\n\n        // Iterate over each character in the string\n        for _ in 0..str_len {\n            // Recursively call `generate_deserialize_from_fields` for each character in the string\n            let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n                name,\n                quote {u8}.as_type(),\n                field_array_name,\n                consumed_counter + num_already_consumed,\n                should_unpack,\n            );\n\n            // We should consume just one field in the recursion so we sanity check that\n            assert_eq(\n                num_consumed_in_recursion,\n                1,\n                \"Incorrect number of fields consumed in string deserialization\",\n            );\n\n            // We increment the consumed counter by 1 as we have consumed one field\n            consumed_counter += 1;\n\n            // We add the deserialized field to the list of deserialized fields.\n            // E.g. `fields[6] as u8`\n            byte_list = byte_list.push_back(deserialized_field);\n        }\n\n        // We construct the string from the deserialized fields\n        let bytes = byte_list.join(quote {,});\n        result = quote { [ $bytes ].as_str_unchecked() };\n    } else {\n        panic(\n            f\"Unsupported type for serialization of argument {name} and type {typ}\",\n        )\n    }\n\n    (result, consumed_counter)\n}\n\n/// Generates code that serializes a type into an array of fields. Also generates auxiliary variables if necessary\n/// for serialization. If `should_pack` is true, we check if the type implements the `Packable` trait and pack it\n/// if it does.\n///\n/// # Parameters\n/// - `name`: The base identifier (e.g., `self`, `some_var`).\n/// - `typ`: The type being serialized (e.g., a custom struct, array, or primitive type).\n/// - `should_pack`: A boolean indicating whether the type should be packed.\n///\n/// # Returns\n/// A tuple containing:\n/// - A flattened array of `Quoted` field references representing the serialized fields.\n/// - An array of `Quoted` auxiliary variables needed for serialization, such as byte arrays for strings.\n///\n/// # Examples\n///\n/// ## Struct\n/// Given the following struct:\n/// ```rust\n/// struct MockStruct {\n///     a: Field,\n///     b: Field,\n/// }\n/// ```\n///\n/// Serializing the struct:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_mock_struct }, MockStruct, false)\n/// // Returns:\n/// // ([`my_mock_struct.a`, `my_mock_struct.b`], [])\n/// ```\n///\n/// ## Nested Struct\n/// For a more complex struct:\n/// ```rust\n/// struct NestedStruct {\n///     m1: MockStruct,\n///     m2: MockStruct,\n/// }\n/// ```\n///\n/// Serialization output:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, NestedStruct, false)\n/// // Returns:\n/// // ([`self.m1.a`, `self.m1.b`, `self.m2.a`, `self.m2.b`], [])\n/// ```\n///\n/// ## Array\n/// For an array type:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_array }, [Field; 3], false)\n/// // Returns:\n/// // ([`my_array[0]`, `my_array[1]`, `my_array[2]`], [])\n/// ```\n///\n/// ## String\n/// For a string field, where each character is serialized as a `Field`:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_string }, StringType, false)\n/// // Returns:\n/// // ([`my_string_as_bytes[0] as Field`, `my_string_as_bytes[1] as Field`, ...],\n/// // [`let my_string_as_bytes = my_string.as_bytes()`])\n/// ```\n///\n/// ## Nested Struct with packing enabled\n/// - u128 has a `Packable` implementation hence it will be packed.\n///\n/// For a more complex struct:\n/// ```rust\n/// struct MyStruct {\n///     value: u128,\n///     value2: Field,\n/// }\n/// ```\n///\n/// # Panics\n/// - If the type is unsupported for serialization.\n/// - If the provided `typ` contains invalid constants or incompatible structures.\npub comptime fn generate_serialize_to_fields(\n    name: Quoted,\n    typ: Type,\n    should_pack: bool,\n) -> ([Quoted], [Quoted]) {\n    let mut fields = &[];\n    let mut aux_vars = &[];\n\n    // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n    let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n    let packable_constraint =\n        quote { crate::traits::Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n    if (should_pack & typ.implements(packable_constraint)) {\n        // Packing is enabled and the given type implements the `Packable` trait so we call the `pack()`\n        // method, add the resulting field array to `aux_vars` and each field to `fields`.\n        let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n        // We collapse the name to a one that gets tokenized as a single token (e.g. \"self.value\" -> \"self_value\").\n        let name_at_one_token = collapse_to_one_token(name);\n        let packed_struct_name = f\"{name_at_one_token}_aux_var\".quoted_contents();\n\n        // We add the individual fields to the fields array\n        let pack_method = get_trait_impl_method(\n            typ,\n            quote { crate::traits::Packable<$packed_len> },\n            quote { pack },\n        );\n        let packed_struct = quote { let $packed_struct_name = $pack_method($name) };\n        for i in 0..packed_len {\n            fields = fields.push_back(quote { $packed_struct_name[$i] });\n        }\n\n        // We add the new auxiliary variable to the aux_vars array\n        aux_vars = aux_vars.push_back(packed_struct);\n    } else if typ.is_field() {\n        // For field we just add the value to fields\n        fields = fields.push_back(name);\n    } else if typ.as_integer().is_some() | typ.is_bool() {\n        // For integer and bool we just cast to Field and add the value to fields\n        fields = fields.push_back(quote { $name as Field });\n    } else if typ.as_data_type().is_some() {\n        // For struct we pref\n        let nested_struct = typ.as_data_type().unwrap();\n        let params = nested_struct.0.fields(nested_struct.1);\n        let struct_flattened = params.map(|(param_name, param_type): (Quoted, Type)| {\n            let maybe_prefixed_name = if name == quote {} {\n                // Triggered when the param name is of a value available in the current scope (e.g. a function\n                // argument) --> then we don't prefix the name with anything.\n                param_name\n            } else {\n                // Triggered when we want to prefix the param name with the `name` from function input. This\n                // can typically be `self` when implementing a method on a struct.\n                quote { $name.$param_name }\n            };\n            generate_serialize_to_fields(quote {$maybe_prefixed_name}, param_type, should_pack)\n        });\n        let struct_flattened_fields = struct_flattened.fold(\n            &[],\n            |acc: [Quoted], (fields, _): (_, [Quoted])| acc.append(fields),\n        );\n        let struct_flattened_aux_vars = struct_flattened.fold(\n            &[],\n            |acc: [Quoted], (_, aux_vars): ([Quoted], _)| acc.append(aux_vars),\n        );\n        fields = fields.append(struct_flattened_fields);\n        aux_vars = aux_vars.append(struct_flattened_aux_vars);\n    } else if typ.as_array().is_some() {\n        // For array we recursively call `generate_serialize_to_fields(...)` for each element\n        let (element_type, array_len) = typ.as_array().unwrap();\n        let array_len = array_len.as_constant().unwrap();\n        for i in 0..array_len {\n            let (element_fields, element_aux_vars) =\n                generate_serialize_to_fields(quote { $name[$i] }, element_type, should_pack);\n            fields = fields.append(element_fields);\n            aux_vars = aux_vars.append(element_aux_vars);\n        }\n    } else if typ.as_str().is_some() {\n        // For string we convert the value to bytes, we store the `as_bytes` in an auxiliary variables and\n        // then we add each byte to fields as a Field\n        let length_type = typ.as_str().unwrap();\n        let str_len = length_type.as_constant().unwrap();\n        let as_member = name.as_expr().unwrap().as_member_access();\n        let var_name = if as_member.is_some() {\n            as_member.unwrap().1\n        } else {\n            name\n        };\n        let as_bytes_name = f\"{var_name}_as_bytes\".quoted_contents();\n        let as_bytes = quote { let $as_bytes_name = $name.as_bytes() };\n        for i in 0..str_len {\n            fields = fields.push_back(quote { $as_bytes_name[$i] as Field });\n        }\n        aux_vars = aux_vars.push_back(as_bytes);\n    } else {\n        panic(\n            f\"Unsupported type for serialization of argument {name} and type {typ}\",\n        )\n    }\n\n    (fields, aux_vars)\n}\n\n/// From a quote that gets tokenized to a multiple tokens we collapse it to a single token by replacing all `.` with `_`.\n/// E.g. \"self.values[0]\" -> \"self_values_0_\"\ncomptime fn collapse_to_one_token(q: Quoted) -> Quoted {\n    let tokens = q.tokens();\n\n    let mut single_token = quote {};\n    for token in tokens {\n        let new_token = if ((token == quote {.}) | (token == quote {[}) | (token == quote {]})) {\n            quote {_}\n        } else {\n            token\n        };\n        single_token = f\"{single_token}{new_token}\".quoted_contents();\n    }\n    single_token\n}\n\npub(crate) comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let (fields, aux_vars) = generate_serialize_to_fields(quote { self }, typ, false);\n    let aux_vars_for_serialization = if aux_vars.len() > 0 {\n        let joint = aux_vars.join(quote {;});\n        quote { $joint; }\n    } else {\n        quote {}\n    };\n\n    let field_serializations = fields.join(quote {,});\n    let serialized_len = fields.len();\n    quote {\n        impl Serialize<$serialized_len> for $typ {\n            fn serialize(self) -> [Field; $serialized_len] {\n                $aux_vars_for_serialization\n                [ $field_serializations ]\n            }\n        }\n    }\n}\n\npub(crate) comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let (fields, _) = generate_serialize_to_fields(quote { self }, typ, false);\n    let serialized_len = fields.len();\n    let (deserialized, _) =\n        generate_deserialize_from_fields(quote { self }, typ, quote { serialized }, 0, false);\n    quote {\n        impl Deserialize<$serialized_len> for $typ {\n            fn deserialize(serialized: [Field; $serialized_len]) -> Self {\n                $deserialized\n            }\n        }\n    }\n}\n\n/// Generates `Packable` implementation for a given struct and returns the packed length.\n///\n/// Note: We are having this function separate from `derive_packable` because we use this in the note macros to get\n/// the packed length of a note as well as the `Packable` implementation. We need the length to be able to register\n/// the note in the global `NOTES` map. There the length is used to generate partial note helper functions.\npub comptime fn derive_packable_and_get_packed_len(s: TypeDefinition) -> (Quoted, u32) {\n    let packing_enabled = true;\n\n    let typ = s.as_type();\n    let (fields, aux_vars) = generate_serialize_to_fields(quote { self }, typ, packing_enabled);\n    let aux_vars_for_packing = if aux_vars.len() > 0 {\n        let joint = aux_vars.join(quote {;});\n        quote { $joint; }\n    } else {\n        quote {}\n    };\n\n    let (unpacked, _) =\n        generate_deserialize_from_fields(quote { self }, typ, quote { packed }, 0, packing_enabled);\n\n    let field_packings = fields.join(quote {,});\n    let packed_len = fields.len();\n    let packable_trait: TraitConstraint = quote { Packable<$packed_len> }.as_trait_constraint();\n    (\n        quote {\n        impl $packable_trait for $typ {\n            fn pack(self) -> [Field; $packed_len] {\n                $aux_vars_for_packing\n                [ $field_packings ]\n            }\n\n            fn unpack(packed: [Field; $packed_len]) -> Self {\n                $unpacked\n            }\n        }\n    },\n        packed_len,\n    )\n}\n\npub(crate) comptime fn derive_packable(s: TypeDefinition) -> Quoted {\n    let (packable_impl, _) = derive_packable_and_get_packed_len(s);\n    packable_impl\n}\n\n#[derive(Packable, Serialize, Deserialize, Eq)]\npub struct Smol {\n    a: Field,\n    b: Field,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct HasArray {\n    a: [Field; 2],\n    b: bool,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct Fancier {\n    a: Smol,\n    b: [Field; 2],\n    c: [u8; 3],\n    d: str<16>,\n}\n\nfn main() {\n    assert(false);\n}\n\n#[test]\nfn smol_test() {\n    let smol = Smol { a: 1, b: 2 };\n    let serialized = smol.serialize();\n    assert(serialized == [1, 2], serialized);\n    let deserialized = Smol::deserialize(serialized);\n    assert(deserialized == smol);\n\n    // None of the struct members implements the `Packable` trait so the packed and serialized data should be the same\n    let packed = smol.pack();\n    assert_eq(packed, serialized, \"Packed does not match serialized\");\n}\n\n#[test]\nfn has_array_test() {\n    let has_array = HasArray { a: [1, 2], b: true };\n    let serialized = has_array.serialize();\n    assert(serialized == [1, 2, 1], serialized);\n    let deserialized = HasArray::deserialize(serialized);\n    assert(deserialized == has_array);\n}\n\n#[test]\nfn fancier_test() {\n    let fancier =\n        Fancier { a: Smol { a: 1, b: 2 }, b: [0, 1], c: [1, 2, 3], d: \"metaprogramming!\" };\n    let serialized = fancier.serialize();\n    assert(\n        serialized\n            == [\n                1, 2, 0, 1, 1, 2, 3, 0x6d, 0x65, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61,\n                0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x21,\n            ],\n        serialized,\n    );\n    let deserialized = Fancier::deserialize(serialized);\n    assert(deserialized == fancier);\n}\n"
     },
     "296": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
@@ -2757,7 +2757,7 @@
     },
     "305": {
       "path": "/home/aztec-dev/aztec-packages/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, ToField},\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"
+      "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"
     },
     "309": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/shared_mutable/scheduled_delay_change.nr",
@@ -2809,7 +2809,7 @@
     },
     "60": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/public_context.nr",
-      "source": "use crate::context::gas::GasOpts;\nuse crate::hash::{\n    compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n};\nuse dep::protocol_types::abis::function_selector::FunctionSelector;\nuse dep::protocol_types::address::{AztecAddress, EthAddress};\nuse dep::protocol_types::constants::MAX_FIELD_VALUE;\nuse dep::protocol_types::traits::{Empty, FromField, Packable, Serialize, ToField};\n\npub struct PublicContext {\n    pub args_hash: Option<Field>,\n    pub compute_args_hash: fn() -> Field,\n}\n\nimpl PublicContext {\n    pub fn new(compute_args_hash: fn() -> Field) -> Self {\n        PublicContext { args_hash: Option::none(), compute_args_hash }\n    }\n\n    pub fn emit_public_log<T, let N: u32>(_self: &mut Self, log: T)\n    where\n        T: Serialize<N>,\n    {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_public_log(Serialize::serialize(log).as_slice()) };\n    }\n\n    pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { note_hash_exists(note_hash, leaf_index) } == 1\n    }\n\n    pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { l1_to_l2_msg_exists(msg_hash, msg_leaf_index) } == 1\n    }\n\n    pub fn nullifier_exists(_self: Self, unsiloed_nullifier: Field, address: AztecAddress) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { nullifier_exists(unsiloed_nullifier, address.to_field()) } == 1\n    }\n\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        let secret_hash = compute_secret_hash(secret);\n        let message_hash = compute_l1_to_l2_message_hash(\n            sender,\n            self.chain_id(),\n            /*recipient=*/\n            self.this_address(),\n            self.version(),\n            content,\n            secret_hash,\n            leaf_index,\n        );\n        let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n        assert(\n            !self.nullifier_exists(nullifier, self.this_address()),\n            \"L1-to-L2 message is already nullified\",\n        );\n        assert(\n            self.l1_to_l2_msg_exists(message_hash, leaf_index),\n            \"Tried to consume nonexistent L1-to-L2 message\",\n        );\n\n        self.push_nullifier(nullifier);\n    }\n\n    pub fn message_portal(_self: &mut Self, recipient: EthAddress, content: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { send_l2_to_l1_msg(recipient, content) };\n    }\n\n    pub unconstrained fn call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let calldata = args.push_front(function_selector.to_field());\n\n        call(gas_for_call(gas_opts), contract_address, calldata);\n        // Use success_copy to determine whether the call succeeded\n        let success = success_copy();\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub unconstrained fn static_call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let calldata = args.push_front(function_selector.to_field());\n\n        call_static(gas_for_call(gas_opts), contract_address, calldata);\n        // Use success_copy to determine whether the call succeeded\n        let success = success_copy();\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub fn push_note_hash(_self: &mut Self, note_hash: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_note_hash(note_hash) };\n    }\n    pub fn push_nullifier(_self: &mut Self, nullifier: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_nullifier(nullifier) };\n    }\n\n    pub fn this_address(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            address()\n        }\n    }\n    pub fn msg_sender(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            sender()\n        }\n    }\n    pub fn selector(_self: Self) -> FunctionSelector {\n        // The selector is the first element of the calldata when calling a public function through dispatch.\n        // Safety: AVM opcodes are constrained by the AVM itself\n        let raw_selector: [Field; 1] = unsafe { calldata_copy(0, 1) };\n        FunctionSelector::from_field(raw_selector[0])\n    }\n    pub fn get_args_hash(mut self) -> Field {\n        if !self.args_hash.is_some() {\n            self.args_hash = Option::some((self.compute_args_hash)());\n        }\n\n        self.args_hash.unwrap_unchecked()\n    }\n    pub fn transaction_fee(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            transaction_fee()\n        }\n    }\n\n    pub fn chain_id(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            chain_id()\n        }\n    }\n    pub fn version(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            version()\n        }\n    }\n    pub fn block_number(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            block_number()\n        }\n    }\n    pub fn timestamp(_self: Self) -> u64 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            timestamp()\n        }\n    }\n    pub fn fee_per_l2_gas(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_l2_gas()\n        }\n    }\n    pub fn fee_per_da_gas(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_da_gas()\n        }\n    }\n\n    pub fn l2_gas_left(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            l2_gas_left()\n        }\n    }\n    pub fn da_gas_left(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            da_gas_left()\n        }\n    }\n    pub fn is_static_call(_self: Self) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { is_static_call() } == 1\n    }\n\n    pub fn raw_storage_read<let N: u32>(_self: Self, storage_slot: Field) -> [Field; N] {\n        let mut out = [0; N];\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            out[i] = unsafe { storage_read(storage_slot + i as Field) };\n        }\n        out\n    }\n\n    pub fn storage_read<T, let N: u32>(self, storage_slot: Field) -> T\n    where\n        T: Packable<N>,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n\n    pub fn raw_storage_write<let N: u32>(_self: Self, storage_slot: Field, values: [Field; N]) {\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            unsafe { storage_write(storage_slot + i as Field, values[i]) };\n        }\n    }\n\n    pub fn storage_write<T, let N: u32>(self, storage_slot: Field, value: T)\n    where\n        T: Packable<N>,\n    {\n        self.raw_storage_write(storage_slot, value.pack());\n    }\n}\n\n// Helper functions\nfn gas_for_call(user_gas: GasOpts) -> [Field; 2] {\n    // It's ok to use the max possible gas here, because the gas will be\n    // capped by the gas left in the (STATIC)CALL instruction.\n    [user_gas.l2_gas.unwrap_or(MAX_FIELD_VALUE), user_gas.da_gas.unwrap_or(MAX_FIELD_VALUE)]\n}\n\n// Unconstrained opcode wrappers (do not use directly).\nunconstrained fn address() -> AztecAddress {\n    address_opcode()\n}\nunconstrained fn sender() -> AztecAddress {\n    sender_opcode()\n}\nunconstrained fn transaction_fee() -> Field {\n    transaction_fee_opcode()\n}\nunconstrained fn chain_id() -> Field {\n    chain_id_opcode()\n}\nunconstrained fn version() -> Field {\n    version_opcode()\n}\nunconstrained fn block_number() -> Field {\n    block_number_opcode()\n}\nunconstrained fn timestamp() -> u64 {\n    timestamp_opcode()\n}\nunconstrained fn fee_per_l2_gas() -> Field {\n    fee_per_l2_gas_opcode()\n}\nunconstrained fn fee_per_da_gas() -> Field {\n    fee_per_da_gas_opcode()\n}\nunconstrained fn l2_gas_left() -> Field {\n    l2_gas_left_opcode()\n}\nunconstrained fn da_gas_left() -> Field {\n    da_gas_left_opcode()\n}\nunconstrained fn is_static_call() -> Field {\n    is_static_call_opcode()\n}\nunconstrained fn note_hash_exists(note_hash: Field, leaf_index: Field) -> u1 {\n    note_hash_exists_opcode(note_hash, leaf_index)\n}\nunconstrained fn emit_note_hash(note_hash: Field) {\n    emit_note_hash_opcode(note_hash)\n}\nunconstrained fn nullifier_exists(nullifier: Field, address: Field) -> u1 {\n    nullifier_exists_opcode(nullifier, address)\n}\nunconstrained fn emit_nullifier(nullifier: Field) {\n    emit_nullifier_opcode(nullifier)\n}\nunconstrained fn emit_public_log(message: [Field]) {\n    emit_public_log_opcode(message)\n}\nunconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: Field) -> u1 {\n    l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\nunconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n    send_l2_to_l1_msg_opcode(recipient, content)\n}\nunconstrained fn call(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n    call_opcode(gas, address, args)\n}\n\nunconstrained fn call_static(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n    call_static_opcode(gas, address, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n    calldata_copy_opcode(cdoffset, copy_size)\n}\n\n// `success_copy` is placed immediately after the CALL opcode to get the success value\nunconstrained fn success_copy() -> bool {\n    success_copy_opcode()\n}\n\nunconstrained fn returndata_size() -> u32 {\n    returndata_size_opcode()\n}\n\nunconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n    returndata_copy_opcode(rdoffset, copy_size)\n}\n\npub unconstrained fn avm_return(returndata: [Field]) {\n    return_opcode(returndata)\n}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\nunconstrained fn avm_revert(revertdata: [Field]) {\n    revert_opcode(revertdata)\n}\n\nunconstrained fn storage_read(storage_slot: Field) -> Field {\n    storage_read_opcode(storage_slot)\n}\n\nunconstrained fn storage_write(storage_slot: Field, value: Field) {\n    storage_write_opcode(storage_slot, value);\n}\n\nimpl Empty for PublicContext {\n    fn empty() -> Self {\n        PublicContext::new(|| 0)\n    }\n}\n\n// AVM oracles (opcodes) follow, do not use directly.\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> Field {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeFeePerL2Gas)]\nunconstrained fn fee_per_l2_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeFeePerDaGas)]\nunconstrained fn fee_per_da_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> Field {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(nullifier: Field, address: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n// TODO(#11124): rename unencrypted to public in avm\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) {}\n\n#[oracle(avmOpcodeSuccessCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(avmOpcodeStorageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field) -> Field {}\n\n#[oracle(avmOpcodeStorageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
+      "source": "use crate::context::gas::GasOpts;\nuse crate::hash::{\n    compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n};\nuse dep::protocol_types::abis::function_selector::FunctionSelector;\nuse dep::protocol_types::address::{AztecAddress, EthAddress};\nuse dep::protocol_types::constants::MAX_FIELD_VALUE;\nuse dep::protocol_types::traits::{Empty, FromField, Packable, Serialize, ToField};\n\npub struct PublicContext {\n    pub args_hash: Option<Field>,\n    pub compute_args_hash: fn() -> Field,\n}\n\nimpl PublicContext {\n    pub fn new(compute_args_hash: fn() -> Field) -> Self {\n        PublicContext { args_hash: Option::none(), compute_args_hash }\n    }\n\n    pub fn emit_public_log<T, let N: u32>(_self: &mut Self, log: T)\n    where\n        T: Serialize<N>,\n    {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_public_log(Serialize::serialize(log).as_slice()) };\n    }\n\n    pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { note_hash_exists(note_hash, leaf_index) } == 1\n    }\n\n    pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { l1_to_l2_msg_exists(msg_hash, msg_leaf_index) } == 1\n    }\n\n    pub fn nullifier_exists(_self: Self, unsiloed_nullifier: Field, address: AztecAddress) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { nullifier_exists(unsiloed_nullifier, address.to_field()) } == 1\n    }\n\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        let secret_hash = compute_secret_hash(secret);\n        let message_hash = compute_l1_to_l2_message_hash(\n            sender,\n            self.chain_id(),\n            /*recipient=*/\n            self.this_address(),\n            self.version(),\n            content,\n            secret_hash,\n            leaf_index,\n        );\n        let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n        assert(\n            !self.nullifier_exists(nullifier, self.this_address()),\n            \"L1-to-L2 message is already nullified\",\n        );\n        assert(\n            self.l1_to_l2_msg_exists(message_hash, leaf_index),\n            \"Tried to consume nonexistent L1-to-L2 message\",\n        );\n\n        self.push_nullifier(nullifier);\n    }\n\n    pub fn message_portal(_self: &mut Self, recipient: EthAddress, content: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { send_l2_to_l1_msg(recipient, content) };\n    }\n\n    pub unconstrained fn call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let calldata = args.push_front(function_selector.to_field());\n\n        call(\n            gas_opts.l2_gas.unwrap_or(MAX_FIELD_VALUE),\n            gas_opts.da_gas.unwrap_or(MAX_FIELD_VALUE),\n            contract_address,\n            calldata,\n        );\n        // Use success_copy to determine whether the call succeeded\n        let success = success_copy();\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub unconstrained fn static_call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let calldata = args.push_front(function_selector.to_field());\n\n        call_static(\n            gas_opts.l2_gas.unwrap_or(MAX_FIELD_VALUE),\n            gas_opts.da_gas.unwrap_or(MAX_FIELD_VALUE),\n            contract_address,\n            calldata,\n        );\n        // Use success_copy to determine whether the call succeeded\n        let success = success_copy();\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub fn push_note_hash(_self: &mut Self, note_hash: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_note_hash(note_hash) };\n    }\n    pub fn push_nullifier(_self: &mut Self, nullifier: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_nullifier(nullifier) };\n    }\n\n    pub fn this_address(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            address()\n        }\n    }\n    pub fn msg_sender(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            sender()\n        }\n    }\n    pub fn selector(_self: Self) -> FunctionSelector {\n        // The selector is the first element of the calldata when calling a public function through dispatch.\n        // Safety: AVM opcodes are constrained by the AVM itself\n        let raw_selector: [Field; 1] = unsafe { calldata_copy(0, 1) };\n        FunctionSelector::from_field(raw_selector[0])\n    }\n    pub fn get_args_hash(mut self) -> Field {\n        if !self.args_hash.is_some() {\n            self.args_hash = Option::some((self.compute_args_hash)());\n        }\n\n        self.args_hash.unwrap_unchecked()\n    }\n    pub fn transaction_fee(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            transaction_fee()\n        }\n    }\n\n    pub fn chain_id(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            chain_id()\n        }\n    }\n    pub fn version(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            version()\n        }\n    }\n    pub fn block_number(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            block_number()\n        }\n    }\n    pub fn timestamp(_self: Self) -> u64 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            timestamp()\n        }\n    }\n    pub fn fee_per_l2_gas(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_l2_gas()\n        }\n    }\n    pub fn fee_per_da_gas(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_da_gas()\n        }\n    }\n\n    pub fn l2_gas_left(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            l2_gas_left()\n        }\n    }\n    pub fn da_gas_left(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            da_gas_left()\n        }\n    }\n    pub fn is_static_call(_self: Self) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { is_static_call() } == 1\n    }\n\n    pub fn raw_storage_read<let N: u32>(_self: Self, storage_slot: Field) -> [Field; N] {\n        let mut out = [0; N];\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            out[i] = unsafe { storage_read(storage_slot + i as Field) };\n        }\n        out\n    }\n\n    pub fn storage_read<T, let N: u32>(self, storage_slot: Field) -> T\n    where\n        T: Packable<N>,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n\n    pub fn raw_storage_write<let N: u32>(_self: Self, storage_slot: Field, values: [Field; N]) {\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            unsafe { storage_write(storage_slot + i as Field, values[i]) };\n        }\n    }\n\n    pub fn storage_write<T, let N: u32>(self, storage_slot: Field, value: T)\n    where\n        T: Packable<N>,\n    {\n        self.raw_storage_write(storage_slot, value.pack());\n    }\n}\n\n// Unconstrained opcode wrappers (do not use directly).\nunconstrained fn address() -> AztecAddress {\n    address_opcode()\n}\nunconstrained fn sender() -> AztecAddress {\n    sender_opcode()\n}\nunconstrained fn transaction_fee() -> Field {\n    transaction_fee_opcode()\n}\nunconstrained fn chain_id() -> Field {\n    chain_id_opcode()\n}\nunconstrained fn version() -> Field {\n    version_opcode()\n}\nunconstrained fn block_number() -> Field {\n    block_number_opcode()\n}\nunconstrained fn timestamp() -> u64 {\n    timestamp_opcode()\n}\nunconstrained fn fee_per_l2_gas() -> Field {\n    fee_per_l2_gas_opcode()\n}\nunconstrained fn fee_per_da_gas() -> Field {\n    fee_per_da_gas_opcode()\n}\nunconstrained fn l2_gas_left() -> Field {\n    l2_gas_left_opcode()\n}\nunconstrained fn da_gas_left() -> Field {\n    da_gas_left_opcode()\n}\nunconstrained fn is_static_call() -> Field {\n    is_static_call_opcode()\n}\nunconstrained fn note_hash_exists(note_hash: Field, leaf_index: Field) -> u1 {\n    note_hash_exists_opcode(note_hash, leaf_index)\n}\nunconstrained fn emit_note_hash(note_hash: Field) {\n    emit_note_hash_opcode(note_hash)\n}\nunconstrained fn nullifier_exists(nullifier: Field, address: Field) -> u1 {\n    nullifier_exists_opcode(nullifier, address)\n}\nunconstrained fn emit_nullifier(nullifier: Field) {\n    emit_nullifier_opcode(nullifier)\n}\nunconstrained fn emit_public_log(message: [Field]) {\n    emit_public_log_opcode(message)\n}\nunconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: Field) -> u1 {\n    l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\nunconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n    send_l2_to_l1_msg_opcode(recipient, content)\n}\nunconstrained fn call(\n    l2_gas_allocation: Field,\n    da_gas_allocation: Field,\n    address: AztecAddress,\n    args: [Field],\n) {\n    call_opcode(l2_gas_allocation, da_gas_allocation, address, args)\n}\n\nunconstrained fn call_static(\n    l2_gas_allocation: Field,\n    da_gas_allocation: Field,\n    address: AztecAddress,\n    args: [Field],\n) {\n    call_static_opcode(l2_gas_allocation, da_gas_allocation, address, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n    calldata_copy_opcode(cdoffset, copy_size)\n}\n\n// `success_copy` is placed immediately after the CALL opcode to get the success value\nunconstrained fn success_copy() -> bool {\n    success_copy_opcode()\n}\n\nunconstrained fn returndata_size() -> u32 {\n    returndata_size_opcode()\n}\n\nunconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n    returndata_copy_opcode(rdoffset, copy_size)\n}\n\npub unconstrained fn avm_return(returndata: [Field]) {\n    return_opcode(returndata)\n}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\nunconstrained fn avm_revert(revertdata: [Field]) {\n    revert_opcode(revertdata)\n}\n\nunconstrained fn storage_read(storage_slot: Field) -> Field {\n    storage_read_opcode(storage_slot)\n}\n\nunconstrained fn storage_write(storage_slot: Field, value: Field) {\n    storage_write_opcode(storage_slot, value);\n}\n\nimpl Empty for PublicContext {\n    fn empty() -> Self {\n        PublicContext::new(|| 0)\n    }\n}\n\n// AVM oracles (opcodes) follow, do not use directly.\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> Field {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeFeePerL2Gas)]\nunconstrained fn fee_per_l2_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeFeePerDaGas)]\nunconstrained fn fee_per_da_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> Field {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(nullifier: Field, address: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n// TODO(#11124): rename unencrypted to public in avm\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode(\n    l2_gas_allocation: Field,\n    da_gas_allocation: Field,\n    address: AztecAddress,\n    args: [Field],\n) {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n    l2_gas_allocation: Field,\n    da_gas_allocation: Field,\n    address: AztecAddress,\n    args: [Field],\n) {}\n\n#[oracle(avmOpcodeSuccessCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(avmOpcodeStorageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field) -> Field {}\n\n#[oracle(avmOpcodeStorageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
     },
     "61": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/returns_hash.nr",
@@ -2833,7 +2833,7 @@
     },
     "95": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr",
-      "source": "use crate::macros::{\n    functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n    notes::NOTES,\n    utils::{\n        add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_contract_library_method,\n        is_fn_initializer, is_fn_internal, is_fn_private, is_fn_public, is_fn_test, is_fn_utility,\n        is_fn_view, modify_fn_body, module_has_initializer, module_has_storage,\n    },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n    // Private Kernel Circuit.\n    // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n    // about the execution context (e.g. the caller).\n    let original_params = f.parameters();\n    f.set_parameters(&[(\n        quote { inputs },\n        quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n    )]\n        .append(original_params));\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    // TODO: Optimize args_hasher for small number of arguments\n    let args_hasher_name = quote { args_hasher };\n    let args_hasher = original_params.fold(\n        quote {\n            let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n        },\n        |args_hasher, param: (Quoted, Type)| {\n            let (name, typ) = param;\n            let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n            quote {\n                $args_hasher\n                $appended_arg\n            }\n        },\n    );\n\n    let context_creation = quote {\n        let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    // All private functions perform message discovery, since they may need to access notes. This is slightly\n    // inefficient and could be improved by only doing it once we actually attempt to read any.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n    // circuit expects.\n    let return_value_var_name = quote { macro__returned__values };\n\n    let return_value_type = f.return_type();\n    let return_value = if body.len() == 0 {\n        quote {}\n    } else if return_value_type != type_of(()) {\n        // The original return value is passed to a second args hasher which the context receives.\n        let (body_without_return, last_body_expr) = body.pop_back();\n        let return_value = last_body_expr.quoted();\n        let return_value_assignment =\n            quote { let $return_value_var_name: $return_value_type = $return_value; };\n        let return_hasher_name = quote { return_hasher };\n        let return_value_into_hasher =\n            add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n        body = body_without_return;\n\n        quote {\n            let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n            $return_value_assignment\n            $return_value_into_hasher\n            context.set_return_hash($return_hasher_name);\n        }\n    } else {\n        let (body_without_return, last_body_expr) = body.pop_back();\n        if !last_body_expr.has_semicolon()\n            & last_body_expr.as_for().is_none()\n            & last_body_expr.as_assert().is_none()\n            & last_body_expr.as_for_range().is_none()\n            & last_body_expr.as_assert_eq().is_none()\n            & last_body_expr.as_let().is_none() {\n            let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n            body = body_without_return.push_back(\n                quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n            );\n        }\n        quote {}\n    };\n\n    let context_finish = quote { context.finish() };\n\n    let to_prepend = quote {\n        $args_hasher\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n        $message_discovery_call\n    };\n\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $context_finish\n    };\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n    f.set_return_type(\n        quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n            .as_type(),\n    );\n    f.set_return_data();\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Public functions undergo a lot of transformations from their Aztec.nr form.\n    let original_params = f.parameters();\n    let args_len = original_params\n        .map(|(name, typ): (Quoted, Type)| {\n            generate_serialize_to_fields(name, typ, &[], false).0.len()\n        })\n        .fold(0, |acc: u32, val: u32| acc + val);\n\n    // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n    let context_creation = quote {\n        let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n        // We start from 1 because we skip the selector for the dispatch function.\n        let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n        dep::aztec::hash::hash_args_array(serialized_args)\n        });\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n        // referenced. We instead ignore 'unused variable' warnings for it.\n        quote {\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n    };\n\n    let to_append = quote {\n        $mark_as_initialized\n    };\n\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n\n    // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n    // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n    // bytecode.\n    f.set_unconstrained(true);\n    f.set_return_public(true);\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_utility(f: FunctionDefinition) {\n    // Check if function is marked as unconstrained\n    if !f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[utility] but not marked as unconstrained, add unconstrained keyword\",\n        );\n    }\n\n    // Create utility context\n    let context_creation =\n        quote { let mut context = dep::aztec::context::utility_context::UtilityContext::new(); };\n    let module_has_storage = module_has_storage(f.module());\n\n    // Initialize Storage if module has storage\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(context);\n        }\n    } else {\n        quote {}\n    };\n\n    // All utility functions perform message discovery, since they may need to access private notes that would be\n    // found during this process. This is slightly inefficient and could be improved by only doing it once we actually\n    // attempt to read any.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Inject context creation, storage initialization, and message discovery call at the beginning of the function\n    // body.\n    let to_prepend = quote {\n        $context_creation\n        $storage_init\n        $message_discovery_call\n    };\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, quote {});\n    f.set_body(modified_body);\n\n    f.set_return_public(true);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called internally\";\n    quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called statically\";\n    if is_fn_private(f) {\n        // Here `context` is of type context::PrivateContext\n        quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n    } else {\n        // Here `context` is of type context::PublicContext\n        quote { assert(context.is_static_call(), $assertion_message); }\n    }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\n/// Injects a call to `aztec::messages::discovery::discover_new_messages`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_message_discovery_call() -> Quoted {\n    quote {\n        /// Safety: message discovery returns nothing and is performed solely for its side-effects. It is therefore\n        /// always safe to call.\n        unsafe {\n            dep::aztec::messages::discovery::discover_new_messages(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\n            );\n        };\n    }\n}\n\n/// Checks if each function in the module is marked with either #[private], #[public], #[utility],\n/// #[contract_library_method], or #[test]. Non-macroified functions are not allowed in contracts.\npub(crate) comptime fn check_each_fn_macroified(m: Module) {\n    for f in m.functions() {\n        let name = f.name();\n        if !is_fn_private(f)\n            & !is_fn_public(f)\n            & !is_fn_utility(f)\n            & !is_fn_contract_library_method(f)\n            & !is_fn_test(f) {\n            panic(\n                f\"Function {name} must be marked as either #[private], #[public], #[utility], #[contract_library_method], or #[test]\",\n            );\n        }\n    }\n}\n"
+      "source": "use crate::macros::{\n    functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n    notes::NOTES,\n    utils::{\n        add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_contract_library_method,\n        is_fn_initializer, is_fn_internal, is_fn_private, is_fn_public, is_fn_test, is_fn_utility,\n        is_fn_view, modify_fn_body, module_has_initializer, module_has_storage,\n    },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n    // Private Kernel Circuit.\n    // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n    // about the execution context (e.g. the caller).\n    let original_params = f.parameters();\n    f.set_parameters(&[(\n        quote { inputs },\n        quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n    )]\n        .append(original_params));\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    // TODO: Optimize args_hasher for small number of arguments\n    let args_hasher_name = quote { args_hasher };\n    let args_hasher = original_params.fold(\n        quote {\n            let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n        },\n        |args_hasher, param: (Quoted, Type)| {\n            let (name, typ) = param;\n            let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n            quote {\n                $args_hasher\n                $appended_arg\n            }\n        },\n    );\n\n    let context_creation = quote {\n        let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    // All private functions perform message discovery, since they may need to access notes. This is slightly\n    // inefficient and could be improved by only doing it once we actually attempt to read any.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n    // circuit expects.\n    let return_value_var_name = quote { macro__returned__values };\n\n    let return_value_type = f.return_type();\n    let return_value = if body.len() == 0 {\n        quote {}\n    } else if return_value_type != type_of(()) {\n        // The original return value is passed to a second args hasher which the context receives.\n        let (body_without_return, last_body_expr) = body.pop_back();\n        let return_value = last_body_expr.quoted();\n        let return_value_assignment =\n            quote { let $return_value_var_name: $return_value_type = $return_value; };\n        let return_hasher_name = quote { return_hasher };\n        let return_value_into_hasher =\n            add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n        body = body_without_return;\n\n        quote {\n            let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n            $return_value_assignment\n            $return_value_into_hasher\n            context.set_return_hash($return_hasher_name);\n        }\n    } else {\n        let (body_without_return, last_body_expr) = body.pop_back();\n        if !last_body_expr.has_semicolon()\n            & last_body_expr.as_for().is_none()\n            & last_body_expr.as_assert().is_none()\n            & last_body_expr.as_for_range().is_none()\n            & last_body_expr.as_assert_eq().is_none()\n            & last_body_expr.as_let().is_none() {\n            let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n            body = body_without_return.push_back(\n                quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n            );\n        }\n        quote {}\n    };\n\n    let context_finish = quote { context.finish() };\n\n    let to_prepend = quote {\n        $args_hasher\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n        $message_discovery_call\n    };\n\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $context_finish\n    };\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n    f.set_return_type(\n        quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n            .as_type(),\n    );\n    f.set_return_data();\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Public functions undergo a lot of transformations from their Aztec.nr form.\n    let original_params = f.parameters();\n    let args_len = original_params\n        .map(|(name, typ): (Quoted, Type)| {\n            generate_serialize_to_fields(name, typ, false).0.len()\n        })\n        .fold(0, |acc: u32, val: u32| acc + val);\n\n    // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n    let context_creation = quote {\n        let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n        // We start from 1 because we skip the selector for the dispatch function.\n        let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n        dep::aztec::hash::hash_args_array(serialized_args)\n        });\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n        // referenced. We instead ignore 'unused variable' warnings for it.\n        quote {\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n    };\n\n    let to_append = quote {\n        $mark_as_initialized\n    };\n\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n\n    // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n    // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n    // bytecode.\n    f.set_unconstrained(true);\n    f.set_return_public(true);\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_utility(f: FunctionDefinition) {\n    // Check if function is marked as unconstrained\n    if !f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[utility] but not marked as unconstrained, add unconstrained keyword\",\n        );\n    }\n\n    // Create utility context\n    let context_creation =\n        quote { let mut context = dep::aztec::context::utility_context::UtilityContext::new(); };\n    let module_has_storage = module_has_storage(f.module());\n\n    // Initialize Storage if module has storage\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(context);\n        }\n    } else {\n        quote {}\n    };\n\n    // All utility functions perform message discovery, since they may need to access private notes that would be\n    // found during this process. This is slightly inefficient and could be improved by only doing it once we actually\n    // attempt to read any.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Inject context creation, storage initialization, and message discovery call at the beginning of the function\n    // body.\n    let to_prepend = quote {\n        $context_creation\n        $storage_init\n        $message_discovery_call\n    };\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, quote {});\n    f.set_body(modified_body);\n\n    f.set_return_public(true);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called internally\";\n    quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called statically\";\n    if is_fn_private(f) {\n        // Here `context` is of type context::PrivateContext\n        quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n    } else {\n        // Here `context` is of type context::PublicContext\n        quote { assert(context.is_static_call(), $assertion_message); }\n    }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\n/// Injects a call to `aztec::messages::discovery::discover_new_messages`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_message_discovery_call() -> Quoted {\n    quote {\n        /// Safety: message discovery returns nothing and is performed solely for its side-effects. It is therefore\n        /// always safe to call.\n        unsafe {\n            dep::aztec::messages::discovery::discover_new_messages(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\n            );\n        };\n    }\n}\n\n/// Checks if each function in the module is marked with either #[private], #[public], #[utility],\n/// #[contract_library_method], or #[test]. Non-macroified functions are not allowed in contracts.\npub(crate) comptime fn check_each_fn_macroified(m: Module) {\n    for f in m.functions() {\n        let name = f.name();\n        if !is_fn_private(f)\n            & !is_fn_public(f)\n            & !is_fn_utility(f)\n            & !is_fn_contract_library_method(f)\n            & !is_fn_test(f) {\n            panic(\n                f\"Function {name} must be marked as either #[private], #[public], #[utility], #[contract_library_method], or #[test]\",\n            );\n        }\n    }\n}\n"
     },
     "98": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/storage.nr",