@aztec/protocol-contracts 0.83.1 → 0.84.0

package/artifacts/ContractInstanceDeployer.json

@@ -4,130 +4,11 @@
   "name": "ContractInstanceDeployer",
   "functions": [
     {
-      "name": "get_update_delay",
+      "name": "sync_notes",
       "is_unconstrained": true,
       "custom_attributes": [
-        "public",
-        "view"
+        "aztec::macros::functions::utility"
       ],
-      "abi": {
-        "parameters": [],
-        "return_type": {
-          "abi_type": {
-            "kind": "integer",
-            "sign": "unsigned",
-            "width": 32
-          },
-          "visibility": "public"
-        },
-        "error_types": {
-          "206160798890201757": {
-            "error_kind": "string",
-            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "11343565365413149907": {
-            "error_kind": "string",
-            "string": "Function get_update_delay can only be called statically"
-          },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        }
-      },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "get_update_delay"
-      ]
-    },
-    {
-      "name": "public_dispatch",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public"
-      ],
-      "abi": {
-        "parameters": [
-          {
-            "name": "selector",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": null,
-        "error_types": {
-          "206160798890201757": {
-            "error_kind": "string",
-            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
-          },
-          "2830029349304997821": {
-            "error_kind": "fmtstring",
-            "length": 27,
-            "item_types": [
-              {
-                "kind": "field"
-              }
-            ]
-          },
-          "2920182694213909827": {
-            "error_kind": "string",
-            "string": "attempt to subtract with overflow"
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "6504213605561840204": {
-            "error_kind": "string",
-            "string": "New contract class is not registered"
-          },
-          "10019982601749771606": {
-            "error_kind": "string",
-            "string": "msg.sender is not deployed"
-          },
-          "11343565365413149907": {
-            "error_kind": "string",
-            "string": "Function get_update_delay can only be called statically"
-          },
-          "15573886522241766899": {
-            "error_kind": "string",
-            "string": "New update delay is too low"
-          },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
-          "17595253152434889169": {
-            "error_kind": "string",
-            "string": "offset too large"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        }
-      },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "public_dispatch"
-      ]
-    },
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [],
       "abi": {
         "parameters": [],
         "return_type": null,
@@ -285,12 +166,118 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "sync_notes"
       ]
     },
+    {
+      "name": "get_update_delay",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public",
+        "view"
+      ],
+      "abi": {
+        "parameters": [],
+        "return_type": {
+          "abi_type": {
+            "kind": "integer",
+            "sign": "unsigned",
+            "width": 32
+          },
+          "visibility": "public"
+        },
+        "error_types": {
+          "206160798890201757": {
+            "error_kind": "string",
+            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "11343565365413149907": {
+            "error_kind": "string",
+            "string": "Function get_update_delay can only be called statically"
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        }
+      },
+      "bytecode": "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",
+      "debug_symbols": "7Z3dTt04EMff5VyfC3vs8QevslohoLQ60hFUQFdaVX33TeDYCdhKiMfdOvLcIAKezD+/TDJjx3F+Hr7c3/74dn16+Pr4fLj66+fh/Hh383J6fBi2fv46Hm6fTufz6dv1/M8HMf6Q0rwaPH+/eRi3n19unl4OV9Y6ezzcP3w5XDkp7bCLr6fz/eFKSv/r7+NBgiiywhIrVeRL6SIrV2KlVZFVkS+EIquis2xkkVWRL5s9y0PIgLyYDb9r9c7umHqRwl+a26F9bG10prEHA5fGHty7xq+K8DOKMDkSJwrtCv15VWiXjT/jRTAzfmR8scIcQe2UvjTWTsMyboc24Hbo7AfcILKHYVw0GpSJZTlSGBUOWcpZrBiRa+1MaOxdbKvkRY5tSo6EtuS0RQfaogNt0VGyLTnYlBwt2pKj/285GOSAgHdyMunVawzp1ftpz2BtprWKe9YwSYbcjkH6kEhguNctN0YI+0Ww86av/Bzzo/BDxfxI/Dj+SPwMxx+NH8cfiZ8F5kfiZ5gfhZ+TzI/ED5kfhZ8XzI/ETzO/NX5GBH5GJvy4fqHwU4LrZxo/y/zW+MW25n3TkR/w9Uvip7j/QePH1y+Jn+b4o/Hj+CPxQ44/Gj8efyHxM9z/pfHj8RcaP8/8KPysZn4kftx/I/FzPP5C48f1cwrF80OhDBSudBMoWnD5moGiGUoKhQvNFIrk7J2Bwik5hQI8TpWBwik5haI4JWeg8DBRBgqn5BSK5pScgcKjNCkU1AwlhcKRkkLhlwwyUDoduQQ1QZm9Jf0GBUWfI29WhtfowSpV3PiVYJ+V3haC0kzHZ9zHKYko++xA1CTYZxKsSBD6TA41CfY5iraJoLXx1Xjrk1zc6dTYmgT7HJ+rSFBzLqYS1EyQSJCrGSLBTicZ1yTI1QyRoOEYpBLkaoZI0HI1QyWomSCRIFczRIKOMwmVIGcSIsFOlw2pSZCfk1AJ9jl9ZhNBLwMM6eEjQdPp4hcVCcoKz4ulc8HD/Il0nuDQEw+th4cOE0MJkFWPGNXbWWsr3+SbXcuHfdMHv2v5ar0vpFfkK6fCpajcuIr8zEXa2ggXBBnhp7Xq88vPOxWO1Tl81/hVvK8r3qqEj9a/38XvPwqscRQu5AjlBa6cZZytt4YoV1pbdGE+jzVi5QsQVkUhVgMsNx6y2VR+SC2SEPrE0gG1ybhpJStYu1pAxn2D9GaWbd9O7Cfe3G9Zvm2c/qA/yAfEVH7j9EHaKN/4RP4nJg/+UfkqftUERsmJfLdr+X7f9H3r9AGjfExi34rW6UOc4apmCT3I/0SX5Y/K1yIIAS0z8s2u5cO+6UPr9CGmLY0uka9apx9LX9BWpvJ94/J9rHlQpPSrdIj+oPx908fG6SPEO8+82xflN05/+vweoEnqfWts4/J97G0ZoRP5n/hMRtPy903fNU7fTH1do9M7j2ucvpn6usakdx7feFfduEm+tx/lO9H4QMma/H3Tl43TX77zOKn3Tb/xomFFPuybPrReMC/2dZ1qfJxnud53qvFRthX5et/0dWX6s09z5wUNz0iCfBBiFs3CjoK87nO+kRJmGorW88YjFOxzGtsKFI6UFEqnS4isQOlzLvcyFMuRkoHCkZJC6XQiP/hYdiuBy42liHM1h0N1CcE+J/JXJNjpRP5NBKWajg9lQrDPcqkeQSk6/YhlVYR9JtiaCCWn43WEJk4Jl84lCBVfyKsItQjjNMOvaRR2+kHLmgh1n4s4VkXIRQ0ZYZ+vJ25CiBCPD1EkCDtd4bkqQo5CKkLDGZmK0HJpTUbIHTwqQsdFDRUhDxfSEfKYNRGh7HSV/qoIOQqpCDtdp38bwghDoocUIRc1VISdrtRfE6HidEJGyOmEirDTpearItSMkIqQMzIVYadrpW9CqKZV9ZRKnp3IThdLr4qQMzIVYafLpVdFyBmZjJAzMhUhT7SmI+SihorQcxSSEXJRQ0QIgosaMkLNCKkIuahZR6htRGiSx08gOQqpCIEH/skIOSNTEXb6neOqCLl3QkXIM/7pCHmuNfGlCUCezUBGyPdCKsJOF3upiZBn/H9AOFJRRueo2PgFHqtVYpOfte51cOQx9eP8dpv8RyVWbOxmG52fvLu8TMVgZUqs8lM0V62wxAqKfEGRL1XkSxX50kW+dNH5wiJfWHRc+Tfj1qzyqWHVypZY2aIrxZrN9xjtsty9CB8S8ZCx2X5fwvxVvOgHpSiw0QU2brsNwHYGsP2eiarAT/66XbEpOKdY4AdL/ORzGoa4nn+iMNjk8+2KTYGf/Pryyzb5h9IrNgV+fIGf/HO22flJbUw+ry+eUyPMdhtZ4Edur4dMfvHlZRslCmy23w+MhgIbt90GVYFNgR9TcDymIHZswfmxG+Pg17D1z83T6eb2fP88WIz//PFw93J6fLhsvvz7Pfzn9ul0Pp++XX9/ery7//Lj6f76/Hg3/u8gLj/+UsocFdpRy7gJCEd42xwvBIXuOIxFDV4Hz/8B",
+      "brillig_names": [
+        "get_update_delay"
+      ]
+    },
+    {
+      "name": "set_update_delay",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public"
+      ],
+      "abi": {
+        "parameters": [
+          {
+            "name": "new_update_delay",
+            "type": {
+              "kind": "integer",
+              "sign": "unsigned",
+              "width": 32
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": null,
+        "error_types": {
+          "206160798890201757": {
+            "error_kind": "string",
+            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+          },
+          "2920182694213909827": {
+            "error_kind": "string",
+            "string": "attempt to subtract with overflow"
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "10019982601749771606": {
+            "error_kind": "string",
+            "string": "msg.sender is not deployed"
+          },
+          "15573886522241766899": {
+            "error_kind": "string",
+            "string": "New update delay is too low"
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "17595253152434889169": {
+            "error_kind": "string",
+            "string": "offset too large"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        }
+      },
+      "bytecode": "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",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "set_update_delay"
+      ]
+    },
     {
       "name": "deploy",
       "is_unconstrained": false,
@@ -2064,7 +2051,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "store_in_execution_cache_oracle_wrapper",
         "call_private_function_internal",
@@ -2078,7 +2065,7 @@
       "verification_key": "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"
     },
     {
-      "name": "set_update_delay",
+      "name": "update",
       "is_unconstrained": true,
       "custom_attributes": [
         "public"
@@ -2086,11 +2073,18 @@
       "abi": {
         "parameters": [
           {
-            "name": "new_update_delay",
+            "name": "new_contract_class_id",
             "type": {
-              "kind": "integer",
-              "sign": "unsigned",
-              "width": 32
+              "kind": "struct",
+              "path": "aztec::protocol_types::contract_class_id::ContractClassId",
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ]
             },
             "visibility": "private"
           }
@@ -2109,13 +2103,13 @@
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "10019982601749771606": {
+          "6504213605561840204": {
             "error_kind": "string",
-            "string": "msg.sender is not deployed"
+            "string": "New contract class is not registered"
           },
-          "15573886522241766899": {
+          "10019982601749771606": {
             "error_kind": "string",
-            "string": "New update delay is too low"
+            "string": "msg.sender is not deployed"
           },
           "16761564377371454734": {
             "error_kind": "string",
@@ -2131,14 +2125,14 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "set_update_delay"
+        "update"
       ]
     },
     {
-      "name": "update",
+      "name": "public_dispatch",
       "is_unconstrained": true,
       "custom_attributes": [
         "public"
@@ -2146,18 +2140,9 @@
       "abi": {
         "parameters": [
           {
-            "name": "new_contract_class_id",
+            "name": "selector",
             "type": {
-              "kind": "struct",
-              "path": "aztec::protocol_types::contract_class_id::ContractClassId",
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ]
+              "kind": "field"
             },
             "visibility": "private"
           }
@@ -2168,6 +2153,15 @@
             "error_kind": "string",
             "string": "Storage slot 0 not allowed. Storage slots must start from 1."
           },
+          "2830029349304997821": {
+            "error_kind": "fmtstring",
+            "length": 27,
+            "item_types": [
+              {
+                "kind": "field"
+              }
+            ]
+          },
           "2920182694213909827": {
             "error_kind": "string",
             "string": "attempt to subtract with overflow"
@@ -2184,6 +2178,14 @@
             "error_kind": "string",
             "string": "msg.sender is not deployed"
           },
+          "11343565365413149907": {
+            "error_kind": "string",
+            "string": "Function get_update_delay can only be called statically"
+          },
+          "15573886522241766899": {
+            "error_kind": "string",
+            "string": "New update delay is too low"
+          },
           "16761564377371454734": {
             "error_kind": "string",
             "string": "Array index out of bounds"
@@ -2198,10 +2200,10 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "7V3bjt02sv0XP/uBRRbrkl8ZHAS5eAIDhh04yQEGQf591Bdxqy1qc3aF4q4tJQ9Bt1tLa1WxSBYvIv989/OHH//45fuPn//95bd33/3rz3efvvz0w+8fv3yefvvzr/fvfvz68dOnj798v/znd+HpfzHoM+C3X3/4/PT7b7//8PX3d98lEH3/7sPnn6cfE/D0in9//PTh3XcA8a//e/8uglhQMdVQUZheUdOPskaJBZVMXMnEhdGEYgsqm7iyiYvAhCILioMJlS0orZYyYMBXFCDnN6j366cDJpkfD8hanid8IkkhjiDhASQwwhIYYUkcYUmqRjJkCDMqS/g2JlNCE0otKEwmFFtQ9faqiSILikyep2xBcbVtBM1zDwjK3AglgflhSVienVz2wkB7M0jYnQF3Z5C9GTTtzrC3DbjRGfVk6BGtgQsDv2FYP8t57uKZLk12JHlWA+hKTT2rJJj7kUiMDTXMUuTAm9xanznqXVtnDt6fYyNv78sxwA4cUB44IK7yADvygPKgAXZsjHxu4siY57wjI13GLhkrD+PUEr8+jIJxmYlW2rPMcVafhb9JW7Ge0NwofpI8i89EDfFEMIsnDi3xIRfxEVbie3g+ByjiY74uHjLPoQCU0nXxU7czv1lp0Xe+iq8nSX9DPOlS/BOFxv0pOlTiTDnNFLTooPcugim4+opnDN/4J0Pan6JDf5AFC4Uof0sR0/4UvDtFgv0p8v4UujsF7m8F7m9F3j9o8/5Vj/a3gvaverx/1eP9g5b3D1rpXNya4/X+dFokuLw6LGa8GF4EiTNBXZKaroLIl6Dpn7wJQm+CnAU1gbNqT+DNQ9FZtafordonb9U+eav2yVtQo7dqj+xMUAZvgrxVe/JW7clbtSd1JoiHV3tKUF6d01qQOBMk0ZsgciZIgzdB6E2Qs6Dm4Kzac/DmIXBW7RmcVXuOzqo9R2fVnqO3oE7jg1rmVdPI8Db9WD89TYbMT1PQN/saKwuyUnZBiuRvN0Fy4ruaqivfY/QmyJuH8nAPMWoRxOvqktmZIAJvgrI3QepM0PgBVkuQt6AWb0Et3oJ6/ACrJcidh5xVexk/wNJL6qdZ14LEmSDw5qEI3gQNH/EplaDWxYaAerYuicp2TlxsRk3heTOqjF8E6isfH1u++JaPGIr8Rew/yV8/DRrmbb2gCCtjxy9e3dNYfujAHD/K6yv/sb1Pj+19emzvs3PvX2mnnuU7T0ga8sV5QtKSj4Plp0DzfF0Ky8/SX/NTUWeCNHkTxL4EaQBvgrI3Qc6CWsFZUCt4C+roLaijt6CO3oI6eQvq5C2o0VtQIzkTlL15KHeo9pTinARSwnRdkMg8UaDw5ovkyqSCaDkhYvqZLkvxUV/U99i8aVUf33x8/awme1LDrnzDvnyjntT0GCR1VOPKN+rKNz32RHZTA6HHgl1POexKTo/dkD3l+PJOjwFITzm+vJN8xU4iV3LQV+ygp9wCQvaUeE1yPPWgkxxP6QUEGt6FcihyWsfvcNl7qgK01i6Pq50f2O/Mj6td4gNrf2C/q+Vk9QlmOYIcIEQbbOMQ8igXmDYcPGm+HAwdplncb10x/TeEJY9g2fieqDfLEFvqSWbjegKAevbVhNU73r6nik8sPIKF4xCWIbbIEFtkiC1qOaR8glnOh5+aArTBxASDaIOxCVafLWjDTAUQTZcBTLC9z36HiLA/Rd6fQnenyGl/Ctmdgva3YqOH6knR5daFG851h1wWKCEvFihTSq+C1JkgSfcUpBVB4kyQevOQ7n+MO2xcR9SbhAeQQBpBMsKSOKJM4ojoSiMsSSPKBEdY0mMzDyHOIwxCauyd6XhRAKQeO38ol93WlCk01Pe7KQBS7uJ7LSdlZNDr6jueUz9NbGBn9fRm4vCZo8dnEk2OHhOgVIKalk/PHD0+JG9x9Njz3uDAHrvGmxw9agXDHOjTw3nFATCAIw/g0P05etyz0OTg/TnSADvSADtwQOzigDqYB9iRB9TBPKAO0oDYpQGxy73LnBs3O6VYEsgUdfHql53a0OW6pr6Kenyc2FkRulMk3hT1uAGisyJvkZ2Dt9qfgzsfgbfan8Fb7e9yuVhfRdFb7c/RXWQnd5Gd3EV2Um+KMLlTxN4UZXe1P7ur/eSu9lN2p8hd7Wd3tZ/d9f3irvaLu9qv7jJ/HV77U5z3Cadp3eqNosqr+x2ADl3u3rPbSqu7ZiZF2ZsicOcjGO8jhqJItRGh02r+ooZd9r2nwC/6Y3hw/fjg+uWx9af44PrpsfXjg9dffPD6iw9ef3N6cP0P7n968PaTnLefuXzzmPJiL1XRL77bH6RyJCmSxIp+fWz9+tj+5+C7/jb1R/at/7Jxflrg1rV+5/lnW/+D+x99j3+b+rPv/Lmt33f/29RPD+5/5/lPUz8/uP8ZR+tHLDOCU5f6Rv+LIvWmSJI7RexN0fi1j6ai7E6Rt8iW4K32S3DnI/BW+wW81f4ud8l1VuSt9kt0F9nJXWQnd5GN7iJ7/IgRUzkHHjGvFY0fAzYVoTtF4k3R+JnzpiLypojdRTa7i2x2F9niLrLFXWSru8hWd5Gt3iJbg7fI1sDeFIE7H8GIs1G3rgXrzTLiPFFNYQjLEFvQdDbqxu1KTRgPOKxJecDBQCpxBMmAw5pUR1ii+5dJ7HJrTJtkhCUQR5CMsKTH3BvEHOdVpennxeHmTzQVUVNT9/o4T88v27z1wxrLLdEaJX/TQE4GUH8D8tpPPb6D/B9oepxn9r/Q9Mi7NMwspK1TtTqeaBZDl28JpXBMhrw50eyFg/fnIBjAkQdw6P4cXb6ya3EMsEMG2CEDYlcH1EHd3w4IMIAjD+DYP3YB0gCO3mWOjdMqk6QyJhLCN+Pvyqv7fXMYIcZ72srp27mGSRF7U5Tc+SiN95HMJ1InDXmtCKM7ReRNUZdVxr6K0J0i8aaI3EU2uav97M5H7K72i7vaL+5qv7ir/eousvWukQ26UhS7j1/+vqLsTpF6U9R9JPX3FbE3RdFdZEd3kR3dRXaX8wL7KnLnI3RX+zfWA5TmxaMUUmgogqSz/qfLA8rTrxcnTbWn2p2noGXHKqzXpCcYm2BkYyMbW/3Q7jaMTDCxsYmNrb7Zqw3LNphaYCmgDWZjq/ffbdhGcKEUWGxWs8aWkbhxT1V3FhrBkmAIyxBb8ObSf4blaIPZ2MjGRjY2trGxjU1sbGJjUxubmtgwRBvMxgY2NrCxRbDByARLNrZkY0Mb28bd502YmmAZbTAxwSjZYLbgsjVByLbiFltxi624tzK3FsxW3GoKrhySDWYKrmxrubKt5cq2livbWq6N2wPasGyD2Yob0QazFXe2BZctecq25CmTrbjZFlxsK26xBZfYiltswaW24lZTcJEt5yJbzkUANpgpuDZOJm7Dsg1mKm5KaIPZihuTDWYrbtuwj7KtuMkWXGQrbrYFF9uKm23BVd+pmaY0Z4blRH9dnxQoc7SLK+qRX95fP/Om4/t11/fzxoxbv/fLvu+HtPP7d9a/Mc3X7f0baWG399fPzu74/p315531b7Tk3d5PO8cP7Rz/vHP95Z3179y/sOzc/uvO7b/u638J+/p/4xSZXE70zrI4EDvHV5AYQPWaTDCfvU0LOy4gNoDYwlQfObZA2QBSC5OamKqVK5cV8GmQtwJpPeJaIDGAwMIEFqZoYap/ZtAA1eflpwHPDOJYAakBVJ+iaoDq47UWiA0gut0RKdRnDyDQvDEEABYfOzxdtrR+WmYKWF5GAPhKkXenqM9K9KXY34q0vxVpgBW6O0V9xqUvhexOUW8ZbqQotTuG+IaikpQozt+oserlzfEpSVknPOXNuJgFibUXR9B5h0OMEJcPPxvK6SyGykkMlbOEbn1r3AENVTiLoScpUQjhLIbiWQw9SfcCcJLuBeAsjVE8S2PUZZj4EIbqSQxNJxm9QDpL94Jn6V7wLN1LPsnoBfJZupd8lu6F8CyGnqV74bN0L/XPrQ5oqJyle5GzdC96kvHoxqkrj2hoTBdDF2cXz4bGw+S6DPNOo8gprQxNh2mMWoYeJnRbhh4m120YioeZSmkZepjMqGHocQbeLUPP0r3QWUqUztK91I/hB5ByLNMyn6obmjOXTZiySDMhVs880TybCrrYdfh6rlSKGyPHe0raGPrcU1L9q9V7SkrHWbBMoah4pn5baVI8TDPYMvQsJZoOM9HaMvQww4mGoXiWEsWzlGg+zAAxaiyGhrw29DCLIQ1D6TCLIS1DD9OPNgzlw0ydtww9TPfSMvQsjdFxPltoGXqY+ceGoXqSEsVwmPFow9D6h8NIZY4LCfHNxERFfJZ5rZApNC6S5ZhnH04/4vLhF0HsTFD96rN7CvLmIfTmIfTmofq6zT0FefMQeYuh+v65Owpiby11/UC3OwoSbx4SZzG0ccjvroIkFEECK0ERRwtKVBKtxBVBXYqML4IWCVpVULocW5BiXBy4kl6ODMl98o+uitibIoTRiqLOcZ2WM6tPiiojgcBl3BDkciXF07Ew66elqJaEjWevno80+UX/8UvNLzn945eaX+ifelT3S/7HLzW/8D/1qO4Xdu4XguIXDmv94r0daOmnx9avD+5/fWz/U3hs/1Pw3l+19HvPWxv6AR9cvzy2/ug9L2npvzl/eIYlsMHIBKufHI9Uci7kIA0nA6V5eQooLzI0mEnyCBIdQLI15uxLMsISwhEkIyzhEWWyNRi4jUTmO6CnB2RNInEECQ0g0TCCZIAlvJVF9iUZYQmEESQ9mhXOWkgE35BUngYo31/A4vb2SFJNCKjkA/nNs8/yY3xs+T3iiMvX8SCLlGmA/ISPLV86yJcUinykdQXDNIJkhCXUZX6h3zomcxgtCGEeQjDGiqA8WlBSuiZIhnsoSboIitcfBpiCalGbda1/eMhdX6lmBW+CnHlIAnoTpM4EQXYmKEZvgtiZoJS8CRJngtCbh9BbDGVnXYfU52FyjnOfnHMGv8mB1LdC5lySxkyx5dAIRVIEXSe9Ur/DuzdJD0smlpkk5rwmUexCwoWE1tNuWr8W/EaSFOYsOz6PAlckPIAERlgCXSyJuZBUpkI1drEklpPppoHzmqR+r9eNJBjKZzMINZI8gARHWIJdLImlMmJez+1p7mJJ6Q4iciWEN27tvJGkXH8Yc6hYQmkEyQhLuIclOZboWnbRFxLpQlLarkzr/kTrY/NbSbT0jBRwTVIfb/cm2d8SDKGHJXTp4wmlQkJdSEqzQgRrEuiRSFzWJaY8giskOoAkjrAkjrAkjbAk6e4NJAbEAST1idopN59JYgiLXjs8X2uNsT63RRnnqj/Vl9DQpmXApLqwQ2vrF9N4qXyCIet0exKkowVdvglRqAiC0R7SmIqgBBVB6kxQ9Oah6M1D9cm2ewpiZ4IQvAkiZ4KyNw/VL7W5p6DxXUe+CMprQXTHzlUTVQQNbxjzpcik4iEe3nWIFkGVhDCyOhMk3jxU/xj9joLqhwndUxD5EpQCeBPkzUP1jYn3FDS82ud5Au5pYqciSO/Wl02C4lrQ6FHH0wROEUShIkhHCyIsgrjioYTeBHnzECZvgtiZoNGjjrYgciaIvHmIsjdBw6t9WVOYBK2HQWn4qGPZl3Glt+fhHio71BHielyWRo86JhWlc4VU8ZCoM0HqzUMqvgRhiN4EkTNBAN4EefNQDN4EDc+pyyI8AsaKoDuOywDTWtDwUQeUJc4pXEJF0OiuY1pULYKgUmSI3gR581BO3gSxM0EE3gSRM0HszUOcvQkanlOXr5InQZXOdfhax6Ivi+tPySdBoz2EXGZhUdabUVCTN0HiS9DG0cT3FOTNQ+DNQ8DOBEXwJoicCUrBm6DsTdCuXcczxb6rFy8UsjtF7jBNBCGVEzdCpkbZ7XdJDpRp1bjMuF4uycGNY26PaaqcxlQ5TwALncZUhfOYeppSpRDOYyqex9TTdDYEp+lsCM7TLMXzNEsxn8dUPY2p6TQjG0rn6WzwPJ0NnqezyacZ2VA+T2eTz9PZ9Pis7lFMPU9nw+fpbJhPY6qcp7OR83Q2eprxKocDlWpMF1Mxr0yNB8qBuXysFzmllanpQM1Sy9QDBXDL1APlwA1T8UATLi1TD5QtNUw90tC8Zep5Ohs6T6nSeTqbja9aqZwxOs1TcMNUuVwsLUEuHPW7IVO+3A25OBV53knFG9uL7qlIvCkSdz4Sdz5Sdz5SdqZINo7Uuaci8qZo41CdeyrK7hR560Vk4wvXOypKXXxUPvWRsDhZvn6rB19yCl7cG/dyTQcKwWhBQvOJFiwsa0E0XFA52K8qiMd76HKxnoiuBZEzQeLNQ6LOBCl6E+TMQxqceUiDDBeUtAjScP1hAJTLVas5rhp2BfSj/1lQj6MCvIynUyjXriTAv74ZTyseaPK2YWo+T6nSgVb1W6YeaJ66YeqR9mq0TD1PqR5pr0bUcp9UCnlt6oFWHxqmHmmvRsvUA/WrLVMPtDHwqqk5hAN1Ni1Tz9Is5QBnaZYmU4+0hey6qUf6kK1l6oHGq9dNhfqC4OJW7chrDN+MiRtXLV/HGHjAwAMGnvo5Qg2MgScZ7Kl/xnYdg8mAqd+wSJe7D2GFqR//2MDI7Zj65EQuG4JptR94wtDtmPpqSANj4BEDjxh46kOKBuZ2no17axoYvh0D0YCR2zEx3Y6p14Xrm5MmVNULQDR3TkCyqg8bNwe0UPVtR02UWFD1s3aAeW6CgDWvUWxB1U+AaaKyCaUGFNbPOmyiLN5AiCaUiSuCCZVNKJPnk8nzyeQNNHkDTd6ob0AGhTk/BI0VlFpQG7Xycs0SBJIVaqNWtlB1b0AqrQ3kVWuzcZZoC1U/1b+JIguqPt4CoMs6p6y8kTciCsOcLE0/rrk2IqqFUguq3us1UfWIyuXeUJjKdIWqZ4FNlIlr45buBkqCCUUWVH2s10SJAbVxRFUTpRYUmLhgw65y+CdkXeVsFMmCqn+T1kSpBYVoQpm8kaMJZfLhRgabLj1RSqt2gziYUGhCiQW1kfe2UGRBqckbavE8h2BCoQll8TxDNKE2PI9cULRqbThGE0otqIQWFAYTKltQGzlAC8WGzGHjE60mypIRMZu4NuqyJig59mJrWkJ9gdWXRNswtcBkY2jZgm3UsSVssZGuwDaS3yZMTLBEJlg9145BZlgMShUYmWDZxlYfwDVh9YN42jAbG9vY6h3utG5QljwCV8qt3uO2YWyCqY1NTWwaog1GBhiF+sy8TOJfYdOPFxjIC6o+Kmui2IKqz2BOhVI28uriuAyorc1N8+jzkDvKYuKyUMjuFLK/FfXo7kpRrwl9KXa3AkLcn2J/K2B/K+qTtl0p6neV9KWg3Slw/7KgjTaKQ6FYXO88o+qJqQaYu2UNnFeo+jRui0s3okVK877cF/GKivVB5qSw3EsSFjskCipbUGDiqk8ztVD15cQJFS8oWKPEgkomrnry20SRBZVNXNnERaGJSuvyoo2ISrmgcB29HJr1C3GN2uBCudTKtULZKOUy5K7V5ShiaAGiJhOKDahU7wL48u0VfruETmkjnrAUcc5rTDZg9HYMJQPGsNxGicGEIgtKTFxi4lITl1q4MIAJZSmvjSvFmyiTXRvzLy0UmlBiQdU3xjVRfHNrgVs9XenAYwVDN9diJL6dhw3aNvuPaxi9HSO3t2S40d9cxejtPDmAAXN7mW5sGGhgDDz1+qrlUt5lxl0w+XZMMvDUt6Nex9S3ozYwBp5s4KkvQyzKp4KpT3ldL1Pi2zFs4KlvQWhgbs+GNq5da2Bubw8oJAPm9kxtY9tBA2PgiQZ74u2xs7FJoYG5MQ7+mn77/x++fvzhx08ffpsQT3/84/NPv3/88vn119//8+v8lx+/fvz06eMv3//69ctPH37+4+uH7z99+enpb+/C6//+BaD0HiLwpOZJ/rRiK+8hZZp+f3IbhKffp6HR09+fANNq2/tpwefp19fn8/R84knZpO6/",
       "brillig_names": [
-        "update"
+        "public_dispatch"
       ]
     }
   ],
@@ -2248,6 +2250,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": [
             {
@@ -2477,74 +2544,62 @@
           ],
           "kind": "struct",
           "path": "ContractInstanceDeployer::ContractInstanceDeployed"
-        },
+        }
+      ],
+      "functions": [
         {
           "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",
+              "name": "parameters",
               "type": {
                 "fields": [
                   {
-                    "name": "inner",
+                    "name": "new_update_delay",
                     "type": {
-                      "kind": "field"
+                      "kind": "integer",
+                      "sign": "unsigned",
+                      "width": 32
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "aztec::protocol_types::contract_class_id::ContractClassId"
+                "path": "ContractInstanceDeployer::set_update_delay_parameters"
               }
-            },
+            }
+          ],
+          "kind": "struct",
+          "path": "ContractInstanceDeployer::set_update_delay_abi"
+        },
+        {
+          "fields": [
             {
-              "name": "new_contract_class_id",
+              "name": "parameters",
               "type": {
                 "fields": [
                   {
-                    "name": "inner",
+                    "name": "new_contract_class_id",
                     "type": {
-                      "kind": "field"
+                      "fields": [
+                        {
+                          "name": "inner",
+                          "type": {
+                            "kind": "field"
+                          }
+                        }
+                      ],
+                      "kind": "struct",
+                      "path": "aztec::protocol_types::contract_class_id::ContractClassId"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "aztec::protocol_types::contract_class_id::ContractClassId"
-              }
-            },
-            {
-              "name": "block_of_change",
-              "type": {
-                "kind": "integer",
-                "sign": "unsigned",
-                "width": 32
+                "path": "ContractInstanceDeployer::update_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "ContractInstanceDeployer::ContractInstanceUpdated"
-        }
-      ],
-      "functions": [
+          "path": "ContractInstanceDeployer::update_abi"
+        },
         {
           "fields": [
             {
@@ -2767,59 +2822,6 @@
           ],
           "kind": "struct",
           "path": "ContractInstanceDeployer::deploy_abi"
-        },
-        {
-          "fields": [
-            {
-              "name": "parameters",
-              "type": {
-                "fields": [
-                  {
-                    "name": "new_contract_class_id",
-                    "type": {
-                      "fields": [
-                        {
-                          "name": "inner",
-                          "type": {
-                            "kind": "field"
-                          }
-                        }
-                      ],
-                      "kind": "struct",
-                      "path": "aztec::protocol_types::contract_class_id::ContractClassId"
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "ContractInstanceDeployer::update_parameters"
-              }
-            }
-          ],
-          "kind": "struct",
-          "path": "ContractInstanceDeployer::update_abi"
-        },
-        {
-          "fields": [
-            {
-              "name": "parameters",
-              "type": {
-                "fields": [
-                  {
-                    "name": "new_update_delay",
-                    "type": {
-                      "kind": "integer",
-                      "sign": "unsigned",
-                      "width": 32
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "ContractInstanceDeployer::set_update_delay_parameters"
-              }
-            }
-          ],
-          "kind": "struct",
-          "path": "ContractInstanceDeployer::set_update_delay_abi"
         }
       ]
     }
@@ -2827,7 +2829,7 @@
   "file_map": {
     "111": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/aztec.nr",
-      "source": "use crate::{\n    discovery::private_notes::MAX_NOTE_PACKED_LEN,\n    macros::{\n        dispatch::generate_public_dispatch,\n        functions::{\n            stub_registry,\n            utils::{create_message_discovery_call, find_and_transform_top_level_unconstrained_fns},\n        },\n        notes::{generate_note_export, NOTES},\n        storage::STORAGE_LAYOUT_NAME,\n        utils::{get_trait_impl_method, module_has_storage},\n    },\n};\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `process_log` and `sync_notes` functions PXE requires in order to discover notes.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n    let interface = generate_contract_interface(m);\n\n    find_and_transform_top_level_unconstrained_fns(m);\n\n    let contract_library_method_compute_note_hash_and_nullifier =\n        generate_contract_library_method_compute_note_hash_and_nullifier();\n    let note_exports = generate_note_exports();\n    let public_dispatch = generate_public_dispatch(m);\n    let sync_notes = generate_sync_notes();\n\n    quote {\n        $note_exports\n        $interface\n        $contract_library_method_compute_note_hash_and_nullifier\n        $public_dispatch\n        $sync_notes\n    }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n    let module_name = m.name();\n    let contract_stubs = stub_registry::get(m);\n    let fn_stubs_quote = if contract_stubs.is_some() {\n        contract_stubs.unwrap().join(quote {})\n    } else {\n        quote {}\n    };\n\n    let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n    let storage_layout_getter = if has_storage_layout {\n        let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n        quote {\n            pub fn storage_layout() -> StorageLayoutFields {\n                $storage_layout_name.fields\n            }\n        }\n    } else {\n        quote {}\n    };\n\n    let library_storage_layout_getter = if has_storage_layout {\n        quote {\n            #[contract_library_method]\n            $storage_layout_getter\n        }\n    } else {\n        quote {}\n    };\n\n    quote {\n        pub struct $module_name {\n            pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n        }\n\n        impl $module_name {\n            $fn_stubs_quote\n\n            pub fn at(\n                addr: aztec::protocol_types::address::AztecAddress\n            ) -> Self {\n                Self { target_contract: addr }\n            }\n\n            pub fn interface() -> Self {\n                Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n            }\n\n            $storage_layout_getter\n        }\n\n        #[contract_library_method]\n        pub fn at(\n            addr: aztec::protocol_types::address::AztecAddress\n        ) -> $module_name {\n            $module_name { target_contract: addr }\n        }\n\n        #[contract_library_method]\n        pub fn interface() -> $module_name {\n            $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n        }\n\n        $library_storage_layout_getter\n\n    }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n    let notes = NOTES.entries();\n\n    if notes.len() > 0 {\n        let max_note_packed_len = notes.fold(\n            0,\n            |acc, (_, (_, len, _, _)): (Type, (TypeDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n                if len > acc {\n                    len\n                } else {\n                    acc\n                }\n            },\n        );\n\n        if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n            panic(\n                f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n            );\n        }\n\n        // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n        // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n        // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n        // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n        let mut if_note_type_id_match_statements_list = &[];\n        for i in 0..notes.len() {\n            let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n            let get_note_type_id = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteType },\n                quote { get_id },\n            );\n            let unpack = get_trait_impl_method(\n                typ,\n                quote { crate::protocol_types::traits::Packable<_> },\n                quote { unpack },\n            );\n\n            let compute_note_hash = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_note_hash },\n            );\n\n            let compute_nullifier_unconstrained = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_nullifier_unconstrained },\n            );\n\n            let if_or_else_if = if i == 0 {\n                quote { if }\n            } else {\n                quote { else if }\n            };\n\n            if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n                quote {\n                    $if_or_else_if note_type_id == $get_note_type_id() {\n                        // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n                        // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n                        // unpack function on it.\n                        let expected_len = $packed_note_length;\n                        let actual_len = packed_note.len();\n                        assert(\n                            actual_len == expected_len,\n                            f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n                        );\n\n                        let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n                        let note_hash = $compute_note_hash(note, storage_slot);\n    \n                        // The message discovery process finds settled notes, that is, notes that were created in prior\n                        // transactions and are therefore already part of the note hash tree. We therefore compute the\n                        // nullification note hash by treating the note as a settled note with the provided nonce.\n                        let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n                            aztec::note::retrieved_note::RetrievedNote{ \n                                note, \n                                contract_address, \n                                metadata: aztec::note::note_metadata::SettledNoteMetadata::new(nonce).into() \n                            }, \n                            storage_slot,\n                        );\n\n                        let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullify);\n\n                        Option::some(\n                            aztec::discovery::NoteHashAndNullifier {\n                                note_hash, inner_nullifier\n                            }\n                        )\n                    }\n                },\n            );\n        }\n\n        let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n        quote {\n            /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n            /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n            /// tree with `nonce`.\n            ///\n            /// The signature of this function notably matches the `aztec::discovery::ComputeNoteHashAndNullifier` type,\n            /// and so it can be used to call functions from that module such as `discover_new_messages`, \n            /// `do_process_log` and `attempt_note_discovery`.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                packed_note: BoundedVec<Field, aztec::discovery::private_notes::MAX_NOTE_PACKED_LEN>,\n                storage_slot: Field,\n                note_type_id: Field,\n                contract_address: aztec::protocol_types::address::AztecAddress,\n                nonce: Field,\n            ) -> Option<aztec::discovery::NoteHashAndNullifier> {\n                $if_note_type_id_match_statements\n                else {\n                    Option::none()\n                }\n            }\n        }\n    } else {\n        // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n        // simply throws immediately.\n        quote {\n            /// This contract does not use private notes, so this function should never be called as it will\n            /// unconditionally fail.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                _packed_note: BoundedVec<Field, aztec::discovery::private_notes::MAX_NOTE_PACKED_LEN>,\n                _storage_slot: Field,\n                _note_type_id: Field,\n                _contract_address: aztec::protocol_types::address::AztecAddress,\n                _nonce: Field,\n            ) -> Option<aztec::discovery::NoteHashAndNullifier> {\n                panic(f\"This contract does not use private notes\")\n            }\n        }\n    }\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n    let notes = NOTES.values();\n    // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n    // generating partial note helper functions.\n    notes\n        .map(|(s, _, note_type_id, fields): (TypeDefinition, u32, Field, [(Quoted, u32, bool)])| {\n            generate_note_export(s, note_type_id, fields)\n        })\n        .join(quote {})\n}\n\ncomptime fn generate_sync_notes() -> Quoted {\n    let message_discovery_call = create_message_discovery_call();\n    quote {\n        unconstrained fn sync_notes() {\n            // Because this unconstrained function is injected after the contract is processed by the macros, it'll not\n            // be modified by the macros that alter unconstrained functions. As such, we need to manually inject the\n            // unconstrained execution context since it will not be available otherwise.\n            let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n            $message_discovery_call\n        }\n    }\n}\n"
+      "source": "use crate::{\n    discovery::private_notes::MAX_NOTE_PACKED_LEN,\n    macros::{\n        dispatch::generate_public_dispatch,\n        functions::{\n            stub_registry,\n            utils::{check_each_fn_macroified, create_message_discovery_call},\n        },\n        notes::{generate_note_export, NOTES},\n        storage::STORAGE_LAYOUT_NAME,\n        utils::{get_trait_impl_method, module_has_storage},\n    },\n};\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `sync_notes` utility function PXE requires in order to discover notes.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n    let interface = generate_contract_interface(m);\n\n    // Functions that don't have #[private], #[public], #[utility], #[contract_library_method], or #[test] are not\n    // allowed in contracts.\n    check_each_fn_macroified(m);\n\n    let contract_library_method_compute_note_hash_and_nullifier =\n        generate_contract_library_method_compute_note_hash_and_nullifier();\n    let note_exports = generate_note_exports();\n    let public_dispatch = generate_public_dispatch(m);\n    let sync_notes = generate_sync_notes();\n\n    quote {\n        $note_exports\n        $interface\n        $contract_library_method_compute_note_hash_and_nullifier\n        $public_dispatch\n        $sync_notes\n    }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n    let module_name = m.name();\n    let contract_stubs = stub_registry::get(m);\n    let fn_stubs_quote = if contract_stubs.is_some() {\n        contract_stubs.unwrap().join(quote {})\n    } else {\n        quote {}\n    };\n\n    let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n    let storage_layout_getter = if has_storage_layout {\n        let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n        quote {\n            pub fn storage_layout() -> StorageLayoutFields {\n                $storage_layout_name.fields\n            }\n        }\n    } else {\n        quote {}\n    };\n\n    let library_storage_layout_getter = if has_storage_layout {\n        quote {\n            #[contract_library_method]\n            $storage_layout_getter\n        }\n    } else {\n        quote {}\n    };\n\n    quote {\n        pub struct $module_name {\n            pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n        }\n\n        impl $module_name {\n            $fn_stubs_quote\n\n            pub fn at(\n                addr: aztec::protocol_types::address::AztecAddress\n            ) -> Self {\n                Self { target_contract: addr }\n            }\n\n            pub fn interface() -> Self {\n                Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n            }\n\n            $storage_layout_getter\n        }\n\n        #[contract_library_method]\n        pub fn at(\n            addr: aztec::protocol_types::address::AztecAddress\n        ) -> $module_name {\n            $module_name { target_contract: addr }\n        }\n\n        #[contract_library_method]\n        pub fn interface() -> $module_name {\n            $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n        }\n\n        $library_storage_layout_getter\n\n    }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n    let notes = NOTES.entries();\n\n    if notes.len() > 0 {\n        let max_note_packed_len = notes.fold(\n            0,\n            |acc, (_, (_, len, _, _)): (Type, (TypeDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n                if len > acc {\n                    len\n                } else {\n                    acc\n                }\n            },\n        );\n\n        if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n            panic(\n                f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n            );\n        }\n\n        // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n        // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n        // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n        // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n        let mut if_note_type_id_match_statements_list = &[];\n        for i in 0..notes.len() {\n            let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n            let get_note_type_id = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteType },\n                quote { get_id },\n            );\n            let unpack = get_trait_impl_method(\n                typ,\n                quote { crate::protocol_types::traits::Packable<_> },\n                quote { unpack },\n            );\n\n            let compute_note_hash = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_note_hash },\n            );\n\n            let compute_nullifier_unconstrained = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_nullifier_unconstrained },\n            );\n\n            let if_or_else_if = if i == 0 {\n                quote { if }\n            } else {\n                quote { else if }\n            };\n\n            if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n                quote {\n                    $if_or_else_if note_type_id == $get_note_type_id() {\n                        // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n                        // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n                        // unpack function on it.\n                        let expected_len = $packed_note_length;\n                        let actual_len = packed_note.len();\n                        assert(\n                            actual_len == expected_len,\n                            f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n                        );\n\n                        let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n                        let note_hash = $compute_note_hash(note, storage_slot);\n    \n                        // The message discovery process finds settled notes, that is, notes that were created in prior\n                        // transactions and are therefore already part of the note hash tree. We therefore compute the\n                        // nullification note hash by treating the note as a settled note with the provided nonce.\n                        let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n                            aztec::note::retrieved_note::RetrievedNote{ \n                                note, \n                                contract_address, \n                                metadata: aztec::note::note_metadata::SettledNoteMetadata::new(nonce).into() \n                            }, \n                            storage_slot,\n                        );\n\n                        let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullify);\n\n                        Option::some(\n                            aztec::discovery::NoteHashAndNullifier {\n                                note_hash, inner_nullifier\n                            }\n                        )\n                    }\n                },\n            );\n        }\n\n        let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n        quote {\n            /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n            /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n            /// tree with `nonce`.\n            ///\n            /// The signature of this function notably matches the `aztec::discovery::ComputeNoteHashAndNullifier` type,\n            /// and so it can be used to call functions from that module such as `discover_new_messages`, \n            /// `do_process_log` and `attempt_note_discovery`.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                packed_note: BoundedVec<Field, aztec::discovery::private_notes::MAX_NOTE_PACKED_LEN>,\n                storage_slot: Field,\n                note_type_id: Field,\n                contract_address: aztec::protocol_types::address::AztecAddress,\n                nonce: Field,\n            ) -> Option<aztec::discovery::NoteHashAndNullifier> {\n                $if_note_type_id_match_statements\n                else {\n                    Option::none()\n                }\n            }\n        }\n    } else {\n        // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n        // simply throws immediately.\n        quote {\n            /// This contract does not use private notes, so this function should never be called as it will\n            /// unconditionally fail.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                _packed_note: BoundedVec<Field, aztec::discovery::private_notes::MAX_NOTE_PACKED_LEN>,\n                _storage_slot: Field,\n                _note_type_id: Field,\n                _contract_address: aztec::protocol_types::address::AztecAddress,\n                _nonce: Field,\n            ) -> Option<aztec::discovery::NoteHashAndNullifier> {\n                panic(f\"This contract does not use private notes\")\n            }\n        }\n    }\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n    let notes = NOTES.values();\n    // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n    // generating partial note helper functions.\n    notes\n        .map(|(s, _, note_type_id, fields): (TypeDefinition, u32, Field, [(Quoted, u32, bool)])| {\n            generate_note_export(s, note_type_id, fields)\n        })\n        .join(quote {})\n}\n\ncomptime fn generate_sync_notes() -> Quoted {\n    let message_discovery_call = create_message_discovery_call();\n\n    // TODO(https://github.com/noir-lang/noir/issues/7912): Doing the following unfortunately doesn't work. Once\n    // the issue is fixed uncomment the following and remove the workaround from TS (look for the issue link in the\n    // codebase).\n    // let utility: fn(FunctionDefinition) -> () = crate::macros::functions::utility;\n    // quote {\n    //     #[$utility]\n    //     unconstrained fn sync_notes() {\n    //         $message_discovery_call\n    //     }\n    // }\n\n    quote {\n        #[aztec::macros::functions::utility]\n        unconstrained fn sync_notes() {\n            $message_discovery_call\n        }\n    }\n}\n"
     },
     "112": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/dispatch.nr",
@@ -2839,7 +2841,7 @@
     },
     "119": {
       "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_initializer, is_fn_internal,\n        is_fn_private, is_fn_public, is_fn_view, modify_fn_body, module_has_initializer,\n        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 find_and_transform_top_level_unconstrained_fns(m: Module) {\n    // Top-level unconstrained fns are contract entrypoints, but they're not explicitly designated in any way. They're\n    // the fallback case for a function that matches no other rules.\n    // TODO(#12743): improve this\n\n    // We first find non-standard contract entrypoints, i.e. functions in the `contract` mod that are not private or\n    // public, but which *are* contract entrypoints (i.e. they're not opting out via the #[test] or\n    // #[contract_library_method] attributes). Ideally entrypoints would be explicitly designated instead.\n    let non_private_public_entrypoint_functions = m.functions().filter(|f: FunctionDefinition| {\n        !is_fn_private(f)\n            & !is_fn_public(f)\n            & !f.has_named_attribute(\"contract_library_method\")\n            & !f.has_named_attribute(\"test\")\n    });\n\n    // TODO: uncomment the code below and emit a warning once support for them is added to Noir (tracked in\n    // https://github.com/noir-lang/noir/issues/7714). We can't simply print a message since that'd otherwise break the\n    // output of utils such as `nargo test --list-tests`.\n    // // We don't expect to see any custom constrained entrypoints (i.e. private functions created outside of aztec-nr's\n    // // #[private] macro, possibly resulting in a non-standard interface).\n    // for f in non_private_public_entrypoint_functions.filter(|f: FunctionDefinition| {\n    //     !f.is_unconstrained()\n    // }) {\n    //     let name = f.name();\n    //     warn(\n    //         f\"found private contract function '{name}' which does not have the #[private] attribute - make sure you know what you're doing!\",\n    //     );\n    // }\n\n    // An unconstrained contract entrypoints is what we call a top-level unconstrained function, to which we apply the\n    // appropriate transformation. Ideally these would be explicitly designated as such instead.\n    for f in non_private_public_entrypoint_functions.filter(|f: FunctionDefinition| {\n        f.is_unconstrained()\n    }) {\n        transform_top_level_unconstrained(f);\n    }\n}\n\npub(crate) comptime fn transform_top_level_unconstrained(f: FunctionDefinition) {\n    let context_creation = quote { let mut context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new(); };\n    let module_has_storage = module_has_storage(f.module());\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(context);\n        }\n    } else {\n        quote {}\n    };\n\n    // All unconstrained 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    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_return_public(true);\n    f.set_body(modified_body);\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::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::discovery::discover_new_messages(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\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::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::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"
     },
     "122": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/storage.nr",
@@ -2889,51 +2891,51 @@
       "path": "std/field/bn254.nr",
       "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\nglobal TWO_POW_64: Field = 0x10000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(mut x: Field) -> (Field, Field) {\n    // Here's we're taking advantage of truncating 64 bit limbs from the input field\n    // and then subtracting them from the input such the field division is equivalent to integer division.\n    let low_lower_64 = (x as u64) as Field;\n    x = (x - low_lower_64) / TWO_POW_64;\n    let low_upper_64 = (x as u64) as Field;\n\n    let high = (x - low_upper_64) / TWO_POW_64;\n    let low = low_upper_64 * TWO_POW_64 + low_lower_64;\n\n    (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n    compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n    if x == y {\n        true\n    } else {\n        field_less_than(x, y)\n    }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n    let (alo, ahi) = a;\n    let (blo, bhi) = b;\n    // Safety: borrow is enforced to be boolean due to its type.\n    // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n    // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n    unsafe {\n        let borrow = lte_hint(alo, blo);\n\n        let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n        let rhi = ahi - bhi - (borrow as Field);\n\n        rlo.assert_max_bit_size::<128>();\n        rhi.assert_max_bit_size::<128>();\n    }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n    if is_unconstrained() {\n        compute_decomposition(x)\n    } else {\n        // Safety: decomposition is properly checked below\n        unsafe {\n            // Take hints of the decomposition\n            let (xlo, xhi) = decompose_hint(x);\n\n            // Range check the limbs\n            xlo.assert_max_bit_size::<128>();\n            xhi.assert_max_bit_size::<128>();\n\n            // Check that the decomposition is correct\n            assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n            // Assert that the decomposition of P is greater than the decomposition of x\n            assert_gt_limbs((PLO, PHI), (xlo, xhi));\n            (xlo, xhi)\n        }\n    }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n    if is_unconstrained() {\n        assert(\n            // Safety: already unconstrained\n            unsafe { field_less_than(b, a) },\n        );\n    } else {\n        // Decompose a and b\n        let a_limbs = decompose(a);\n        let b_limbs = decompose(b);\n\n        // Assert that a_limbs is greater than b_limbs\n        assert_gt_limbs(a_limbs, b_limbs)\n    }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n    assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unsafe in unconstrained\n        unsafe {\n            field_less_than(b, a)\n        }\n    } else if a == b {\n        false\n    } else {\n        // Safety: Take a hint of the comparison and verify it\n        unsafe {\n            if field_less_than(a, b) {\n                assert_gt(b, a);\n                false\n            } else {\n                assert_gt(a, b);\n                true\n            }\n        }\n    }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n    gt(b, a)\n}\n\nmod tests {\n    // TODO: Allow imports from \"super\"\n    use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n    #[test]\n    fn check_decompose() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_decompose_unconstrained() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_lte_hint() {\n        assert(lte_hint(0, 1));\n        assert(lte_hint(0, 0x100));\n        assert(lte_hint(0x100, TWO_POW_128 - 1));\n        assert(!lte_hint(0 - 1, 0));\n\n        assert(lte_hint(0, 0));\n        assert(lte_hint(0x100, 0x100));\n        assert(lte_hint(0 - 1, 0 - 1));\n    }\n\n    #[test]\n    fn check_assert_gt() {\n        assert_gt(1, 0);\n        assert_gt(0x100, 0);\n        assert_gt((0 - 1), (0 - 2));\n        assert_gt(TWO_POW_128, 0);\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    unconstrained fn check_assert_gt_unconstrained() {\n        assert_gt(1, 0);\n        assert_gt(0x100, 0);\n        assert_gt((0 - 1), (0 - 2));\n        assert_gt(TWO_POW_128, 0);\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    fn check_gt() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n    }\n\n    #[test]\n    unconstrained fn check_gt_unconstrained() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n    }\n\n    #[test]\n    fn check_plo_phi() {\n        assert_eq(PLO + PHI * TWO_POW_128, 0);\n        let p_bytes = crate::field::modulus_le_bytes();\n        let mut p_low: Field = 0;\n        let mut p_high: Field = 0;\n\n        let mut offset = 1;\n        for i in 0..16 {\n            p_low += (p_bytes[i] as Field) * offset;\n            p_high += (p_bytes[i + 16] as Field) * offset;\n            offset *= 256;\n        }\n        assert_eq(p_low, PLO);\n        assert_eq(p_high, PHI);\n    }\n}\n"
     },
-    "170": {
+    "171": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/state_vars/shared_mutable.nr",
-      "source": "use dep::protocol_types::{\n    shared_mutable::{ScheduledDelayChange, ScheduledValueChange, SharedMutableValues},\n    traits::Packable,\n};\n\nuse crate::{\n    context::{PrivateContext, PublicContext, UnconstrainedContext},\n    state_vars::storage::Storage,\n    utils::with_hash::WithHash,\n};\n\nmod test;\n\npub struct SharedMutable<T, let INITIAL_DELAY: u32, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n\n// This will make the Aztec macros require that T implements the Packable and Eq traits, and allocate `M` storage\n// slots to this state variable.\nimpl<T, let INITIAL_DELAY: u32, Context, let M: u32> Storage<M> for SharedMutable<T, INITIAL_DELAY, Context>\nwhere\n    WithHash<SharedMutableValues<T, INITIAL_DELAY>, _>: Packable<M>,\n{\n    fn get_storage_slot(self) -> Field {\n        self.storage_slot\n    }\n}\n\n// SharedMutable<T> stores a value of type T that is:\n//  - publicly known (i.e. unencrypted)\n//  - mutable in public\n//  - readable in private with no contention (i.e. multiple parties can all read the same value without blocking one\n//    another nor needing to coordinate)\n// This is famously a hard problem to solve. SharedMutable makes it work by introducing a delay to public mutation:\n// the value is not changed immediately but rather a value change is scheduled to happen in the future after some delay\n// measured in blocks. Reads in private are only valid as long as they are included in a block not too far into the\n// future, so that they can guarantee the value will not have possibly changed by then (because of the delay).\n// The delay for changing a value is initially equal to INITIAL_DELAY, but can be changed by calling\n// `schedule_delay_change`.\nimpl<T, let INITIAL_DELAY: u32, Context> SharedMutable<T, INITIAL_DELAY, Context> {\n    pub fn new(context: Context, storage_slot: Field) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Self { context, storage_slot }\n    }\n}\n\nimpl<T, let INITIAL_DELAY: u32> SharedMutable<T, INITIAL_DELAY, &mut PublicContext>\nwhere\n    T: Eq,\n{\n\n    pub fn schedule_value_change<let N: u32>(self, new_value: T)\n    where\n        T: Packable<N>,\n    {\n        let _value_change = self.schedule_and_return_value_change(new_value);\n    }\n\n    pub fn schedule_and_return_value_change<let N: u32>(\n        self,\n        new_value: T,\n    ) -> ScheduledValueChange<T>\n    where\n        T: Packable<N>,\n    {\n        let mut value_change = self.read_value_change();\n        let delay_change = self.read_delay_change();\n\n        let block_number = self.context.block_number() as u32;\n        let current_delay = delay_change.get_current(block_number);\n\n        // TODO: make this configurable\n        // https://github.com/AztecProtocol/aztec-packages/issues/5501\n        let block_of_change = block_number + current_delay;\n        value_change.schedule_change(new_value, block_number, current_delay, block_of_change);\n\n        self.write(value_change, delay_change);\n\n        value_change\n    }\n\n    pub fn schedule_delay_change<let N: u32>(self, new_delay: u32)\n    where\n        T: Packable<N>,\n    {\n        let mut delay_change = self.read_delay_change();\n\n        let block_number = self.context.block_number() as u32;\n\n        delay_change.schedule_change(new_delay, block_number);\n\n        self.write(self.read_value_change(), delay_change);\n    }\n\n    pub fn get_current_value<let N: u32>(self) -> T\n    where\n        T: Packable<N>,\n    {\n        let block_number = self.context.block_number() as u32;\n        self.read_value_change().get_current_at(block_number)\n    }\n\n    pub fn get_current_delay<let N: u32>(self) -> u32\n    where\n        T: Packable<N>,\n    {\n        let block_number = self.context.block_number() as u32;\n        self.read_delay_change().get_current(block_number)\n    }\n\n    pub fn get_scheduled_value<let N: u32>(self) -> (T, u32)\n    where\n        T: Packable<N>,\n    {\n        self.read_value_change().get_scheduled()\n    }\n\n    pub fn get_scheduled_delay<let N: u32>(self) -> (u32, u32)\n    where\n        T: Packable<N>,\n    {\n        self.read_delay_change().get_scheduled()\n    }\n\n    fn read_value_change<let N: u32>(self) -> ScheduledValueChange<T>\n    where\n        T: Packable<N>,\n    {\n        // We don't read ScheduledValueChange directly by having it implement Packable because ScheduledValueChange\n        // and ScheduledDelayChange are packed together (sdc and svc.block_of_change are stored in the same slot).\n        let packed = self.context.storage_read(self.storage_slot);\n        SharedMutableValues::unpack_value_change(packed)\n    }\n\n    fn read_delay_change<let N: u32>(self) -> ScheduledDelayChange<INITIAL_DELAY>\n    where\n        T: Packable<N>,\n    {\n        // Since all ScheduledDelayChange member are packed into a single field, we can read a single storage slot\n        // here and skip the ones that correspond to ScheduledValueChange members. We are abusing the fact that\n        // the field containing the ScheduledDelayChange data is the first one in the storage layout - otherwise we'd\n        // need to offset the storage slot to get the position where it'd land.\n        // We don't read ScheduledDelayChange directly by having it implement Packable because\n        // ScheduledValueChange and ScheduledDelayChange are packed together (sdc and svc.block_of_change are\n        // stored in the same slot).\n        let packed = self.context.storage_read(self.storage_slot);\n        SharedMutableValues::<T, INITIAL_DELAY>::unpack_delay_change(packed)\n    }\n\n    fn write<let N: u32>(\n        self,\n        value_change: ScheduledValueChange<T>,\n        delay_change: ScheduledDelayChange<INITIAL_DELAY>,\n    )\n    where\n        T: Packable<N>,\n    {\n        // Whenever we write to public storage, we write both the value change and delay change to storage at once.\n        // We do so by wrapping them in a single struct (`SharedMutableValues`). Then we wrap the resulting struct in\n        // `WithHash`.\n        // Wrapping in `WithHash` makes for more costly writes but it also makes private proofs much simpler because\n        // they only need to produce a historical proof for the hash, which results in a single inclusion proof (as\n        // opposed to 4 in the best case scenario in which T is a single field). Private shared mutable reads are\n        // assumed to be much more frequent than public writes, so this tradeoff makes sense.\n        let values = WithHash::new(SharedMutableValues::new(value_change, delay_change));\n\n        self.context.storage_write(self.storage_slot, values);\n    }\n}\n\nimpl<T, let INITIAL_DELAY: u32> SharedMutable<T, INITIAL_DELAY, &mut PrivateContext>\nwhere\n    T: Eq,\n{\n    pub fn get_current_value<let N: u32>(self) -> T\n    where\n        T: Packable<N>,\n    {\n        // When reading the current value in private we construct a historical state proof for the public value.\n        // However, since this value might change, we must constrain the maximum transaction block number as this proof\n        // will only be valid for however many blocks we can ensure the value will not change, which will depend on the\n        // current delay and any scheduled delay changes.\n        let (value_change, delay_change, historical_block_number) =\n            self.historical_read_from_public_storage();\n\n        // We use the effective minimum delay as opposed to the current delay at the historical block as this one also\n        // takes into consideration any scheduled delay changes.\n        // For example, consider a scenario in which at block 200 the current delay was 50. We may naively think that\n        // the earliest we could change the value would be at block 251 by scheduling immediately after the historical\n        // block, i.e. at block 201. But if there was a delay change scheduled for block 210 to reduce the delay to 20\n        // blocks, then if a value change was scheduled at block 210 it would go into effect at block 230, which is\n        // earlier than what we'd expect if we only considered the current delay.\n        let effective_minimum_delay =\n            delay_change.get_effective_minimum_delay_at(historical_block_number);\n        let block_horizon =\n            value_change.get_block_horizon(historical_block_number, effective_minimum_delay);\n\n        // We prevent this transaction from being included in any block after the block horizon, ensuring that the\n        // historical public value matches the current one, since it can only change after the horizon.\n        self.context.set_tx_max_block_number(block_horizon);\n        value_change.get_current_at(historical_block_number)\n    }\n\n    fn historical_read_from_public_storage<let N: u32>(\n        self,\n    ) -> (ScheduledValueChange<T>, ScheduledDelayChange<INITIAL_DELAY>, u32)\n    where\n        T: Packable<N>,\n    {\n        let header = self.context.get_block_header();\n        let address = self.context.this_address();\n\n        let historical_block_number = header.global_variables.block_number as u32;\n\n        let values: SharedMutableValues<T, INITIAL_DELAY> =\n            WithHash::historical_public_storage_read(header, address, self.storage_slot);\n\n        (values.svc, values.sdc, historical_block_number)\n    }\n}\n\nimpl<T, let INITIAL_DELAY: u32> SharedMutable<T, INITIAL_DELAY, UnconstrainedContext>\nwhere\n    T: Eq,\n{\n    pub unconstrained fn get_current_value<let N: u32>(self) -> T\n    where\n        T: Packable<N>,\n    {\n        let smv: SharedMutableValues<T, INITIAL_DELAY> =\n            WithHash::unconstrained_public_storage_read(self.context, self.storage_slot);\n\n        let block_number = self.context.block_number() as u32;\n        smv.svc.get_current_at(block_number)\n    }\n}\n"
+      "source": "use dep::protocol_types::{\n    shared_mutable::{\n        ScheduledDelayChange,\n        ScheduledValueChange,\n        shared_mutable_values::{unpack_delay_change, unpack_value_change},\n        SharedMutableValues,\n    },\n    traits::Packable,\n};\n\nuse crate::{\n    context::{PrivateContext, PublicContext, UtilityContext},\n    state_vars::storage::Storage,\n    utils::with_hash::WithHash,\n};\n\nmod test;\n\npub struct SharedMutable<T, let INITIAL_DELAY: u32, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n\n// This will make the Aztec macros require that T implements the Packable and Eq traits, and allocate `M` storage\n// slots to this state variable.\nimpl<T, let INITIAL_DELAY: u32, Context, let M: u32> Storage<M> for SharedMutable<T, INITIAL_DELAY, Context>\nwhere\n    WithHash<SharedMutableValues<T, INITIAL_DELAY>, _>: Packable<M>,\n{\n    fn get_storage_slot(self) -> Field {\n        self.storage_slot\n    }\n}\n\n// SharedMutable<T> stores a value of type T that is:\n//  - publicly known (i.e. unencrypted)\n//  - mutable in public\n//  - readable in private with no contention (i.e. multiple parties can all read the same value without blocking one\n//    another nor needing to coordinate)\n// This is famously a hard problem to solve. SharedMutable makes it work by introducing a delay to public mutation:\n// the value is not changed immediately but rather a value change is scheduled to happen in the future after some delay\n// measured in blocks. Reads in private are only valid as long as they are included in a block not too far into the\n// future, so that they can guarantee the value will not have possibly changed by then (because of the delay).\n// The delay for changing a value is initially equal to INITIAL_DELAY, but can be changed by calling\n// `schedule_delay_change`.\nimpl<T, let INITIAL_DELAY: u32, Context> SharedMutable<T, INITIAL_DELAY, Context> {\n    pub fn new(context: Context, storage_slot: Field) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Self { context, storage_slot }\n    }\n}\n\nimpl<T, let INITIAL_DELAY: u32> SharedMutable<T, INITIAL_DELAY, &mut PublicContext>\nwhere\n    T: Eq,\n{\n\n    pub fn schedule_value_change<let N: u32>(self, new_value: T)\n    where\n        T: Packable<N>,\n    {\n        let _value_change = self.schedule_and_return_value_change(new_value);\n    }\n\n    pub fn schedule_and_return_value_change<let N: u32>(\n        self,\n        new_value: T,\n    ) -> ScheduledValueChange<T>\n    where\n        T: Packable<N>,\n    {\n        let mut value_change = self.read_value_change();\n        let delay_change = self.read_delay_change();\n\n        let block_number = self.context.block_number() as u32;\n        let current_delay = delay_change.get_current(block_number);\n\n        // TODO: make this configurable\n        // https://github.com/AztecProtocol/aztec-packages/issues/5501\n        let block_of_change = block_number + current_delay;\n        value_change.schedule_change(new_value, block_number, current_delay, block_of_change);\n\n        self.write(value_change, delay_change);\n\n        value_change\n    }\n\n    pub fn schedule_delay_change<let N: u32>(self, new_delay: u32)\n    where\n        T: Packable<N>,\n    {\n        let mut delay_change = self.read_delay_change();\n\n        let block_number = self.context.block_number() as u32;\n\n        delay_change.schedule_change(new_delay, block_number);\n\n        self.write(self.read_value_change(), delay_change);\n    }\n\n    pub fn get_current_value<let N: u32>(self) -> T\n    where\n        T: Packable<N>,\n    {\n        let block_number = self.context.block_number() as u32;\n        self.read_value_change().get_current_at(block_number)\n    }\n\n    pub fn get_current_delay<let N: u32>(self) -> u32\n    where\n        T: Packable<N>,\n    {\n        let block_number = self.context.block_number() as u32;\n        self.read_delay_change().get_current(block_number)\n    }\n\n    pub fn get_scheduled_value<let N: u32>(self) -> (T, u32)\n    where\n        T: Packable<N>,\n    {\n        self.read_value_change().get_scheduled()\n    }\n\n    pub fn get_scheduled_delay<let N: u32>(self) -> (u32, u32)\n    where\n        T: Packable<N>,\n    {\n        self.read_delay_change().get_scheduled()\n    }\n\n    fn read_value_change<let N: u32>(self) -> ScheduledValueChange<T>\n    where\n        T: Packable<N>,\n    {\n        // We don't read ScheduledValueChange directly by having it implement Packable because ScheduledValueChange\n        // and ScheduledDelayChange are packed together (sdc and svc.block_of_change are stored in the same slot).\n        let packed = self.context.storage_read(self.storage_slot);\n        unpack_value_change::<T, N>(packed)\n    }\n\n    fn read_delay_change<let N: u32>(self) -> ScheduledDelayChange<INITIAL_DELAY>\n    where\n        T: Packable<N>,\n    {\n        // Since all ScheduledDelayChange member are packed into a single field, we can read a single storage slot\n        // here and skip the ones that correspond to ScheduledValueChange members. We are abusing the fact that\n        // the field containing the ScheduledDelayChange data is the first one in the storage layout - otherwise we'd\n        // need to offset the storage slot to get the position where it'd land.\n        // We don't read ScheduledDelayChange directly by having it implement Packable because\n        // ScheduledValueChange and ScheduledDelayChange are packed together (sdc and svc.block_of_change are\n        // stored in the same slot).\n        let packed = self.context.storage_read(self.storage_slot);\n        unpack_delay_change::<INITIAL_DELAY>(packed)\n    }\n\n    fn write<let N: u32>(\n        self,\n        value_change: ScheduledValueChange<T>,\n        delay_change: ScheduledDelayChange<INITIAL_DELAY>,\n    )\n    where\n        T: Packable<N>,\n    {\n        // Whenever we write to public storage, we write both the value change and delay change to storage at once.\n        // We do so by wrapping them in a single struct (`SharedMutableValues`). Then we wrap the resulting struct in\n        // `WithHash`.\n        // Wrapping in `WithHash` makes for more costly writes but it also makes private proofs much simpler because\n        // they only need to produce a historical proof for the hash, which results in a single inclusion proof (as\n        // opposed to 4 in the best case scenario in which T is a single field). Private shared mutable reads are\n        // assumed to be much more frequent than public writes, so this tradeoff makes sense.\n        let values = WithHash::new(SharedMutableValues::new(value_change, delay_change));\n\n        self.context.storage_write(self.storage_slot, values);\n    }\n}\n\nimpl<T, let INITIAL_DELAY: u32> SharedMutable<T, INITIAL_DELAY, &mut PrivateContext>\nwhere\n    T: Eq,\n{\n    pub fn get_current_value<let N: u32>(self) -> T\n    where\n        T: Packable<N>,\n    {\n        // When reading the current value in private we construct a historical state proof for the public value.\n        // However, since this value might change, we must constrain the maximum transaction block number as this proof\n        // will only be valid for however many blocks we can ensure the value will not change, which will depend on the\n        // current delay and any scheduled delay changes.\n        let (value_change, delay_change, historical_block_number) =\n            self.historical_read_from_public_storage();\n\n        // We use the effective minimum delay as opposed to the current delay at the historical block as this one also\n        // takes into consideration any scheduled delay changes.\n        // For example, consider a scenario in which at block 200 the current delay was 50. We may naively think that\n        // the earliest we could change the value would be at block 251 by scheduling immediately after the historical\n        // block, i.e. at block 201. But if there was a delay change scheduled for block 210 to reduce the delay to 20\n        // blocks, then if a value change was scheduled at block 210 it would go into effect at block 230, which is\n        // earlier than what we'd expect if we only considered the current delay.\n        let effective_minimum_delay =\n            delay_change.get_effective_minimum_delay_at(historical_block_number);\n        let block_horizon =\n            value_change.get_block_horizon(historical_block_number, effective_minimum_delay);\n\n        // We prevent this transaction from being included in any block after the block horizon, ensuring that the\n        // historical public value matches the current one, since it can only change after the horizon.\n        self.context.set_tx_max_block_number(block_horizon);\n        value_change.get_current_at(historical_block_number)\n    }\n\n    fn historical_read_from_public_storage<let N: u32>(\n        self,\n    ) -> (ScheduledValueChange<T>, ScheduledDelayChange<INITIAL_DELAY>, u32)\n    where\n        T: Packable<N>,\n    {\n        let header = self.context.get_block_header();\n        let address = self.context.this_address();\n\n        let historical_block_number = header.global_variables.block_number as u32;\n\n        let values: SharedMutableValues<T, INITIAL_DELAY> =\n            WithHash::historical_public_storage_read(header, address, self.storage_slot);\n\n        (values.svc, values.sdc, historical_block_number)\n    }\n}\n\nimpl<T, let INITIAL_DELAY: u32> SharedMutable<T, INITIAL_DELAY, UtilityContext>\nwhere\n    T: Eq,\n{\n    pub unconstrained fn get_current_value<let N: u32>(self) -> T\n    where\n        T: Packable<N>,\n    {\n        let smv: SharedMutableValues<T, INITIAL_DELAY> =\n            WithHash::utility_public_storage_read(self.context, self.storage_slot);\n\n        let block_number = self.context.block_number() as u32;\n        smv.svc.get_current_at(block_number)\n    }\n}\n"
     },
     "18": {
       "path": "std/field/mod.nr",
       "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n    /// Asserts that `self` can be represented in `bit_size` bits.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n    // docs:start:assert_max_bit_size\n    pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {\n        // docs:end:assert_max_bit_size\n        static_assert(\n            BIT_SIZE < modulus_num_bits() as u32,\n            \"BIT_SIZE must be less than modulus_num_bits\",\n        );\n        self.__assert_max_bit_size(BIT_SIZE);\n    }\n\n    #[builtin(apply_range_constraint)]\n    fn __assert_max_bit_size(self, bit_size: u32) {}\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n    /// This slice will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n    /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n    /// wrap around due to overflow when verifying the decomposition.\n    #[builtin(to_le_bits)]\n    fn _to_le_bits<let N: u32>(self: Self) -> [u1; N] {}\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n    /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n    /// wrap around due to overflow when verifying the decomposition.\n    #[builtin(to_be_bits)]\n    fn _to_be_bits<let N: u32>(self: Self) -> [u1; N] {}\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n    /// This slice will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_le_bits\n    pub fn to_le_bits<let N: u32>(self: Self) -> [u1; N] {\n        // docs:end:to_le_bits\n        let bits = self._to_le_bits();\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[N - 1 - i] != p[N - 1 - i]) {\n                        assert(p[N - 1 - i] == 1);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_be_bits\n    pub fn to_be_bits<let N: u32>(self: Self) -> [u1; N] {\n        // docs:end:to_be_bits\n        let bits = self._to_be_bits();\n\n        if !is_unconstrained() {\n            // Ensure that the decomposition does not overflow the modulus\n            let p = modulus_be_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[i] != p[i]) {\n                        assert(p[i] == 1);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_le_bytes\n    pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_le_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_le_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[N - 1 - i] != p[N - 1 - i]) {\n                        assert(bytes[N - 1 - i] < p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_be_bytes\n    pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_be_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_be_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_be_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[i] != p[i]) {\n                        assert(bytes[i] < p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    // docs:start:to_le_radix\n    pub fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        self.__to_le_radix(radix)\n    }\n    // docs:end:to_le_radix\n\n    // docs:start:to_be_radix\n    pub fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            crate::assert_constant(radix);\n        }\n        self.__to_be_radix(radix)\n    }\n    // docs:end:to_be_radix\n\n    // `_radix` must be less than 256\n    #[builtin(to_le_radix)]\n    fn __to_le_radix<let N: u32>(self, radix: u32) -> [u8; N] {}\n\n    // `_radix` must be less than 256\n    #[builtin(to_be_radix)]\n    fn __to_be_radix<let N: u32>(self, radix: u32) -> [u8; N] {}\n\n    // Returns self to the power of the given exponent value.\n    // Caution: we assume the exponent fits into 32 bits\n    // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n    pub fn pow_32(self, exponent: Field) -> Field {\n        let mut r: Field = 1;\n        let b: [u1; 32] = exponent.to_le_bits();\n\n        for i in 1..33 {\n            r *= r;\n            r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n        }\n        r\n    }\n\n    // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n    pub fn sgn0(self) -> u1 {\n        self as u1\n    }\n\n    pub fn lt(self, another: Field) -> bool {\n        if crate::compat::is_bn254() {\n            bn254_lt(self, another)\n        } else {\n            lt_fallback(self, another)\n        }\n    }\n\n    /// Convert a little endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n\n    /// Convert a big endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[N - 1 - i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n    __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..16 {\n        high = high + (bytes32[15 - i] as Field) * v;\n        low = low + (bytes32[16 + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    // Abuse that a % p + b % p = (a + b) % p and that low < p\n    low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unconstrained context\n        unsafe {\n            field_less_than(x, y)\n        }\n    } else {\n        let x_bytes: [u8; 32] = x.to_le_bytes();\n        let y_bytes: [u8; 32] = y.to_le_bytes();\n        let mut x_is_lt = false;\n        let mut done = false;\n        for i in 0..32 {\n            if (!done) {\n                let x_byte = x_bytes[32 - 1 - i] as u8;\n                let y_byte = y_bytes[32 - 1 - i] as u8;\n                let bytes_match = x_byte == y_byte;\n                if !bytes_match {\n                    x_is_lt = x_byte < y_byte;\n                    done = true;\n                }\n            }\n        }\n        x_is_lt\n    }\n}\n\nmod tests {\n    use crate::{panic::panic, runtime};\n    use super::field_less_than;\n\n    #[test]\n    // docs:start:to_be_bits_example\n    fn test_to_be_bits() {\n        let field = 2;\n        let bits: [u1; 8] = field.to_be_bits();\n        assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n    }\n    // docs:end:to_be_bits_example\n\n    #[test]\n    // docs:start:to_le_bits_example\n    fn test_to_le_bits() {\n        let field = 2;\n        let bits: [u1; 8] = field.to_le_bits();\n        assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n    }\n    // docs:end:to_le_bits_example\n\n    #[test]\n    // docs:start:to_be_bytes_example\n    fn test_to_be_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_be_bytes();\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_bytes_example\n\n    #[test]\n    // docs:start:to_le_bytes_example\n    fn test_to_le_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_le_bytes();\n        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_bytes_example\n\n    #[test]\n    // docs:start:to_be_radix_example\n    fn test_to_be_radix() {\n        // 259, in base 256, big endian, is [1, 3].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_be_radix(256);\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_radix_example\n\n    #[test]\n    // docs:start:to_le_radix_example\n    fn test_to_le_radix() {\n        // 259, in base 256, little endian, is [3, 1].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_le_radix(256);\n        assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_radix_example\n\n    #[test(should_fail_with = \"radix must be greater than 1\")]\n    fn test_to_le_radix_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(f\"radix must be greater than 1\");\n        }\n    }\n\n    // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n    //#[test]\n    //fn test_to_le_radix_brillig_1() {\n    //    // this test should only fail in constrained mode\n    //    if runtime::is_unconstrained() {\n    //        let field = 1;\n    //        let out: [u8; 8] = field.to_le_radix(1);\n    //        crate::println(out);\n    //        let expected = [0; 8];\n    //        assert(out == expected, \"unexpected result\");\n    //    }\n    //}\n\n    #[test(should_fail_with = \"radix must be a power of 2\")]\n    fn test_to_le_radix_3() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(3);\n        } else {\n            panic(f\"radix must be a power of 2\");\n        }\n    }\n\n    #[test]\n    fn test_to_le_radix_brillig_3() {\n        // this test should only fail in constrained mode\n        if runtime::is_unconstrained() {\n            let field = 1;\n            let out: [u8; 8] = field.to_le_radix(3);\n            let mut expected = [0; 8];\n            expected[0] = 1;\n            assert(out == expected, \"unexpected result\");\n        }\n    }\n\n    #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n    fn test_to_le_radix_512() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(512);\n        } else {\n            panic(f\"radix must be less than or equal to 256\")\n        }\n    }\n\n    // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n    //#[test]\n    //fn test_to_le_radix_brillig_512() {\n    //    // this test should only fail in constrained mode\n    //    if runtime::is_unconstrained() {\n    //        let field = 1;\n    //        let out: [u8; 8] = field.to_le_radix(512);\n    //        let mut expected = [0; 8];\n    //        expected[0] = 1;\n    //        assert(out == expected, \"unexpected result\");\n    //    }\n    //}\n\n    #[test]\n    unconstrained fn test_field_less_than() {\n        assert(field_less_than(0, 1));\n        assert(field_less_than(0, 0x100));\n        assert(field_less_than(0x100, 0 - 1));\n        assert(!field_less_than(0 - 1, 0));\n    }\n}\n"
     },
-    "182": {
+    "183": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/append.nr",
       "source": "/// Appends two `BoundedVec`s together, returning one that contains all of the elements of the first one followed by all\n/// of the elements of the second one. The resulting `BoundedVec` can have any arbitrary maximum length, but it must be\n/// large enough to fit all of the elements of both the first and second vectors.\npub fn append<T, let A_LEN: u32, let B_LEN: u32, let DST_LEN: u32>(\n    a: BoundedVec<T, A_LEN>,\n    b: BoundedVec<T, B_LEN>,\n) -> BoundedVec<T, DST_LEN> {\n    let mut dst = BoundedVec::new();\n\n    dst.extend_from_bounded_vec(a);\n    dst.extend_from_bounded_vec(b);\n\n    dst\n}\n\nmod test {\n    use super::append;\n\n    #[test]\n    unconstrained fn append_empty_vecs() {\n        let a: BoundedVec<_, 3> = BoundedVec::new();\n        let b: BoundedVec<_, 14> = BoundedVec::new();\n\n        let result: BoundedVec<Field, 5> = append(a, b);\n\n        assert_eq(result.len(), 0);\n        assert_eq(result.storage(), std::mem::zeroed());\n    }\n\n    #[test]\n    unconstrained fn append_non_empty_vecs() {\n        let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n        let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n        let result: BoundedVec<Field, 8> = append(a, b);\n\n        assert_eq(result.len(), 6);\n        assert_eq(result.storage(), [1, 2, 3, 4, 5, 6, std::mem::zeroed(), std::mem::zeroed()]);\n    }\n\n    #[test(should_fail_with = \"out of bounds\")]\n    unconstrained fn append_non_empty_vecs_insufficient_max_len() {\n        let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n        let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n        let _: BoundedVec<Field, 5> = append(a, b);\n    }\n}\n"
     },
-    "184": {
+    "185": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/mod.nr",
       "source": "pub mod append;\npub mod collapse;\npub mod subarray;\npub mod subbvec;\n\npub use append::append;\npub use collapse::collapse;\npub use subarray::subarray;\npub use subbvec::subbvec;\n\n// This will eventually be replaced by `BoundedVec::for_each`, once that's implemented.\npub unconstrained fn for_each_in_bounded_vec<T, let MaxLen: u32, Env>(\n    vec: BoundedVec<T, MaxLen>,\n    f: fn[Env](T, u32) -> (),\n) {\n    for i in 0..vec.len() {\n        f(vec.get_unchecked(i), i);\n    }\n}\n"
     },
-    "185": {
+    "186": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr",
       "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must not be larger than the number\n/// of elements past `offset`.\n///\n/// Examples:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n///\n/// let bar: [Field; 5] = subarray([1, 2, 3, 4, 5], 2); // fails - we can't return 5 elements since only 3 remain\n/// ```\npub fn subarray<T, let SRC_LEN: u32, let DST_LEN: u32>(\n    src: [T; SRC_LEN],\n    offset: u32,\n) -> [T; DST_LEN] {\n    assert(offset + DST_LEN <= SRC_LEN, \"DST_LEN too large for offset\");\n\n    let mut dst: [T; DST_LEN] = std::mem::zeroed();\n    for i in 0..DST_LEN {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\nmod test {\n    use super::subarray;\n\n    #[test]\n    unconstrained fn subarray_into_empty() {\n        // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n        assert_eq(subarray::<Field, _, _>([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n    }\n\n    #[test]\n    unconstrained fn subarray_complete() {\n        assert_eq(subarray::<Field, _, _>([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n    }\n\n    #[test]\n    unconstrained fn subarray_different_end_sizes() {\n        // We implicitly select how many values to read in the size of the return array\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n    }\n\n    #[test(should_fail_with = \"DST_LEN too large for offset\")]\n    unconstrained fn subarray_offset_too_large() {\n        // With an offset of 1 we can only request up to 4 elements\n        let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_bad_return_value() {\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n    }\n}\n"
     },
-    "186": {
+    "187": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subbvec.nr",
       "source": "use crate::utils::array;\n\n/// Returns `DST_MAX_LEN` elements from a source BoundedVec, starting at `offset`. `offset` must not be larger than the\n/// original length, and `DST_LEN` must not be larger than the total number of elements past `offset` (including the\n/// zeroed elements past `len()`).\n///\n/// Only elements at the beginning of the vector can be removed: it is not possible to also remove elements at the end\n/// of the vector by passing a value for `DST_LEN` that is smaller than `len() - offset`.\n///\n/// Examples:\n/// ```\n/// let foo = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n/// assert_eq(subbvec(foo, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n///\n/// let bar: BoundedVec<_, 1> = subbvec(foo, 2); // fails - we can't return just 1 element since 3 remain\n/// let baz: BoundedVec<_, 10> = subbvec(foo, 3); // fails - we can't return 10 elements since only 7 remain\n/// ```\npub fn subbvec<T, let SRC_MAX_LEN: u32, let DST_MAX_LEN: u32>(\n    bvec: BoundedVec<T, SRC_MAX_LEN>,\n    offset: u32,\n) -> BoundedVec<T, DST_MAX_LEN> {\n    // from_parts_unchecked does not verify that the elements past len are zeroed, but that is not an issue in our case\n    // because we're constructing the new storage array as a subarray of the original one (which should have zeroed\n    // storage past len), guaranteeing correctness. This is because `subarray` does not allow extending arrays past\n    // their original length.\n    BoundedVec::from_parts_unchecked(array::subarray(bvec.storage(), offset), bvec.len() - offset)\n}\n\nmod test {\n    use super::subbvec;\n\n    #[test]\n    unconstrained fn subbvec_empty() {\n        let bvec = BoundedVec::<Field, 0>::from_array([]);\n        assert_eq(subbvec(bvec, 0), bvec);\n    }\n\n    #[test]\n    unconstrained fn subbvec_complete() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 0), bvec);\n\n        let smaller_capacity = BoundedVec::<_, 5>::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 0), smaller_capacity);\n    }\n\n    #[test]\n    unconstrained fn subbvec_partial() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        assert_eq(subbvec(bvec, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n        assert_eq(subbvec(bvec, 2), BoundedVec::<_, 3>::from_array([3, 4, 5]));\n    }\n\n    #[test]\n    unconstrained fn subbvec_into_empty() {\n        let bvec: BoundedVec<_, 10> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 5), BoundedVec::<_, 5>::from_array([]));\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subbvec_offset_past_len() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n        let _: BoundedVec<_, 1> = subbvec(bvec, 6);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subbvec_insufficient_dst_len() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // We're not providing enough space to hold all of the items inside the original BoundedVec. subbvec can cause\n        // for the capacity to reduce, but not the length (other than by len - offset).\n        let _: BoundedVec<_, 1> = subbvec(bvec, 2);\n    }\n\n    #[test(should_fail_with = \"DST_LEN too large for offset\")]\n    unconstrained fn subbvec_dst_len_causes_enlarge() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // subbvec does not supprt capacity increases\n        let _: BoundedVec<_, 11> = subbvec(bvec, 0);\n    }\n\n    #[test(should_fail_with = \"DST_LEN too large for offset\")]\n    unconstrained fn subbvec_dst_len_too_large_for_offset() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // This effectively requests a capacity increase, since there'd be just one element plus the 5 empty slots,\n        // which is less than 7.\n        let _: BoundedVec<_, 7> = subbvec(bvec, 4);\n    }\n}\n"
     },
-    "188": {
+    "189": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/conversion/bytes_to_fields.nr",
       "source": "use std::static_assert;\n\n// These functions are used to facilitate the conversion of log ciphertext between byte and field representations.\n//\n// `bytes_to_fields` uses fixed-size arrays since encryption contexts have compile-time size information.\n// `bytes_from_fields` uses BoundedVec for flexibility in unconstrained contexts where sizes are dynamic.\n//\n// Together they provide bidirectional conversion between bytes and fields when processing encrypted logs.\n\n/// Converts the input bytes into an array of fields. A Field is ~254 bits meaning that each field can store 31 whole\n/// bytes. Use `bytes_from_fields` to obtain the original bytes array.\n///\n/// The input bytes are chunked into chunks of 31 bytes. Each 31-byte chunk is viewed as big-endian, and is converted\n/// into a Field.\n/// For example, [1, 10, 3, ..., 0] (31 bytes) is encoded as [1 * 256^30 + 10 * 256^29 + 3 * 256^28 + ... + 0]\n/// Note: N must be a multiple of 31 bytes\npub fn bytes_to_fields<let N: u32>(bytes: [u8; N]) -> [Field; N / 31] {\n    // Assert that N is a multiple of 31\n    static_assert(N % 31 == 0, \"N must be a multiple of 31\");\n\n    let mut fields = [0; N / 31];\n\n    // Since N is a multiple of 31, we can simply process all chunks fully\n    for i in 0..N / 31 {\n        let mut field = 0;\n        for j in 0..31 {\n            // Shift the existing value left by 8 bits and add the new byte\n            field = field * 256 + bytes[i * 31 + j] as Field;\n        }\n        fields[i] = field;\n    }\n\n    fields\n}\n\n/// Converts an input BoundedVec of fields into a BoundedVec of bytes in big-endian order. Arbitrary Field arrays\n/// are not allowed: this is assumed to be an array obtained via `bytes_to_fields`, i.e. one that actually represents\n/// bytes. To convert a Field array into bytes, use `fields_to_bytes`.\n///\n/// Each input field must contain at most 31 bytes (this is constrained to be so).\n/// Each field is converted into 31 big-endian bytes, and the resulting 31-byte chunks are concatenated\n/// back together in the order of the original fields.\npub fn bytes_from_fields<let N: u32>(fields: BoundedVec<Field, N>) -> BoundedVec<u8, N * 31> {\n    let mut bytes = BoundedVec::new();\n\n    for i in 0..fields.len() {\n        let field = fields.get(i);\n\n        // We expect that the field contains at most 31 bytes of information.\n        field.assert_max_bit_size::<248>();\n\n        // Now we can safely convert the field to 31 bytes.\n        let field_as_bytes: [u8; 31] = field.to_be_bytes();\n\n        for j in 0..31 {\n            bytes.push(field_as_bytes[j]);\n        }\n    }\n\n    bytes\n}\n\nmod tests {\n    use crate::utils::array::subarray;\n    use super::{bytes_from_fields, bytes_to_fields};\n\n    #[test]\n    unconstrained fn random_bytes_to_fields_and_back(input: [u8; 93]) {\n        let fields = bytes_to_fields(input);\n\n        // At this point in production, the log flies through the system and we get a BoundedVec on the other end.\n        // So we need to convert the field array to a BoundedVec to be able to feed it to the `bytes_from_fields`\n        // function.\n        let fields_as_bounded_vec = BoundedVec::<_, 6>::from_array(fields);\n\n        let bytes_back = bytes_from_fields(fields_as_bounded_vec);\n\n        // Compare the original input with the round-tripped result\n        assert_eq(bytes_back.len(), input.len());\n        assert_eq(subarray(bytes_back.storage(), 0), input);\n    }\n\n    #[test(should_fail_with = \"N must be a multiple of 31\")]\n    unconstrained fn bytes_to_fields_input_length_not_multiple_of_31() {\n        // Try to convert 32 bytes (not a multiple of 31) to fields\n        let _fields = bytes_to_fields([0; 32]);\n    }\n\n}\n"
     },
-    "189": {
+    "190": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/conversion/fields_to_bytes.nr",
       "source": "// These functions are used to facilitate the conversion of log plaintext represented as fields into bytes and back.\n//\n// `fields_to_bytes` uses fixed-size arrays since encryption contexts have compile-time size information.\n// `fields_from_bytes` uses BoundedVec for flexibility in unconstrained contexts where sizes are dynamic.\n//\n// Together they provide bidirectional conversion between fields and bytes.\n\n/// Converts an input array of fields into a single array of bytes. Use `fields_from_bytes` to obtain the original\n/// field array.\n/// Each field is converted to a 32-byte big-endian array.\n///\n/// For example, if you have a field array [123, 456], it will be converted to a 64-byte array:\n/// [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,123,  // First field (32 bytes)\n///  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,200]  // Second field (32 bytes)\n///\n/// Since a field is ~254 bits, you'll end up with a subtle 2-bit \"gap\" at the big end, every 32 bytes. Be careful\n/// that such a gap doesn't leak information! This could happen if you for example expected the output to be\n/// indistinguishable from random bytes.\npub fn fields_to_bytes<let N: u32>(fields: [Field; N]) -> [u8; 32 * N] {\n    let mut bytes = [0; 32 * N];\n\n    for i in 0..N {\n        let field_as_bytes: [u8; 32] = fields[i].to_be_bytes();\n\n        for j in 0..32 {\n            bytes[i * 32 + j] = field_as_bytes[j];\n        }\n    }\n\n    bytes\n}\n\n/// Converts an input BoundedVec of bytes into a BoundedVec of fields. Arbitrary byte arrays are not allowed: this\n/// is assumed to be an array obtained via `fields_to_bytes`, i.e. one that actually represents fields. To convert\n/// a byte array into Fields, use `bytes_to_fields`.\n///\n/// The input bytes are chunked into chunks of 32 bytes. Each 32-byte chunk is viewed as big-endian, and is converted\n/// into a Field.\n/// For example, [1, 10, 3, ..., 0] (32 bytes) is encoded as [1 * 256^31 + 10 * 256^30 + 3 * 256^29 + ... + 0]\n/// Note 1: N must be a multiple of 32 bytes\n/// Note 2: The max value check code was taken from std::field::to_be_bytes function.\npub fn fields_from_bytes<let N: u32>(bytes: BoundedVec<u8, N>) -> BoundedVec<Field, N / 32> {\n    // Assert that input length is a multiple of 32\n    assert(bytes.len() % 32 == 0, \"Input length must be a multiple of 32\");\n\n    let mut fields = BoundedVec::new();\n\n    let p = std::field::modulus_be_bytes();\n\n    // Since input length is a multiple of 32, we can simply process all chunks fully\n    for i in 0..bytes.len() / 32 {\n        let mut field = 0;\n\n        // Process each byte in the 32-byte chunk\n        let mut ok = false;\n\n        for j in 0..32 {\n            let next_byte = bytes.get(i * 32 + j);\n            field = field * 256 + next_byte as Field;\n\n            if !ok {\n                if next_byte != p[j] {\n                    assert(next_byte < p[j], \"Value does not fit in field\");\n                    ok = true;\n                }\n            }\n        }\n        assert(ok, \"Value does not fit in field\");\n\n        fields.push(field);\n    }\n\n    fields\n}\n\nmod tests {\n    use crate::utils::array::subarray;\n    use super::{fields_from_bytes, fields_to_bytes};\n\n    #[test]\n    unconstrained fn random_fields_to_bytes_and_back(input: [Field; 3]) {\n        // Convert to bytes\n        let bytes = fields_to_bytes(input);\n\n        // At this point in production, the log flies through the system and we get a BoundedVec on the other end.\n        // So we need to convert the field array to a BoundedVec to be able to feed it to the `fields_from_bytes`\n        // function.\n        // 113 is an arbitrary max length that is larger than the input length of 96.\n        let bytes_as_bounded_vec = BoundedVec::<_, 113>::from_array(bytes);\n\n        // Convert back to fields\n        let fields_back = fields_from_bytes(bytes_as_bounded_vec);\n\n        // Compare the original input with the round-tripped result\n        assert_eq(fields_back.len(), input.len());\n        assert_eq(subarray(fields_back.storage(), 0), input);\n    }\n\n    #[test(should_fail_with = \"Input length must be a multiple of 32\")]\n    unconstrained fn to_fields_assert() {\n        // 143 is an arbitrary max length that is larger than 33\n        let input = BoundedVec::<_, 143>::from_array([\n            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,\n        ]);\n\n        // This should fail since 33 is not a multiple of 32\n        let _fields = fields_from_bytes(input);\n    }\n\n    #[test]\n    unconstrained fn fields_from_bytes_max_value() {\n        let max_field_as_bytes: [u8; 32] = (-1).to_be_bytes();\n        let input = BoundedVec::<_, 32>::from_array(max_field_as_bytes);\n\n        let fields = fields_from_bytes(input);\n\n        // The result should be a largest value storable in a field (-1 since we are modulo-ing)\n        assert_eq(fields.get(0), -1);\n    }\n\n    // In this test we verify that overflow check works by taking the max allowed value, bumping a random byte\n    // and then feeding it to `fields_from_bytes` as input.\n    #[test(should_fail_with = \"Value does not fit in field\")]\n    unconstrained fn fields_from_bytes_overflow(random_value: u8) {\n        let index_of_byte_to_bump = random_value % 32;\n\n        // Obtain the byte representation of the maximum field value\n        let max_field_value_as_bytes: [u8; 32] = (-1).to_be_bytes();\n\n        let byte_to_bump = max_field_value_as_bytes[index_of_byte_to_bump];\n\n        // Skip test execution if the selected byte is already at maximum value (255).\n        // This is acceptable since we are using fuzz testing to generate many test cases.\n        if byte_to_bump != 255 {\n            let mut input = BoundedVec::<_, 32>::from_array(max_field_value_as_bytes);\n\n            // Increment the selected byte to exceed the field's maximum value\n            input.set(index_of_byte_to_bump as u32, byte_to_bump + 1);\n\n            // Attempt the conversion, which should fail due to the value exceeding the field's capacity\n            let _fields = fields_from_bytes(input);\n        }\n    }\n\n}\n"
     },
-    "191": {
+    "192": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/field.nr",
       "source": "use std::option::Option;\n\nglobal KNOWN_NON_RESIDUE: Field = 5; // This is a non-residue in Noir's native Field.\n\nglobal C1: u32 = 28;\nglobal C3: Field = 40770029410420498293352137776570907027550720424234931066070132305055;\nglobal C5: Field = 19103219067921713944291392827692070036145651957329286315305642004821462161904;\n\n// Power function of two Field arguments of arbitrary size.\n// Adapted from std::field::pow_32.\npub fn pow(x: Field, y: Field) -> Field {\n    let mut r = 1 as Field;\n    let b: [u1; 254] = y.to_le_bits();\n\n    for i in 0..254 {\n        r *= r;\n        r *= (b[254 - 1 - i] as Field) * x + (1 - b[254 - 1 - i] as Field);\n    }\n\n    r\n}\n\n// Boolean indicating whether Field element is a square, i.e. whether there exists a y in Field s.t. x = y*y.\nunconstrained fn is_square(x: Field) -> bool {\n    let v = pow(x, -1 / 2);\n    v * (v - 1) == 0\n}\n\n// Tonelli-Shanks algorithm for computing the square root of a Field element.\n// Requires C1 = max{c: 2^c divides (p-1)}, where p is the order of Field\n// as well as C3 = (C2 - 1)/2, where C2 = (p-1)/(2^c1),\n// and C5 = ZETA^C2, where ZETA is a non-square element of Field.\n// These are pre-computed above as globals.\nunconstrained fn tonelli_shanks_sqrt(x: Field) -> Field {\n    let mut z = pow(x, C3);\n    let mut t = z * z * x;\n    z *= x;\n    let mut b = t;\n    let mut c = C5;\n\n    for i in 0..(C1 - 1) {\n        for _j in 1..(C1 - i - 1) {\n            b *= b;\n        }\n\n        z *= if b == 1 { 1 } else { c };\n\n        c *= c;\n\n        t *= if b == 1 { 1 } else { c };\n\n        b = t;\n    }\n\n    z\n}\n\n// NB: this doesn't return an option, because in the case of there _not_ being a square root, we still want to return a field element that allows us to then assert in the _constrained_ sqrt function that there is no sqrt.\npub unconstrained fn __sqrt(x: Field) -> (bool, Field) {\n    let is_sq = is_square(x);\n    if is_sq {\n        let sqrt = tonelli_shanks_sqrt(x);\n        (true, sqrt)\n    } else {\n        // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n        // Facts:\n        // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n        // - If x is a square, LS(x) = 1\n        // - If x is not a square, LS(x) = -1\n        // - If x = 0, LS(x) = 0.\n        //\n        // Hence:\n        // sq * sq = sq // 1 * 1 = 1\n        // non-sq * non-sq = sq // -1 * -1 = 1\n        // sq * non-sq = non-sq // -1 * 1 = -1\n        //\n        // See: https://en.wikipedia.org/wiki/Legendre_symbol\n        let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n        let not_sqrt = tonelli_shanks_sqrt(demo_x_not_square);\n        (false, not_sqrt)\n    }\n}\n\n// Returns (false, 0) if there is no square root.\n// Returns (true, sqrt) if there is a square root.\npub fn sqrt(x: Field) -> Option<Field> {\n    // Safety: if the hint returns the square root of x, then we simply square it\n    // check the result equals x. If x is not square, we return a value that\n    // enables us to prove that fact (see the `else` clause below).\n    let (is_sq, maybe_sqrt) = unsafe { __sqrt(x) };\n\n    if is_sq {\n        let sqrt = maybe_sqrt;\n        validate_sqrt_hint(x, sqrt);\n        Option::some(sqrt)\n    } else {\n        let not_sqrt_hint = maybe_sqrt;\n        validate_not_sqrt_hint(x, not_sqrt_hint);\n        Option::none()\n    }\n}\n\nfn validate_sqrt_hint(x: Field, hint: Field) {\n    assert(hint * hint == x, f\"The claimed_sqrt {hint} is not the sqrt of x {x}\");\n}\n\nfn validate_not_sqrt_hint(x: Field, hint: Field) {\n    // We need this assertion, because x = 0 would pass the other assertions in this\n    // function, and we don't want people to be able to prove that 0 is not square!\n    assert(x != 0, \"0 has a square root; you cannot claim it is not square\");\n    // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n    //\n    // Facts:\n    // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n    // - If x is a square, LS(x) = 1\n    // - If x is not a square, LS(x) = -1\n    // - If x = 0, LS(x) = 0.\n    //\n    // Hence:\n    // 1. sq * sq = sq // 1 * 1 = 1\n    // 2. non-sq * non-sq = sq // -1 * -1 = 1\n    // 3. sq * non-sq = non-sq // -1 * 1 = -1\n    //\n    // See: https://en.wikipedia.org/wiki/Legendre_symbol\n    //\n    // We want to demonstrate that this below multiplication falls under bullet-point (2):\n    let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n    // I.e. we want to demonstrate that `demo_x_not_square` has Legendre symbol 1\n    // (i.e. that it is a square), so we prove that it is square below.\n    // Why do we want to prove that it has LS 1?\n    // Well, since it was computed with a known-non-residue, its squareness implies we're\n    // in case 2 (something multiplied by a known-non-residue yielding a result which\n    // has a LS of 1), which implies that x must be a non-square. The unconstrained\n    // function gave us the sqrt of demo_x_not_square, so all we need to do is\n    // assert its squareness:\n    assert(\n        hint * hint == demo_x_not_square,\n        f\"The hint {hint} does not demonstrate that {x} is not a square\",\n    );\n}\n\n#[test]\nfn test_sqrt() {\n    let x = 9;\n    let maybe_sqrt = sqrt(x);\n    assert(maybe_sqrt.is_some());\n    let sqrt = maybe_sqrt.unwrap_unchecked();\n    assert((sqrt == 3) | (sqrt == -3));\n}\n\n#[test]\nfn test_non_square() {\n    let x = 5;\n    let maybe_sqrt = sqrt(x);\n    assert(maybe_sqrt.is_none());\n}\n\n#[test]\nunconstrained fn test_known_non_residue_is_actually_a_non_residue_in_the_field() {\n    assert(!is_square(KNOWN_NON_RESIDUE));\n}\n\n#[test]\nfn test_sqrt_0() {\n    let x = 0;\n    let sqrt = sqrt(x).unwrap();\n    assert(sqrt == 0);\n}\n\n#[test]\nfn test_sqrt_1() {\n    let x = 1;\n    let sqrt = sqrt(x).unwrap();\n    assert((sqrt == 1) | (sqrt == -1));\n}\n\n#[test(should_fail_with = \"The claimed_sqrt 0x04 is not the sqrt of x 0x09\")]\nfn test_bad_sqrt_hint_fails() {\n    validate_sqrt_hint(9, 4);\n}\n\n#[test(should_fail_with = \"The hint 0x04 does not demonstrate that 0x0a is not a square\")]\nfn test_bad_not_sqrt_hint_fails() {\n    validate_not_sqrt_hint(10, 4);\n}\n\n#[test(should_fail_with = \"0 has a square root; you cannot claim it is not square\")]\nfn test_0_not_sqrt_hint_fails() {\n    validate_not_sqrt_hint(0, 0);\n}\n\n#[test]\nunconstrained fn test_is_square() {\n    assert(is_square(25));\n}\n\n#[test]\nunconstrained fn test_is_not_square() {\n    assert(!is_square(10));\n}\n"
     },
-    "193": {
+    "194": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/point.nr",
       "source": "use crate::utils::field::sqrt;\nuse dep::protocol_types::point::Point;\n\n// I am storing the modulus minus 1 divided by 2 here because full modulus would throw \"String literal too large\" error\n// Full modulus is 21888242871839275222246405745257275088548364400416034343698204186575808495617\nglobal BN254_FR_MODULUS_DIV_2: Field =\n    10944121435919637611123202872628637544274182200208017171849102093287904247808;\n\n/// Converts a point to a byte array.\n///\n/// We don't serialize the point at infinity flag because this function is used in situations where we do not want\n/// to waste the extra byte (encrypted log).\npub fn point_to_bytes(p: Point) -> [u8; 32] {\n    // Note that there is 1 more free bit in the 32 bytes (254 bits currently occupied by the x coordinate, 1 bit for\n    // the \"sign\") so it's possible to use that last bit as an \"is_infinite\" flag if desired in the future.\n    assert(!p.is_infinite, \"Cannot serialize point at infinity as bytes.\");\n\n    let mut result: [u8; 32] = p.x.to_be_bytes();\n\n    if get_sign_of_point(p) {\n        // y is <= (modulus - 1) / 2 so we set the sign bit to 1\n        // Here we leverage that field fits into 254 bits (log2(Fr.MODULUS) < 254) and given that we serialize Fr to 32\n        // bytes and we use big-endian the 2 most significant bits are never populated. Hence we can use one of\n        // the bits as a sign bit.\n        result[0] += 128;\n    }\n\n    result\n}\n\n/**\n * Returns: true if p.y <= MOD_DIV_2, else false.\n */\npub fn get_sign_of_point(p: Point) -> bool {\n    // We store only a \"sign\" of the y coordinate because the rest can be derived from the x coordinate. To get\n    // the sign we check if the y coordinate is less or equal than the curve's order minus 1 divided by 2.\n    // Ideally we'd do `y <= MOD_DIV_2`, but there's no `lte` function, so instead we do `!(y > MOD_DIV_2)`, which is\n    // equivalent, and then rewrite that as `!(MOD_DIV_2 < y)`, since we also have no `gt` function.\n    !BN254_FR_MODULUS_DIV_2.lt(p.y)\n}\n\npub fn point_from_x_coord(x: Field) -> Point {\n    // y ^ 2 = x ^ 3 - 17\n    let rhs = x * x * x - 17;\n    let y = sqrt(rhs).unwrap();\n    Point { x, y, is_infinite: false }\n}\n\n/// Uses the x coordinate and sign flag (+/-) to reconstruct the point.\n/// The y coordinate can be derived from the x coordinate and the \"sign\" flag by solving the grumpkin curve\n/// equation for y.\n/// @param x - The x coordinate of the point\n/// @param sign - The \"sign\" of the y coordinate - determines whether y <= (Fr.MODULUS - 1) / 2\npub fn point_from_x_coord_and_sign(x: Field, sign: bool) -> Point {\n    // y ^ 2 = x ^ 3 - 17\n    let rhs = x * x * x - 17;\n    let y = sqrt(rhs).unwrap();\n\n    // If y > MOD_DIV_2 and we want positive sign (or vice versa), negate y\n    let y_is_positive = !BN254_FR_MODULUS_DIV_2.lt(y);\n    let final_y = if y_is_positive == sign { y } else { -y };\n\n    Point { x, y: final_y, is_infinite: false }\n}\n\nmod test {\n    use crate::utils::point::{point_from_x_coord_and_sign, point_to_bytes};\n    use dep::protocol_types::point::Point;\n\n    #[test]\n    unconstrained fn test_point_to_bytes_positive_sign() {\n        let p = Point {\n            x: 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73,\n            y: 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a,\n            is_infinite: false,\n        };\n\n        let compressed_point = point_to_bytes(p);\n\n        let expected_compressed_point_positive_sign = [\n            154, 244, 31, 93, 233, 100, 70, 220, 55, 118, 161, 235, 45, 152, 187, 149, 107, 122,\n            205, 153, 121, 166, 120, 84, 190, 198, 250, 124, 41, 115, 189, 115,\n        ];\n        assert_eq(expected_compressed_point_positive_sign, compressed_point);\n    }\n\n    #[test]\n    unconstrained fn test_point_to_bytes_negative_sign() {\n        let p = Point {\n            x: 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5,\n            y: 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0,\n            is_infinite: false,\n        };\n\n        let compressed_point = point_to_bytes(p);\n\n        let expected_compressed_point_negative_sign = [\n            36, 115, 113, 101, 46, 85, 221, 116, 201, 175, 141, 190, 159, 180, 73, 49, 186, 41, 169,\n            34, 153, 148, 56, 75, 215, 7, 119, 150, 193, 78, 226, 181,\n        ];\n\n        assert_eq(expected_compressed_point_negative_sign, compressed_point);\n    }\n\n    #[test]\n    unconstrained fn test_point_from_x_coord_and_sign() {\n        // Test positive y coordinate\n        let x = 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73;\n        let sign = true;\n        let p = point_from_x_coord_and_sign(x, sign);\n\n        assert_eq(p.x, x);\n        assert_eq(p.y, 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a);\n        assert_eq(p.is_infinite, false);\n\n        // Test negative y coordinate\n        let x2 = 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5;\n        let sign2 = false;\n        let p2 = point_from_x_coord_and_sign(x2, sign2);\n\n        assert_eq(p2.x, x2);\n        assert_eq(p2.y, 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0);\n        assert_eq(p2.is_infinite, false);\n    }\n}\n"
     },
-    "197": {
+    "198": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/with_hash.nr",
-      "source": "use crate::{\n    context::{PublicContext, UnconstrainedContext},\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 unconstrained_public_storage_read(\n        context: UnconstrainedContext,\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"
+      "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"
     },
-    "213": {
+    "214": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/abis/event_selector.nr",
       "source": "use crate::traits::{Deserialize, Empty, FromField, Serialize, ToField};\n\npub struct EventSelector {\n    // 1st 4-bytes (big-endian leftmost) of abi-encoding of an event.\n    inner: u32,\n}\n\nimpl Eq for EventSelector {\n    fn eq(self, other: EventSelector) -> bool {\n        other.inner == self.inner\n    }\n}\n\nimpl Serialize<1> for EventSelector {\n    fn serialize(self: Self) -> [Field; 1] {\n        [self.inner as Field]\n    }\n}\n\nimpl Deserialize<1> for EventSelector {\n    fn deserialize(fields: [Field; 1]) -> Self {\n        Self { inner: fields[0] as u32 }\n    }\n}\n\nimpl FromField for EventSelector {\n    fn from_field(field: Field) -> Self {\n        Self { inner: field as u32 }\n    }\n}\n\nimpl ToField for EventSelector {\n    fn to_field(self) -> Field {\n        self.inner as Field\n    }\n}\n\nimpl Empty for EventSelector {\n    fn empty() -> Self {\n        Self { inner: 0 as u32 }\n    }\n}\n\nimpl EventSelector {\n    pub fn from_u32(value: u32) -> Self {\n        Self { inner: value }\n    }\n\n    pub fn from_signature<let N: u32>(signature: str<N>) -> Self {\n        let bytes = signature.as_bytes();\n        let hash = crate::hash::poseidon2_hash_bytes(bytes);\n\n        // `hash` is automatically truncated to fit within 32 bits.\n        EventSelector::from_field(hash)\n    }\n\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n}\n"
     },
@@ -2941,75 +2943,75 @@
       "path": "std/hash/poseidon2.nr",
       "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = crate::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: &[] }\n    }\n}\n"
     },
-    "258": {
+    "259": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
       "source": "use crate::{\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, GENERATOR_INDEX__CONTRACT_ADDRESS_V1, MAX_FIELD_VALUE,\n        MAX_PROTOCOL_CONTRACTS,\n    },\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n    traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n    utils::field::{pow, sqrt},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n    embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n    ops::Add,\n};\n\n// Aztec address\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        FromField::from_field(fields[0])\n    }\n}\n\n/// We implement the Packable trait for AztecAddress because it can be stored in contract's storage (and there\n/// the implementation of Packable is required).\nimpl Packable<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn pack(self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        self.serialize()\n    }\n\n    fn unpack(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        Self::deserialize(fields)\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secret can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_class_id(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_protocol_contract(self) -> bool {\n        self.inner.lt(MAX_PROTOCOL_CONTRACTS as Field)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
     },
-    "261": {
+    "262": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/partial_address.nr",
       "source": "use crate::{\n    address::{aztec_address::AztecAddress, salted_initialization_hash::SaltedInitializationHash},\n    constants::GENERATOR_INDEX__PARTIAL_ADDRESS,\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    traits::{Deserialize, Serialize, ToField},\n};\n\nglobal PARTIAL_ADDRESS_LENGTH: u32 = 1;\n\n// Partial address\npub struct PartialAddress {\n    pub inner: Field,\n}\n\nimpl ToField for PartialAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl Serialize<PARTIAL_ADDRESS_LENGTH> for PartialAddress {\n    fn serialize(self: Self) -> [Field; PARTIAL_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<PARTIAL_ADDRESS_LENGTH> for PartialAddress {\n    fn deserialize(fields: [Field; PARTIAL_ADDRESS_LENGTH]) -> Self {\n        PartialAddress { inner: fields[0] }\n    }\n}\n\nimpl PartialAddress {\n    pub fn from_field(field: Field) -> Self {\n        Self { inner: field }\n    }\n\n    pub fn compute(\n        contract_class_id: ContractClassId,\n        salt: Field,\n        initialization_hash: Field,\n        deployer: AztecAddress,\n    ) -> Self {\n        PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            SaltedInitializationHash::compute(salt, initialization_hash, deployer),\n        )\n    }\n\n    pub fn compute_from_salted_initialization_hash(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n    ) -> Self {\n        PartialAddress::from_field(poseidon2_hash_with_separator(\n            [contract_class_id.to_field(), salted_initialization_hash.to_field()],\n            GENERATOR_INDEX__PARTIAL_ADDRESS,\n        ))\n    }\n\n    pub fn to_field(self) -> Field {\n        self.inner\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.to_field() == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n"
     },
-    "263": {
+    "264": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/salted_initialization_hash.nr",
       "source": "use crate::{\n    address::aztec_address::AztecAddress, constants::GENERATOR_INDEX__PARTIAL_ADDRESS,\n    hash::poseidon2_hash_with_separator, traits::ToField,\n};\n\n// Salted initialization hash. Used in the computation of a partial address.\npub struct SaltedInitializationHash {\n    pub inner: Field,\n}\n\nimpl ToField for SaltedInitializationHash {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl SaltedInitializationHash {\n    pub fn from_field(field: Field) -> Self {\n        Self { inner: field }\n    }\n\n    pub fn compute(salt: Field, initialization_hash: Field, deployer: AztecAddress) -> Self {\n        SaltedInitializationHash::from_field(poseidon2_hash_with_separator(\n            [salt, initialization_hash, deployer.to_field()],\n            GENERATOR_INDEX__PARTIAL_ADDRESS,\n        ))\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n"
     },
-    "267": {
+    "268": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/contract_class_id.nr",
       "source": "use crate::constants::GENERATOR_INDEX__CONTRACT_LEAF;\nuse crate::traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField};\n\npub struct ContractClassId {\n    pub inner: Field,\n}\n\nimpl Eq for ContractClassId {\n    fn eq(self, other: ContractClassId) -> bool {\n        other.inner == self.inner\n    }\n}\n\nimpl ToField for ContractClassId {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for ContractClassId {\n    fn from_field(value: Field) -> Self {\n        Self { inner: value }\n    }\n}\n\nimpl Serialize<1> for ContractClassId {\n    fn serialize(self: Self) -> [Field; 1] {\n        [self.inner]\n    }\n}\n\nimpl Deserialize<1> for ContractClassId {\n    fn deserialize(fields: [Field; 1]) -> Self {\n        Self { inner: fields[0] }\n    }\n}\n\nimpl Empty for ContractClassId {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\n// Implement the Packable trait so ContractClassId can be stored in contract's storage.\nimpl Packable<1> for ContractClassId {\n    fn pack(self) -> [Field; 1] {\n        self.serialize()\n    }\n\n    fn unpack(fields: [Field; 1]) -> Self {\n        Self::deserialize(fields)\n    }\n}\n\nimpl ContractClassId {\n    pub fn compute(\n        artifact_hash: Field,\n        private_functions_root: Field,\n        public_bytecode_commitment: Field,\n    ) -> Self {\n        let hash = crate::hash::poseidon2_hash_with_separator(\n            [artifact_hash, private_functions_root, public_bytecode_commitment],\n            GENERATOR_INDEX__CONTRACT_LEAF,\n        ); // TODO(@spalladino): Update generator index\n        ContractClassId::from_field(hash)\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n"
     },
-    "275": {
+    "276": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
       "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n///   debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n///   debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n///   debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper<let M: u32, let N: u32>(\n    msg: str<M>,\n    args: [Field; N],\n) {\n    debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle<let M: u32>(_msg: str<M>, args: [Field]) {}\n"
     },
-    "276": {
+    "277": {
       "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"
     },
-    "290": {
+    "291": {
       "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"
     },
-    "293": {
+    "294": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
       "source": "use crate::constants::TWO_POW_64;\n\n// NB: This is a clone of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr\n// It exists as we sometimes need to perform custom absorption, but the stdlib version\n// has a private absorb() method (it's also designed to just be a hasher)\n// Can be removed when standalone noir poseidon lib exists: See noir#6679\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2Sponge {\n    pub cache: [Field; 3],\n    pub state: [Field; 4],\n    pub cache_size: u32,\n    pub squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2Sponge {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2Sponge::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2Sponge {\n        let mut result =\n            Poseidon2Sponge { 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 = std::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    pub 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    pub 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 iv: Field = (in_len as Field) * TWO_POW_64;\n        let mut sponge = Poseidon2Sponge::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"
     },
-    "302": {
+    "303": {
       "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"
     },
-    "306": {
+    "307": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/shared_mutable/scheduled_delay_change.nr",
       "source": "use crate::traits::Empty;\nuse std::cmp::min;\n\nmod test;\n\n// This data structure is used by SharedMutable to store the minimum delay with which a ScheduledValueChange object can\n// schedule a change.\n// This delay is initially equal to INITIAL_DELAY, and can be safely mutated to any other value over time. This mutation\n// is performed via `schedule_change` in order to satisfy ScheduleValueChange constraints: if e.g. we allowed for the\n// delay to be decreased immediately then it'd be possible for the state variable to schedule a value change with a\n// reduced delay, invalidating prior private reads.\npub struct ScheduledDelayChange<let INITIAL_DELAY: u32> {\n    // Both pre and post are stored in public storage, so by default they are zeroed. By wrapping them in an Option,\n    // they default to Option::none(), which we detect and replace with INITIAL_DELAY. The end result is that a\n    // ScheduledDelayChange that has not been initialized has a delay equal to INITIAL_DELAY, which is the desired\n    // effect. Once initialized, the Option will never be none again.\n    pub(crate) pre: Option<u32>,\n    pub(crate) post: Option<u32>,\n    // Block at which `post` value is used instead of `pre`\n    pub(crate) block_of_change: u32,\n}\n\nimpl<let INITIAL_DELAY: u32> ScheduledDelayChange<INITIAL_DELAY> {\n    pub fn new(pre: Option<u32>, post: Option<u32>, block_of_change: u32) -> Self {\n        Self { pre, post, block_of_change }\n    }\n\n    /// Returns the current value of the delay stored in the data structure.\n    /// This function only returns a meaningful value when called in public with the current block number - for\n    /// historical private reads use `get_effective_minimum_delay_at` instead.\n    pub fn get_current(self, current_block_number: u32) -> u32 {\n        // The post value becomes the current one at the block of change, so any transaction that is included in the\n        // block of change will use the post value.\n        if current_block_number < self.block_of_change {\n            self.pre.unwrap_or(INITIAL_DELAY)\n        } else {\n            self.post.unwrap_or(INITIAL_DELAY)\n        }\n    }\n\n    /// Returns the scheduled change, i.e. the post-change delay and the block at which it will become the current\n    /// delay. Note that this block may be in the past if the change has already taken place.\n    /// Additionally, further changes might be later scheduled, potentially canceling the one returned by this function.\n    pub fn get_scheduled(self) -> (u32, u32) {\n        (self.post.unwrap_or(INITIAL_DELAY), self.block_of_change)\n    }\n\n    /// Mutates the delay change by scheduling a change at the current block number. This function is only meaningful\n    /// when called in public with the current block number.\n    /// The block at which the new delay will become effective is determined automatically:\n    ///  - when increasing the delay, the change is effective immediately\n    ///  - when reducing the delay, the change will take effect after a delay equal to the difference between old and\n    ///    new delay. For example, if reducing from 3 days to 1 day, the reduction will be scheduled to happen after 2\n    ///    days.\n    pub fn schedule_change(&mut self, new: u32, current_block_number: u32) {\n        let current = self.get_current(current_block_number);\n\n        // When changing the delay value we must ensure that it is not possible to produce a value change with a delay\n        // shorter than the current one.\n        let blocks_until_change = if new > current {\n            // Increasing the delay value can therefore be done immediately: this does not invalidate prior constraints\n            // about how quickly a value might be changed (indeed it strengthens them).\n            0\n        } else {\n            // Decreasing the delay requires waiting for the difference between current and new delay in order to ensure\n            // that overall the current delay is respected.\n            //\n            //      current                    delay              earliest value block of change\n            //       block                 block of change         if delay remained unchanged\n            //  =======N=========================|================================X=================>\n            //         ^                         ^                                ^\n            //         |-------------------------|--------------------------------|\n            //         |   blocks until change               new delay            |\n            //         ------------------------------------------------------------\n            //                            current delay\n            current - new\n        };\n\n        self.pre = Option::some(current);\n        self.post = Option::some(new);\n        self.block_of_change = current_block_number + blocks_until_change;\n    }\n\n    /// Returns the minimum delay before a value might mutate due to a scheduled change, from the perspective of some\n    /// historical block number. It only returns a meaningful value when called in private with historical blocks. This\n    /// function can be used alongside `ScheduledValueChange.get_block_horizon` to properly constrain the\n    /// `max_block_number` transaction property when reading mutable shared state.\n    /// This value typically equals the current delay at the block following the historical one (the earliest one in\n    /// which a value change could be scheduled), but it also considers scenarios in which a delay reduction is\n    /// scheduled to happen in the near future, resulting in a way to schedule a change with an overall delay lower than\n    /// the current one.\n    pub fn get_effective_minimum_delay_at(self, historical_block_number: u32) -> u32 {\n        if self.block_of_change <= historical_block_number {\n            // If no delay changes were scheduled, then the delay value at the historical block (post) is guaranteed to\n            // hold due to how further delay changes would be scheduled by `schedule_change`.\n            self.post.unwrap_or(INITIAL_DELAY)\n        } else {\n            // If a change is scheduled, then the effective delay might be lower than the current one (pre). At the\n            // block of change the current delay will be the scheduled one, with an overall delay from the historical\n            // block number equal to the number of blocks until the change plus the new delay. If this value is lower\n            // than the current delay, then that is the effective minimum delay.\n            //\n            //       historical\n            //         block                  delay                  actual earliest value\n            //           v                block of change              block of change\n            //  =========NS=====================|=============================X===========Y=====>\n            //            ^                     ^                             ^           ^\n            //     earliest block in            |                             |           |\n            //   which to schedule change       |                             |           |\n            //           |                      |                             |           |\n            //           |----------------------|------------------------------           |\n            //           |         blocks                  new delay                      |\n            //           |      until change                                              |\n            //           |                                                                |\n            //           |----------------------------------------------------------------|\n            //                        current delay at the earliest block in\n            //                             which to scheduled value change\n            let blocks_until_change = self.block_of_change - (historical_block_number + 1);\n\n            min(\n                self.pre.unwrap_or(INITIAL_DELAY),\n                blocks_until_change + self.post.unwrap_or(INITIAL_DELAY),\n            )\n        }\n    }\n}\n\nimpl<let INITIAL_DELAY: u32> Eq for ScheduledDelayChange<INITIAL_DELAY> {\n    fn eq(self, other: Self) -> bool {\n        (self.pre == other.pre)\n            & (self.post == other.post)\n            & (self.block_of_change == other.block_of_change)\n    }\n}\n\nimpl<let INITIAL_DELAY: u32> Empty for ScheduledDelayChange<INITIAL_DELAY> {\n    fn empty() -> Self {\n        Self { pre: Option::none(), post: Option::none(), block_of_change: 0 }\n    }\n}\n"
     },
-    "308": {
+    "309": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/shared_mutable/scheduled_value_change.nr",
       "source": "use crate::traits::Empty;\nuse std::cmp::min;\n\nmod test;\n\n// This data structure is used by SharedMutable to represent a value that changes from `pre` to `post` at some block\n// called the `block_of_change`. The value can only be made to change by scheduling a change event at some future block\n// of change after some minimum delay measured in blocks has elapsed. This means that at any given block number we know\n// both the current value and the smallest block number at which the value might change - this is called the\n// 'block horizon'.\npub struct ScheduledValueChange<T> {\n    pub(crate) pre: T,\n    pub(crate) post: T,\n    // Block at which `post` value is used instead of `pre`\n    pub(crate) block_of_change: u32,\n}\n\nimpl<T> ScheduledValueChange<T> {\n    pub fn new(pre: T, post: T, block_of_change: u32) -> Self {\n        Self { pre, post, block_of_change }\n    }\n\n    /// Returns the value stored in the data structure at a given block. This function can be called both in public\n    /// (where `block_number` is simply the current block number, i.e. the number of the block in which the current\n    /// transaction will be included) and in private (where `block_number` is the historical block number that is used\n    /// to construct the proof).\n    /// Reading in private is only safe if the transaction's `max_block_number` property is set to a value lower or\n    /// equal to the block horizon (see `get_block_horizon()`).\n    pub fn get_current_at(self, block_number: u32) -> T {\n        // The post value becomes the current one at the block of change. This means different things in each realm:\n        // - in public, any transaction that is included in the block of change will use the post value\n        // - in private, any transaction that includes the block of change as part of the historical state will use the\n        //   post value (barring any follow-up changes)\n        if block_number < self.block_of_change {\n            self.pre\n        } else {\n            self.post\n        }\n    }\n\n    /// Returns the scheduled change, i.e. the post-change value and the block at which it will become the current\n    /// value. Note that this block may be in the past if the change has already taken place.\n    /// Additionally, further changes might be later scheduled, potentially canceling the one returned by this function.\n    pub fn get_scheduled(self) -> (T, u32) {\n        (self.post, self.block_of_change)\n    }\n\n    // Returns the previous value. This is the value that is current up until the block of change. Note that this value\n    // might not be the current anymore since block of change might have already passed.\n    pub fn get_previous(self) -> (T, u32) {\n        (self.pre, self.block_of_change)\n    }\n\n    /// Returns the largest block number at which the value returned by `get_current_at` is known to remain the current\n    /// value. This value is only meaningful in private when constructing a proof at some `historical_block_number`,\n    /// since due to its asynchronous nature private execution cannot know about any later scheduled changes.\n    /// The caller of this function must know how quickly the value can change due to a scheduled change in the form of\n    /// `minimum_delay`. If the delay itself is immutable, then this is just its duration. If the delay is mutable\n    /// however, then this value is the 'effective minimum delay' (obtained by calling\n    /// `ScheduledDelayChange.get_effective_minimum_delay_at`), which equals the minimum number of blocks that need to\n    /// elapse from the next block until the value changes, regardless of further delay changes.\n    /// The value returned by `get_current_at` in private when called with a historical block number is only safe to use\n    /// if the transaction's `max_block_number` property is set to a value lower or equal to the block horizon computed\n    /// using the same historical block number.\n    pub fn get_block_horizon(self, historical_block_number: u32, minimum_delay: u32) -> u32 {\n        // The block horizon is the very last block in which the current value is known. Any block past the horizon\n        // (i.e. with a block number larger than the block horizon) may have a different current value. Reading the\n        // current value in private typically requires constraining the maximum valid block number to be equal to the\n        // block horizon.\n        if historical_block_number >= self.block_of_change {\n            // Once the block of change has been mined, the current value (post) will not change unless a new value\n            // change is scheduled. This did not happen at the historical block number (or else it would not be\n            // greater or equal to the block of change), and therefore could only happen after the historical block\n            // number. The earliest would be the immediate next block, and so the smallest possible next block of change\n            // equals `historical_block_number + 1 + minimum_delay`. Our block horizon is simply the previous block to\n            // that one.\n            //\n            //      block of      historical\n            //       change         block            block horizon\n            //   =======|=============N===================H===========>\n            //                         ^                   ^\n            //                         ---------------------\n            //                             minimum delay\n            historical_block_number + minimum_delay\n        } else {\n            // If the block of change has not yet been mined however, then there are two possible scenarios.\n            //   a) It could be so far into the future that the block horizon is actually determined by the minimum\n            //      delay, because a new change could be scheduled and take place _before_ the currently scheduled one.\n            //      This is similar to the scenario where the block of change is in the past: the time horizon is the\n            //      block prior to the earliest one in which a new block of change might land.\n            //\n            //         historical\n            //           block                        block horizon      block of change\n            //        =====N=================================H=================|=========>\n            //              ^                                 ^\n            //              |                                 |\n            //              -----------------------------------\n            //                        minimum delay\n            //\n            //   b) It could be fewer than `minimum_delay` blocks away from the historical block number, in which case\n            //      the block of change would become the limiting factor for the time horizon, which would equal the\n            //      block right before the block of change (since by definition the value changes at the block of\n            //      change).\n            //\n            //           historical                         block horizon\n            //             block     block of change       if not scheduled\n            //        =======N=============|===================H=================>\n            //                ^           ^                     ^\n            //                |     actual horizon              |\n            //                -----------------------------------\n            //                          minimum delay\n            //\n            // Note that the current implementation does not allow the caller to set the block of change to an arbitrary\n            // value, and therefore scenario a) is not currently possible. However implementing #5501 would allow for\n            // this to happen.\n            // Because historical_block_number < self.block_of_change, then block_of_change > 0 and we can safely\n            // subtract 1.\n            min(\n                self.block_of_change - 1,\n                historical_block_number + minimum_delay,\n            )\n        }\n    }\n\n    /// Mutates the value by scheduling a change at the current block number. This function is only meaningful when\n    /// called in public with the current block number.\n    pub fn schedule_change(\n        &mut self,\n        new_value: T,\n        current_block_number: u32,\n        minimum_delay: u32,\n        block_of_change: u32,\n    ) {\n        assert(block_of_change >= current_block_number + minimum_delay);\n\n        self.pre = self.get_current_at(current_block_number);\n        self.post = new_value;\n        self.block_of_change = block_of_change;\n    }\n}\n\nimpl<T> Eq for ScheduledValueChange<T>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: Self) -> bool {\n        (self.pre == other.pre)\n            & (self.post == other.post)\n            & (self.block_of_change == other.block_of_change)\n    }\n}\n\nimpl<T> Empty for ScheduledValueChange<T>\nwhere\n    T: Empty,\n{\n    fn empty() -> Self {\n        Self { pre: T::empty(), post: T::empty(), block_of_change: 0 }\n    }\n}\n"
     },
-    "310": {
+    "311": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/shared_mutable/shared_mutable_values.nr",
-      "source": "use crate::{\n    hash::poseidon2_hash,\n    shared_mutable::{\n        scheduled_delay_change::ScheduledDelayChange, scheduled_value_change::ScheduledValueChange,\n    },\n    traits::{Hash, Packable},\n    utils::arrays,\n};\nuse std::meta::derive;\n\nmod test;\n\n/// SharedMutableValues is just a wrapper around ScheduledValueChange and ScheduledDelayChange that then allows us\n/// to wrap both of these values in WithHash. WithHash allows for efficient read of values in private.\n///\n/// Note that the WithHash optimization does not work in public (due to there being no unconstrained). But we also want\n/// to be able to read the values efficiently in public and we want to be able to read each value separately. Reading\n/// the values separately is tricky because ScheduledValueChange and ScheduledDelayChange are packed together (sdc and\n/// svc.block_of_change are stored in the same slot). For that reason we expose `unpack_value_change` and\n/// `unpack_delay_change` functions that can be used to extract the values from the packed representation. This\n/// is \"hacky\" but there is no way around it.\n#[derive(Eq)]\npub struct SharedMutableValues<T, let INITIAL_DELAY: u32> {\n    pub svc: ScheduledValueChange<T>,\n    pub sdc: ScheduledDelayChange<INITIAL_DELAY>,\n}\n\nimpl<T, let INITIAL_DELAY: u32> SharedMutableValues<T, INITIAL_DELAY> {\n    pub fn new(svc: ScheduledValueChange<T>, sdc: ScheduledDelayChange<INITIAL_DELAY>) -> Self {\n        SharedMutableValues { svc, sdc }\n    }\n\n    pub fn unpack_value_change<let N: u32>(packed: [Field; 2 * N + 1]) -> ScheduledValueChange<T>\n    where\n        T: Packable<N>,\n    {\n        let svc_pre_packed = arrays::subarray(packed, 1);\n        let svc_post_packed = arrays::subarray(packed, N + 1);\n        ScheduledValueChange::new(\n            T::unpack(svc_pre_packed),\n            T::unpack(svc_post_packed),\n            packed[0] as u32,\n        )\n    }\n\n    pub fn unpack_delay_change(packed: Field) -> ScheduledDelayChange<INITIAL_DELAY> {\n        // This function expects to be called with just the first field of the packed representation, which contains sdc\n        // and svc block_of_change. We'll discard the svc component.\n        let svc_block_of_change = packed as u32;\n\n        let mut tmp = (packed - svc_block_of_change as Field) / TWO_POW_32;\n        let sdc_block_of_change = tmp as u32;\n\n        tmp = (tmp - sdc_block_of_change as Field) / TWO_POW_32;\n        let sdc_post_is_some = tmp as bool;\n\n        tmp = (tmp - sdc_post_is_some as Field) / TWO_POW_8;\n        let sdc_post_inner = tmp as u32;\n\n        tmp = (tmp - sdc_post_inner as Field) / TWO_POW_32;\n        let sdc_pre_is_some = tmp as bool;\n\n        tmp = (tmp - sdc_pre_is_some as Field) / TWO_POW_8;\n        let sdc_pre_inner = tmp as u32;\n\n        ScheduledDelayChange {\n            pre: if sdc_pre_is_some {\n                Option::some(sdc_pre_inner)\n            } else {\n                Option::none()\n            },\n            post: if sdc_post_is_some {\n                Option::some(sdc_post_inner)\n            } else {\n                Option::none()\n            },\n            block_of_change: sdc_block_of_change,\n        }\n    }\n}\n\nglobal TWO_POW_32: Field = 2.pow_32(32);\nglobal TWO_POW_8: Field = 2.pow_32(8);\n\n// We pack to `2 * N + 1` fields because ScheduledValueChange contains T twice (hence `2 * N`) and we need one extra\n// field to store ScheduledDelayChange and the block_of_change of ScheduledValueChange.\nimpl<T, let INITIAL_DELAY: u32, let N: u32> Packable<2 * N + 1> for SharedMutableValues<T, INITIAL_DELAY>\nwhere\n    T: Packable<N>,\n{\n    fn pack(self) -> [Field; 2 * N + 1] {\n        let mut result = [0; 2 * N + 1];\n\n        // We pack sdc.pre, sdc.post, sdc.block_of_change and svc.block_of_change into a single field as follows:\n        // [ sdc.pre_inner: u32 | sdc.pre_is_some: u8 | sdc.post_inner: u32 | sdc.post_is_some: u8 | sdc.block_of_change: u32 | svc.block_of_change: u32 ]\n        result[0] = self.svc.block_of_change as Field\n            + ((self.sdc.block_of_change as Field) * 2.pow_32(32))\n            + ((self.sdc.post.is_some() as Field) * 2.pow_32(64))\n            + ((self.sdc.post.unwrap_unchecked() as Field) * 2.pow_32(72))\n            + ((self.sdc.pre.is_some() as Field) * 2.pow_32(104))\n            + ((self.sdc.pre.unwrap_unchecked() as Field) * 2.pow_32(112));\n\n        // Pack the pre and post values from ScheduledValueChange\n        let svc_pre_packed = self.svc.pre.pack();\n        let svc_post_packed = self.svc.post.pack();\n        for i in 0..N {\n            result[i + 1] = svc_pre_packed[i];\n            result[i + 1 + N] = svc_post_packed[i];\n        }\n        result\n    }\n\n    fn unpack(fields: [Field; 2 * N + 1]) -> Self {\n        let svc = Self::unpack_value_change(fields);\n        let sdc = SharedMutableValues::<T, INITIAL_DELAY>::unpack_delay_change(fields[0]);\n        Self::new(svc, sdc)\n    }\n}\n\nimpl<T, let INITIAL_DELAY: u32, let N: u32> Hash for SharedMutableValues<T, INITIAL_DELAY>\nwhere\n    T: Packable<N>,\n{\n    fn hash(self) -> Field {\n        poseidon2_hash(self.pack())\n    }\n}\n"
+      "source": "use crate::{\n    hash::poseidon2_hash,\n    shared_mutable::{\n        scheduled_delay_change::ScheduledDelayChange, scheduled_value_change::ScheduledValueChange,\n    },\n    traits::{Hash, Packable},\n    utils::arrays,\n};\nuse std::meta::derive;\n\nmod test;\n\n/// SharedMutableValues is just a wrapper around ScheduledValueChange and ScheduledDelayChange that then allows us\n/// to wrap both of these values in WithHash. WithHash allows for efficient read of values in private.\n///\n/// Note that the WithHash optimization does not work in public (due to there being no unconstrained). But we also want\n/// to be able to read the values efficiently in public and we want to be able to read each value separately. Reading\n/// the values separately is tricky because ScheduledValueChange and ScheduledDelayChange are packed together (sdc and\n/// svc.block_of_change are stored in the same slot). For that reason we expose `unpack_value_change` and\n/// `unpack_delay_change` functions that can be used to extract the values from the packed representation. This\n/// is \"hacky\" but there is no way around it.\n#[derive(Eq)]\npub struct SharedMutableValues<T, let INITIAL_DELAY: u32> {\n    pub svc: ScheduledValueChange<T>,\n    pub sdc: ScheduledDelayChange<INITIAL_DELAY>,\n}\n\nimpl<T, let INITIAL_DELAY: u32> SharedMutableValues<T, INITIAL_DELAY> {\n    pub fn new(svc: ScheduledValueChange<T>, sdc: ScheduledDelayChange<INITIAL_DELAY>) -> Self {\n        SharedMutableValues { svc, sdc }\n    }\n}\n\npub fn unpack_value_change<T, let N: u32>(packed: [Field; 2 * N + 1]) -> ScheduledValueChange<T>\nwhere\n    T: Packable<N>,\n{\n    let svc_pre_packed = arrays::subarray(packed, 1);\n    let svc_post_packed = arrays::subarray(packed, N + 1);\n    ScheduledValueChange::new(\n        T::unpack(svc_pre_packed),\n        T::unpack(svc_post_packed),\n        packed[0] as u32,\n    )\n}\n\npub fn unpack_delay_change<let INITIAL_DELAY: u32>(\n    packed: Field,\n) -> ScheduledDelayChange<INITIAL_DELAY> {\n    // This function expects to be called with just the first field of the packed representation, which contains sdc\n    // and svc block_of_change. We'll discard the svc component.\n    let svc_block_of_change = packed as u32;\n\n    let mut tmp = (packed - svc_block_of_change as Field) / TWO_POW_32;\n    let sdc_block_of_change = tmp as u32;\n\n    tmp = (tmp - sdc_block_of_change as Field) / TWO_POW_32;\n    let sdc_post_is_some = tmp as bool;\n\n    tmp = (tmp - sdc_post_is_some as Field) / TWO_POW_8;\n    let sdc_post_inner = tmp as u32;\n\n    tmp = (tmp - sdc_post_inner as Field) / TWO_POW_32;\n    let sdc_pre_is_some = tmp as bool;\n\n    tmp = (tmp - sdc_pre_is_some as Field) / TWO_POW_8;\n    let sdc_pre_inner = tmp as u32;\n\n    ScheduledDelayChange {\n        pre: if sdc_pre_is_some {\n            Option::some(sdc_pre_inner)\n        } else {\n            Option::none()\n        },\n        post: if sdc_post_is_some {\n            Option::some(sdc_post_inner)\n        } else {\n            Option::none()\n        },\n        block_of_change: sdc_block_of_change,\n    }\n}\n\nglobal TWO_POW_32: Field = 2.pow_32(32);\nglobal TWO_POW_8: Field = 2.pow_32(8);\n\n// We pack to `2 * N + 1` fields because ScheduledValueChange contains T twice (hence `2 * N`) and we need one extra\n// field to store ScheduledDelayChange and the block_of_change of ScheduledValueChange.\nimpl<T, let INITIAL_DELAY: u32, let N: u32> Packable<2 * N + 1> for SharedMutableValues<T, INITIAL_DELAY>\nwhere\n    T: Packable<N>,\n{\n    fn pack(self) -> [Field; 2 * N + 1] {\n        let mut result = [0; 2 * N + 1];\n\n        // We pack sdc.pre, sdc.post, sdc.block_of_change and svc.block_of_change into a single field as follows:\n        // [ sdc.pre_inner: u32 | sdc.pre_is_some: u8 | sdc.post_inner: u32 | sdc.post_is_some: u8 | sdc.block_of_change: u32 | svc.block_of_change: u32 ]\n        result[0] = self.svc.block_of_change as Field\n            + ((self.sdc.block_of_change as Field) * 2.pow_32(32))\n            + ((self.sdc.post.is_some() as Field) * 2.pow_32(64))\n            + ((self.sdc.post.unwrap_unchecked() as Field) * 2.pow_32(72))\n            + ((self.sdc.pre.is_some() as Field) * 2.pow_32(104))\n            + ((self.sdc.pre.unwrap_unchecked() as Field) * 2.pow_32(112));\n\n        // Pack the pre and post values from ScheduledValueChange\n        let svc_pre_packed = self.svc.pre.pack();\n        let svc_post_packed = self.svc.post.pack();\n        for i in 0..N {\n            result[i + 1] = svc_pre_packed[i];\n            result[i + 1 + N] = svc_post_packed[i];\n        }\n        result\n    }\n\n    fn unpack(fields: [Field; 2 * N + 1]) -> Self {\n        let svc = unpack_value_change::<T, N>(fields);\n        let sdc = unpack_delay_change::<INITIAL_DELAY>(fields[0]);\n        Self::new(svc, sdc)\n    }\n}\n\nimpl<T, let INITIAL_DELAY: u32, let N: u32> Hash for SharedMutableValues<T, INITIAL_DELAY>\nwhere\n    T: Packable<N>,\n{\n    fn hash(self) -> Field {\n        poseidon2_hash(self.pack())\n    }\n}\n"
     },
-    "313": {
+    "314": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr",
       "source": "use crate::{hash::poseidon2_hash, traits::ToField};\n\npub fn derive_storage_slot_in_map<K>(storage_slot: Field, key: K) -> Field\nwhere\n    K: ToField,\n{\n    poseidon2_hash([storage_slot, key.to_field()])\n}\n\nmod test {\n    use crate::{address::AztecAddress, storage::map::derive_storage_slot_in_map, traits::FromField};\n\n    #[test]\n    fn test_derive_storage_slot_in_map_matches_typescript() {\n        let map_slot = 0x132258fb6962c4387ba659d9556521102d227549a386d39f0b22d1890d59c2b5;\n        let key = AztecAddress::from_field(\n            0x302dbc2f9b50a73283d5fb2f35bc01eae8935615817a0b4219a057b2ba8a5a3f,\n        );\n\n        let slot = derive_storage_slot_in_map(map_slot, key);\n\n        // The following value was generated by `map_slot.test.ts`\n        let slot_from_typescript =\n            0x15b9fe39449affd8b377461263e9d2b610b9ad40580553500b4e41d9cbd887ac;\n\n        assert_eq(slot, slot_from_typescript);\n    }\n}\n"
     },
-    "331": {
+    "332": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/type_packing.nr",
       "source": "use crate::traits::Packable;\n\nglobal BOOL_PACKED_LEN: u32 = 1;\nglobal U8_PACKED_LEN: u32 = 1;\nglobal U16_PACKED_LEN: u32 = 1;\nglobal U32_PACKED_LEN: u32 = 1;\nglobal U64_PACKED_LEN: u32 = 1;\nglobal U128_PACKED_LEN: u32 = 1;\nglobal FIELD_PACKED_LEN: u32 = 1;\nglobal I8_PACKED_LEN: u32 = 1;\nglobal I16_PACKED_LEN: u32 = 1;\nglobal I32_PACKED_LEN: u32 = 1;\nglobal I64_PACKED_LEN: u32 = 1;\n\nimpl Packable<BOOL_PACKED_LEN> for bool {\n    fn pack(self) -> [Field; BOOL_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; BOOL_PACKED_LEN]) -> bool {\n        fields[0] as bool\n    }\n}\n\nimpl Packable<U8_PACKED_LEN> for u8 {\n    fn pack(self) -> [Field; U8_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; U8_PACKED_LEN]) -> Self {\n        fields[0] as u8\n    }\n}\n\nimpl Packable<U16_PACKED_LEN> for u16 {\n    fn pack(self) -> [Field; U16_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; U16_PACKED_LEN]) -> Self {\n        fields[0] as u16\n    }\n}\n\nimpl Packable<U32_PACKED_LEN> for u32 {\n    fn pack(self) -> [Field; U32_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; U32_PACKED_LEN]) -> Self {\n        fields[0] as u32\n    }\n}\n\nimpl Packable<U64_PACKED_LEN> for u64 {\n    fn pack(self) -> [Field; U64_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; U64_PACKED_LEN]) -> Self {\n        fields[0] as u64\n    }\n}\n\nimpl Packable<U128_PACKED_LEN> for u128 {\n    fn pack(self) -> [Field; U128_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; U128_PACKED_LEN]) -> Self {\n        fields[0] as u128\n    }\n}\n\nimpl Packable<FIELD_PACKED_LEN> for Field {\n    fn pack(self) -> [Field; FIELD_PACKED_LEN] {\n        [self]\n    }\n\n    fn unpack(fields: [Field; FIELD_PACKED_LEN]) -> Self {\n        fields[0]\n    }\n}\n\nimpl Packable<I8_PACKED_LEN> for i8 {\n    fn pack(self) -> [Field; I8_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; I8_PACKED_LEN]) -> Self {\n        fields[0] as i8\n    }\n}\n\nimpl Packable<I16_PACKED_LEN> for i16 {\n    fn pack(self) -> [Field; I16_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; I16_PACKED_LEN]) -> Self {\n        fields[0] as i16\n    }\n}\n\nimpl Packable<I32_PACKED_LEN> for i32 {\n    fn pack(self) -> [Field; I32_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; I32_PACKED_LEN]) -> Self {\n        fields[0] as i32\n    }\n}\n\nimpl Packable<I64_PACKED_LEN> for i64 {\n    fn pack(self) -> [Field; I64_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; I64_PACKED_LEN]) -> Self {\n        fields[0] as i64\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Packable<N * M> for [T; N]\nwhere\n    T: Packable<M>,\n{\n    fn pack(self) -> [Field; N * M] {\n        let mut result: [Field; N * M] = std::mem::zeroed();\n        let mut serialized: [Field; M] = std::mem::zeroed();\n        for i in 0..N {\n            serialized = self[i].pack();\n            for j in 0..M {\n                result[i * M + j] = serialized[j];\n            }\n        }\n        result\n    }\n\n    fn unpack(fields: [Field; N * M]) -> Self {\n        let mut reader = crate::utils::reader::Reader::new(fields);\n        let mut result: [T; N] = std::mem::zeroed();\n        reader.read_struct_array::<T, M, N>(Packable::unpack, result)\n    }\n}\n\n#[test]\nfn test_u16_packing() {\n    let a: u16 = 10;\n    assert_eq(a, u16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i8_packing() {\n    let a: i8 = -10;\n    assert_eq(a, i8::unpack(a.pack()));\n}\n\n#[test]\nfn test_i16_packing() {\n    let a: i16 = -10;\n    assert_eq(a, i16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i32_packing() {\n    let a: i32 = -10;\n    assert_eq(a, i32::unpack(a.pack()));\n}\n\n#[test]\nfn test_i64_packing() {\n    let a: i64 = -10;\n    assert_eq(a, i64::unpack(a.pack()));\n}\n"
     },
-    "332": {
+    "333": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/type_serialization.nr",
       "source": "use crate::traits::{Deserialize, Serialize};\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize<BOOL_SERIALIZED_LEN> for bool {\n    fn serialize(self) -> [Field; BOOL_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<BOOL_SERIALIZED_LEN> for bool {\n    fn deserialize(fields: [Field; BOOL_SERIALIZED_LEN]) -> bool {\n        fields[0] as bool\n    }\n}\n\nimpl Serialize<U8_SERIALIZED_LEN> for u8 {\n    fn serialize(self) -> [Field; U8_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U8_SERIALIZED_LEN> for u8 {\n    fn deserialize(fields: [Field; U8_SERIALIZED_LEN]) -> Self {\n        fields[0] as u8\n    }\n}\n\nimpl Serialize<U16_SERIALIZED_LEN> for u16 {\n    fn serialize(self) -> [Field; U16_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U16_SERIALIZED_LEN> for u16 {\n    fn deserialize(fields: [Field; U16_SERIALIZED_LEN]) -> Self {\n        fields[0] as u16\n    }\n}\n\nimpl Serialize<U32_SERIALIZED_LEN> for u32 {\n    fn serialize(self) -> [Field; U32_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U32_SERIALIZED_LEN> for u32 {\n    fn deserialize(fields: [Field; U32_SERIALIZED_LEN]) -> Self {\n        fields[0] as u32\n    }\n}\n\nimpl Serialize<U64_SERIALIZED_LEN> for u64 {\n    fn serialize(self) -> [Field; U64_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U64_SERIALIZED_LEN> for u64 {\n    fn deserialize(fields: [Field; U64_SERIALIZED_LEN]) -> Self {\n        fields[0] as u64\n    }\n}\n\nimpl Serialize<U128_SERIALIZED_LEN> for u128 {\n    fn serialize(self) -> [Field; U128_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U128_SERIALIZED_LEN> for u128 {\n    fn deserialize(fields: [Field; U128_SERIALIZED_LEN]) -> Self {\n        fields[0] as u128\n    }\n}\n\nimpl Serialize<FIELD_SERIALIZED_LEN> for Field {\n    fn serialize(self) -> [Field; FIELD_SERIALIZED_LEN] {\n        [self]\n    }\n}\n\nimpl Deserialize<FIELD_SERIALIZED_LEN> for Field {\n    fn deserialize(fields: [Field; FIELD_SERIALIZED_LEN]) -> Self {\n        fields[0]\n    }\n}\n\nimpl Serialize<I8_SERIALIZED_LEN> for i8 {\n    fn serialize(self) -> [Field; I8_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I8_SERIALIZED_LEN> for i8 {\n    fn deserialize(fields: [Field; I8_SERIALIZED_LEN]) -> Self {\n        fields[0] as i8\n    }\n}\n\nimpl Serialize<I16_SERIALIZED_LEN> for i16 {\n    fn serialize(self) -> [Field; I16_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I16_SERIALIZED_LEN> for i16 {\n    fn deserialize(fields: [Field; I16_SERIALIZED_LEN]) -> Self {\n        fields[0] as i16\n    }\n}\n\nimpl Serialize<I32_SERIALIZED_LEN> for i32 {\n    fn serialize(self) -> [Field; I32_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I32_SERIALIZED_LEN> for i32 {\n    fn deserialize(fields: [Field; I32_SERIALIZED_LEN]) -> Self {\n        fields[0] as i32\n    }\n}\n\nimpl Serialize<I64_SERIALIZED_LEN> for i64 {\n    fn serialize(self) -> [Field; I64_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I64_SERIALIZED_LEN> for i64 {\n    fn deserialize(fields: [Field; I64_SERIALIZED_LEN]) -> Self {\n        fields[0] as i64\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]\nwhere\n    T: Serialize<M>,\n{\n    fn serialize(self) -> [Field; N * M] {\n        let mut result: [Field; N * M] = std::mem::zeroed();\n        let mut serialized: [Field; M] = std::mem::zeroed();\n        for i in 0..N {\n            serialized = self[i].serialize();\n            for j in 0..M {\n                result[i * M + j] = serialized[j];\n            }\n        }\n        result\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Deserialize<N * M> for [T; N]\nwhere\n    T: Deserialize<M>,\n{\n    fn deserialize(fields: [Field; N * M]) -> Self {\n        let mut reader = crate::utils::reader::Reader::new(fields);\n        let mut result: [T; N] = std::mem::zeroed();\n        reader.read_struct_array::<T, M, N>(Deserialize::deserialize, result)\n    }\n}\n\n#[test]\nfn test_u16_serialization() {\n    let a: u16 = 10;\n    assert_eq(a, u16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i8_serialization() {\n    let a: i8 = -10;\n    assert_eq(a, i8::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i16_serialization() {\n    let a: i16 = -10;\n    assert_eq(a, i16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i32_serialization() {\n    let a: i32 = -10;\n    assert_eq(a, i32::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i64_serialization() {\n    let a: i64 = -10;\n    assert_eq(a, i64::deserialize(a.serialize()));\n}\n"
     },
-    "348": {
+    "349": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/arrays.nr",
       "source": "pub mod assert_array_appended;\npub mod assert_array_prepended;\npub mod assert_combined_array;\npub mod assert_combined_transformed_array;\npub mod assert_exposed_sorted_transformed_value_array;\npub mod assert_sorted_array;\npub mod assert_sorted_transformed_value_array;\npub mod assert_split_sorted_transformed_value_arrays;\npub mod assert_split_transformed_value_arrays;\npub mod get_sorted_result;\npub mod get_sorted_tuple;\npub mod sort_by;\npub mod sort_by_counter;\n\n// Re-exports.\npub use assert_array_appended::{\n    assert_array_appended, assert_array_appended_and_scoped, assert_array_appended_reversed,\n    assert_array_appended_scoped,\n};\npub use assert_array_prepended::assert_array_prepended;\npub use assert_combined_array::{assert_combined_array, combine_arrays};\npub use assert_combined_transformed_array::{\n    assert_combined_transformed_array, combine_and_transform_arrays,\n};\npub use assert_exposed_sorted_transformed_value_array::{\n    assert_exposed_sorted_transformed_value_array,\n    get_order_hints::{get_order_hints_asc, get_order_hints_desc, OrderHint},\n};\npub use assert_sorted_array::assert_sorted_array;\npub use assert_sorted_transformed_value_array::{\n    assert_sorted_transformed_value_array, assert_sorted_transformed_value_array_capped_size,\n};\npub use assert_split_sorted_transformed_value_arrays::{\n    assert_split_sorted_transformed_value_arrays_asc,\n    assert_split_sorted_transformed_value_arrays_desc,\n    get_split_order_hints::{get_split_order_hints_asc, get_split_order_hints_desc, SplitOrderHints},\n};\npub use assert_split_transformed_value_arrays::assert_split_transformed_value_arrays;\npub use get_sorted_result::{get_sorted_result, SortedResult};\npub use sort_by_counter::{sort_by_counter_asc, sort_by_counter_desc};\n\nuse crate::traits::{Empty, is_empty};\n\npub fn subarray<let SRC_LEN: u32, let DST_LEN: u32>(\n    src: [Field; SRC_LEN],\n    offset: u32,\n) -> [Field; DST_LEN] {\n    assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n    let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n    for i in 0..DST_LEN {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\n// Helper function to convert a validated array to BoundedVec.\n// Important: Only use it for validated arrays: validate_array(array) should be true.\npub unconstrained fn array_to_bounded_vec<T, let N: u32>(array: [T; N]) -> BoundedVec<T, N>\nwhere\n    T: Empty + Eq,\n{\n    let len = array_length(array);\n    BoundedVec::from_parts_unchecked(array, len)\n}\n\n// Helper function to find the index of the first element in an array that satisfies a given predicate. If the element\n// is not found, the function returns N as the index.\npub unconstrained fn find_index_hint<T, let N: u32, Env>(\n    array: [T; N],\n    find: fn[Env](T) -> bool,\n) -> u32 {\n    let mut index = N;\n    for i in 0..N {\n        // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n        if (index == N) & find(array[i]) {\n            index = i;\n        }\n    }\n    index\n}\n\n// Routine which validates that all zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where any * is non-zero. Note that a full array of non-zero values is\n// valid.\npub fn validate_array<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    let mut seen_empty = false;\n    let mut length = 0;\n    for i in 0..N {\n        if is_empty(array[i]) {\n            seen_empty = true;\n        } else {\n            assert(seen_empty == false, \"invalid array\");\n            length += 1;\n        }\n    }\n    length\n}\n\n// Helper function to count the number of non-empty elements in a validated array.\n// Important: Only use it for validated arrays where validate_array(array) returns true,\n// which ensures that:\n// 1. All elements before the first empty element are non-empty\n// 2. All elements after and including the first empty element are empty\n// 3. The array forms a contiguous sequence of non-empty elements followed by empty elements\npub fn array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    // We get the length by checking the index of the first empty element.\n\n    // Safety: This is safe because we have validated the array (see function doc above) and the emptiness\n    // of the element and non-emptiness of the previous element is checked below.\n    let length = unsafe { find_index_hint(array, |elem: T| is_empty(elem)) };\n    if length != 0 {\n        assert(!is_empty(array[length - 1]));\n    }\n    if length != N {\n        assert(is_empty(array[length]));\n    }\n    length\n}\n\npub fn array_concat<T, let N: u32, let M: u32>(array1: [T; N], array2: [T; M]) -> [T; N + M] {\n    let mut result = [array1[0]; N + M];\n    for i in 1..N {\n        result[i] = array1[i];\n    }\n    for i in 0..M {\n        result[i + N] = array2[i];\n    }\n    result\n}\n/// This function assumes that `array1` and `array2` contain no more than N non-empty elements between them,\n/// if this is not the case then elements from the end of `array2` will be dropped.\npub fn array_merge<T, let N: u32>(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n    T: Empty + Eq,\n{\n    // Safety: we constrain this array below\n    let result = unsafe { array_merge_helper(array1, array2) };\n    // We assume arrays have been validated. The only use cases so far are with previously validated arrays.\n    let array1_len = array_length(array1);\n    let mut add_from_left = true;\n    for i in 0..N {\n        add_from_left &= i != array1_len;\n        if add_from_left {\n            assert_eq(result[i], array1[i]);\n        } else {\n            assert_eq(result[i], array2[i - array1_len]);\n        }\n    }\n    result\n}\n\nunconstrained fn array_merge_helper<T, let N: u32>(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n    T: Empty + Eq,\n{\n    let mut result: [T; N] = [T::empty(); N];\n    let mut i = 0;\n    for elem in array1 {\n        if !is_empty(elem) {\n            result[i] = elem;\n            i += 1;\n        }\n    }\n    for elem in array2 {\n        if !is_empty(elem) {\n            result[i] = elem;\n            i += 1;\n        }\n    }\n    result\n}\n\n// Helper fn to create a subarray from a given array\npub fn array_splice<T, let N: u32, let M: u32>(array: [T; N], offset: u32) -> [T; M]\nwhere\n    T: Empty,\n{\n    assert(M + offset <= N, \"Subarray length larger than array length\");\n    let mut result: [T; M] = [T::empty(); M];\n    for i in 0..M {\n        result[i] = array[offset + i];\n    }\n    result\n}\n\npub fn check_permutation<T, let N: u32>(\n    original_array: [T; N],\n    permuted_array: [T; N],\n    original_indexes: [u32; N],\n)\nwhere\n    T: Eq + Empty,\n{\n    let mut seen_value = [false; N];\n    for i in 0..N {\n        let index = original_indexes[i];\n        let original_value = original_array[index];\n        assert(permuted_array[i].eq(original_value), \"Invalid index\");\n        assert(!seen_value[index], \"Duplicated index\");\n        seen_value[index] = true;\n    }\n}\n\n// Helper function to find the index of the last element in an array, allowing empty elements.\n// e.g. useful for removing trailing 0s from [1, 0, 2, 0, 0, 0] -> [1, 0, 2]\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn find_last_value_index<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    let mut index = N;\n    for i in 0..N {\n        let j = N - i - 1;\n        // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n        if (index == N) & !is_empty(array[j]) {\n            index = j;\n        }\n    }\n    index\n}\n\n// Routine which returns the length of an array right padded by empty elements\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\n// See smoke_validate_array_trailing for examples.\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn unsafe_padded_array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    let index = find_last_value_index(array);\n    if index == N {\n        0\n    } else {\n        index + 1\n    }\n}\n\n// Routine which validates that zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\npub fn padded_array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    // Safety: this value is constrained in the below loop.\n    let length = unsafe { unsafe_padded_array_length(array) };\n    // Check the elt just before length is non-zero:\n    if length != 0 {\n        assert(!is_empty(array[length - 1]), \"invalid right padded array\");\n    }\n    // Check all beyond length are zero:\n    let mut check_zero = false;\n    for i in 0..N {\n        check_zero |= i == length;\n        if check_zero {\n            assert(is_empty(array[i]), \"invalid right padded array\");\n        }\n    }\n    length\n}\n\n#[test]\nfn smoke_validate_array() {\n    let valid_array: [Field; 0] = [];\n    assert(validate_array(valid_array) == 0);\n\n    let valid_array = [0];\n    assert(validate_array(valid_array) == 0);\n\n    let valid_array = [3];\n    assert(validate_array(valid_array) == 1);\n\n    let valid_array = [1, 2, 3];\n    assert(validate_array(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0];\n    assert(validate_array(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0, 0];\n    assert(validate_array(valid_array) == 3);\n}\n\n#[test]\nfn smoke_validate_array_trailing() {\n    let valid_array: [Field; 0] = [];\n    assert(padded_array_length(valid_array) == 0);\n\n    let valid_array = [0];\n    assert(padded_array_length(valid_array) == 0);\n\n    let valid_array = [3];\n    assert(padded_array_length(valid_array) == 1);\n\n    let valid_array = [1, 0, 3];\n    assert(padded_array_length(valid_array) == 3);\n\n    let valid_array = [1, 0, 3, 0];\n    assert(padded_array_length(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0, 0];\n    assert(padded_array_length(valid_array) == 3);\n\n    let valid_array = [0, 0, 3, 0, 0];\n    assert(padded_array_length(valid_array) == 3);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case0() {\n    let invalid_array = [0, 1];\n    let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case1() {\n    let invalid_array = [1, 0, 0, 1, 0];\n    let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case2() {\n    let invalid_array = [0, 0, 0, 0, 1];\n    let _ = validate_array(invalid_array);\n}\n\n#[test]\nfn test_empty_array_length() {\n    assert_eq(array_length([0]), 0);\n    assert_eq(array_length([0, 0, 0]), 0);\n}\n\n#[test]\nfn test_array_length() {\n    assert_eq(array_length([123]), 1);\n    assert_eq(array_length([123, 0, 0]), 1);\n    assert_eq(array_length([123, 456]), 2);\n    assert_eq(array_length([123, 456, 0]), 2);\n}\n\n#[test]\nfn test_array_length_invalid_arrays() {\n    // Result can be misleading (but correct) for invalid arrays.\n    assert_eq(array_length([0, 0, 123]), 0);\n    assert_eq(array_length([0, 123, 0]), 0);\n    assert_eq(array_length([0, 123, 456]), 0);\n    assert_eq(array_length([123, 0, 456]), 1);\n}\n\n#[test]\nunconstrained fn find_index_greater_than_min() {\n    let values = [10, 20, 30, 40];\n    let min = 22;\n    let index = find_index_hint(values, |v: Field| min.lt(v));\n    assert_eq(index, 2);\n}\n\n#[test]\nunconstrained fn find_index_not_found() {\n    let values = [10, 20, 30, 40];\n    let min = 100;\n    let index = find_index_hint(values, |v: Field| min.lt(v));\n    assert_eq(index, 4);\n}\n\n#[test]\nfn test_array_concat() {\n    let array0 = [1, 2, 3];\n    let array1 = [4, 5];\n    let concatenated = array_concat(array0, array1);\n    assert_eq(concatenated, [1, 2, 3, 4, 5]);\n}\n\n#[test]\nfn check_permutation_basic_test() {\n    let original_array = [1, 2, 3];\n    let permuted_array = [3, 1, 2];\n    let indexes = [2, 0, 1];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Duplicated index\")]\nfn check_permutation_duplicated_index() {\n    let original_array = [0, 1, 0];\n    let permuted_array = [1, 0, 0];\n    let indexes = [1, 0, 0];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Invalid index\")]\nfn check_permutation_invalid_index() {\n    let original_array = [0, 1, 2];\n    let permuted_array = [1, 0, 0];\n    let indexes = [1, 0, 2];\n    check_permutation(original_array, permuted_array, indexes);\n}\n"
     },
-    "351": {
+    "352": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
       "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() as bool\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
     },
-    "357": {
+    "358": {
       "path": "/home/aztec-dev/nargo/github.com/noir-lang/sha256/v0.1.2/src/sha256.nr",
       "source": "use std::hash::sha256_compression;\nuse std::runtime::is_unconstrained;\n\nuse constants::{\n    BLOCK_BYTE_PTR, BLOCK_SIZE, HASH, INITIAL_STATE, INT_BLOCK, INT_BLOCK_SIZE, INT_SIZE,\n    INT_SIZE_PTR, MSG_BLOCK, MSG_SIZE_PTR, STATE, TWO_POW_16, TWO_POW_24, TWO_POW_32, TWO_POW_8,\n};\n\nmod constants;\nmod tests;\n\n// Implementation of SHA-256 mapping a byte array of variable length to\n// 32 bytes.\n\n// Deprecated in favour of `sha256_var`\n// docs:start:sha256\npub fn sha256<let N: u32>(input: [u8; N]) -> HASH\n// docs:end:sha256\n{\n    digest(input)\n}\n\n// SHA-256 hash function\n#[no_predicates]\npub fn digest<let N: u32>(msg: [u8; N]) -> HASH {\n    sha256_var(msg, N as u64)\n}\n\n// Variable size SHA-256 hash\npub fn sha256_var<let N: u32>(msg: [u8; N], message_size: u64) -> HASH {\n    let message_size = message_size as u32;\n    assert(message_size <= N);\n\n    if std::runtime::is_unconstrained() {\n        // Safety: SHA256 is running as an unconstrained function.\n        unsafe {\n            __sha256_var(msg, message_size)\n        }\n    } else {\n        let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n        // Intermediate hash, starting with the canonical initial value\n        let mut h: STATE = INITIAL_STATE;\n        // Pointer into msg_block on a 64 byte scale\n        let mut msg_byte_ptr = 0;\n        let num_blocks = N / BLOCK_SIZE;\n        for i in 0..num_blocks {\n            let msg_start = BLOCK_SIZE * i;\n            let (new_msg_block, new_msg_byte_ptr) =\n                unsafe { build_msg_block(msg, message_size, msg_start) };\n\n            if msg_start < message_size {\n                msg_block = new_msg_block;\n            }\n\n            // Verify the block we are compressing was appropriately constructed\n            let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n            if msg_start < message_size {\n                msg_byte_ptr = new_msg_byte_ptr;\n            }\n\n            // If the block is filled, compress it.\n            // An un-filled block is handled after this loop.\n            if (msg_start < message_size) & (msg_byte_ptr == BLOCK_SIZE) {\n                h = sha256_compression(msg_block, h);\n            }\n        }\n\n        let modulo = N % BLOCK_SIZE;\n        // Handle setup of the final msg block.\n        // This case is only hit if the msg is less than the block size,\n        // or our message cannot be evenly split into blocks.\n        if modulo != 0 {\n            let msg_start = BLOCK_SIZE * num_blocks;\n            let (new_msg_block, new_msg_byte_ptr) =\n                unsafe { build_msg_block(msg, message_size, msg_start) };\n\n            if msg_start < message_size {\n                msg_block = new_msg_block;\n            }\n\n            let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n            if msg_start < message_size {\n                msg_byte_ptr = new_msg_byte_ptr;\n                verify_msg_block_padding(msg_block, msg_byte_ptr);\n            }\n        }\n\n        // If we had modulo == 0 then it means the last block was full,\n        // and we can reset the pointer to zero to overwrite it.\n        if msg_byte_ptr == BLOCK_SIZE {\n            msg_byte_ptr = 0;\n        }\n\n        // Pad the rest such that we have a [u32; 2] block at the end representing the length\n        // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n        // Here we rely on the fact that everything beyond the available input is set to 0.\n        let index = msg_byte_ptr / INT_SIZE;\n        msg_block[index] = set_item_byte_then_zeros(msg_block[index], msg_byte_ptr, 1 << 7);\n\n        msg_byte_ptr = msg_byte_ptr + 1;\n        let last_block = msg_block;\n\n        // If we don't have room to write the size, compress the block and reset it.\n        if msg_byte_ptr > MSG_SIZE_PTR {\n            h = sha256_compression(msg_block, h);\n            // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n            msg_byte_ptr = 0;\n        }\n\n        msg_block = unsafe { attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size) };\n\n        verify_msg_len(msg_block, last_block, msg_byte_ptr, message_size);\n\n        hash_final_block(msg_block, h)\n    }\n}\n\n// Variable size SHA-256 hash\nunconstrained fn __sha256_var<let N: u32>(msg: [u8; N], message_size: u32) -> HASH {\n    let num_full_blocks = message_size / BLOCK_SIZE;\n    // Intermediate hash, starting with the canonical initial value\n    let mut h: STATE = INITIAL_STATE;\n    // Pointer into msg_block on a 64 byte scale\n    for i in 0..num_full_blocks {\n        let (msg_block, _) = build_msg_block(msg, message_size, BLOCK_SIZE * i);\n        h = sha256_compression(msg_block, h);\n    }\n\n    // Handle setup of the final msg block.\n    // This case is only hit if the msg is less than the block size,\n    // or our message cannot be evenly split into blocks.\n    let modulo = message_size % BLOCK_SIZE;\n    let (mut msg_block, mut msg_byte_ptr): (INT_BLOCK, u32) = if modulo != 0 {\n        let msg_start = BLOCK_SIZE * num_full_blocks;\n        let (new_msg_block, new_msg_byte_ptr) = build_msg_block(msg, message_size, msg_start);\n\n        (new_msg_block, new_msg_byte_ptr)\n    } else {\n        // If we had modulo == 0 then it means the last block was full,\n        // and we can reset the pointer to zero to overwrite it.\n        ([0; INT_BLOCK_SIZE], 0)\n    };\n\n    // Pad the rest such that we have a [u32; 2] block at the end representing the length\n    // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n    // Here we rely on the fact that everything beyond the available input is set to 0.\n    let index = msg_byte_ptr / INT_SIZE;\n    msg_block[index] = set_item_byte_then_zeros(msg_block[index], msg_byte_ptr, 1 << 7);\n\n    // If we don't have room to write the size, compress the block and reset it.\n    let (h, mut msg_byte_ptr): (STATE, u32) = if msg_byte_ptr >= MSG_SIZE_PTR {\n        // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n        (sha256_compression(msg_block, h), 0)\n    } else {\n        (h, msg_byte_ptr + 1)\n    };\n    msg_block = attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size);\n\n    hash_final_block(msg_block, h)\n}\n\n// Take `BLOCK_SIZE` number of bytes from `msg` starting at `msg_start`.\n// Returns the block and the length that has been copied rather than padded with zeros.\nunconstrained fn build_msg_block<let N: u32>(\n    msg: [u8; N],\n    message_size: u32,\n    msg_start: u32,\n) -> (MSG_BLOCK, BLOCK_BYTE_PTR) {\n    let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n\n    // We insert `BLOCK_SIZE` bytes (or up to the end of the message)\n    let block_input = if message_size < msg_start {\n        // This function is sometimes called with `msg_start` past the end of the message.\n        // In this case we return an empty block and zero pointer to signal that the result should be ignored.\n        0\n    } else if message_size < msg_start + BLOCK_SIZE {\n        message_size - msg_start\n    } else {\n        BLOCK_SIZE\n    };\n\n    // Figure out the number of items in the int array that we have to pack.\n    // e.g. if the input is [0,1,2,3,4,5] then we need to pack it as 2 items: [0123, 4500]\n    let mut int_input = block_input / INT_SIZE;\n    if block_input % INT_SIZE != 0 {\n        int_input = int_input + 1;\n    };\n\n    for i in 0..int_input {\n        let mut msg_item: u32 = 0;\n        // Always construct the integer as 4 bytes, even if it means going beyond the input.\n        for j in 0..INT_SIZE {\n            let k = i * INT_SIZE + j;\n            let msg_byte = if k < block_input {\n                msg[msg_start + k]\n            } else {\n                0\n            };\n            msg_item = lshift8(msg_item, 1) + msg_byte as u32;\n        }\n        msg_block[i] = msg_item;\n    }\n\n    // Returning the index as if it was a 64 byte array.\n    // We have to project it down to 16 items and bit shifting to get a byte back if we need it.\n    (msg_block, block_input)\n}\n\n// Verify the block we are compressing was appropriately constructed by `build_msg_block`\n// and matches the input data. Returns the index of the first unset item.\n// If `message_size` is less than `msg_start` then this is called with the old non-empty block;\n// in that case we can skip verification, ie. no need to check that everything is zero.\nfn verify_msg_block<let N: u32>(\n    msg: [u8; N],\n    message_size: u32,\n    msg_block: MSG_BLOCK,\n    msg_start: u32,\n) -> BLOCK_BYTE_PTR {\n    let mut msg_byte_ptr = 0;\n    let mut msg_end = msg_start + BLOCK_SIZE;\n    if msg_end > N {\n        msg_end = N;\n    }\n    // We might have to go beyond the input to pad the fields.\n    if msg_end % INT_SIZE != 0 {\n        msg_end = msg_end + INT_SIZE - msg_end % INT_SIZE;\n    }\n\n    // Reconstructed packed item.\n    let mut msg_item: u32 = 0;\n\n    // Inclusive at the end so that we can compare the last item.\n    let mut i: u32 = 0;\n    for k in msg_start..=msg_end {\n        if k % INT_SIZE == 0 {\n            // If we consumed some input we can compare against the block.\n            if (msg_start < message_size) & (k > msg_start) {\n                assert_eq(msg_block[i], msg_item as u32);\n                i = i + 1;\n                msg_item = 0;\n            }\n        }\n        // Shift the accumulator\n        msg_item = lshift8(msg_item, 1);\n        // If we have input to consume, add it at the rightmost position.\n        if k < message_size & k < msg_end {\n            msg_item = msg_item + msg[k] as u32;\n            msg_byte_ptr = msg_byte_ptr + 1;\n        }\n    }\n\n    msg_byte_ptr\n}\n\n// Verify the block we are compressing was appropriately padded with zeros by `build_msg_block`.\n// This is only relevant for the last, potentially partially filled block.\nfn verify_msg_block_padding(msg_block: MSG_BLOCK, msg_byte_ptr: BLOCK_BYTE_PTR) {\n    // Check all the way to the end of the block.\n    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_BLOCK_SIZE);\n}\n\n// Verify that a region of ints in the message block are (partially) zeroed,\n// up to an (exclusive) maximum which can either be the end of the block\n// or just where the size is to be written.\nfn verify_msg_block_zeros(\n    msg_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n    max_int_byte_ptr: u32,\n) {\n    // This variable is used to get around the compiler under-constrained check giving a warning.\n    // We want to check against a constant zero, but if it does not come from the circuit inputs\n    // or return values the compiler check will issue a warning.\n    let zero = msg_block[0] - msg_block[0];\n\n    // First integer which is supposed to be (partially) zero.\n    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n    // Check partial zeros.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        let zeros = INT_SIZE - modulo;\n        let mask = if zeros == 3 {\n            TWO_POW_24\n        } else if zeros == 2 {\n            TWO_POW_16\n        } else {\n            TWO_POW_8\n        };\n        assert_eq(msg_block[int_byte_ptr] % mask, zero);\n        int_byte_ptr = int_byte_ptr + 1;\n    }\n\n    // Check the rest of the items.\n    for i in 0..max_int_byte_ptr {\n        if i >= int_byte_ptr {\n            assert_eq(msg_block[i], zero);\n        }\n    }\n}\n\n// Verify that up to the byte pointer the two blocks are equal.\n// At the byte pointer the new block can be partially zeroed.\nfn verify_msg_block_equals_last(\n    msg_block: MSG_BLOCK,\n    last_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n) {\n    // msg_byte_ptr is the position at which they are no longer have to be the same.\n    // First integer which is supposed to be (partially) zero contains that pointer.\n    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n    // Check partial zeros.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        // Reconstruct the partially zero item from the last block.\n        let last_field = last_block[int_byte_ptr];\n        let mut msg_item: u32 = 0;\n        // Reset to where they are still equal.\n        msg_byte_ptr = msg_byte_ptr - modulo;\n        for i in 0..INT_SIZE {\n            msg_item = lshift8(msg_item, 1);\n            if i < modulo {\n                msg_item = msg_item + get_item_byte(last_field, msg_byte_ptr) as u32;\n                msg_byte_ptr = msg_byte_ptr + 1;\n            }\n        }\n        assert_eq(msg_block[int_byte_ptr], msg_item);\n    }\n\n    for i in 0..INT_SIZE_PTR {\n        if i < int_byte_ptr {\n            assert_eq(msg_block[i], last_block[i]);\n        }\n    }\n}\n\n// Set the rightmost `zeros` number of bytes to 0.\n#[inline_always]\nfn set_item_zeros(item: u32, zeros: u8) -> u32 {\n    lshift8(rshift8(item, zeros), zeros)\n}\n\n// Replace one byte in the item with a value, and set everything after it to zero.\nfn set_item_byte_then_zeros(msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR, msg_byte: u8) -> u32 {\n    let zeros = INT_SIZE - msg_byte_ptr % INT_SIZE;\n    let zeroed_item = set_item_zeros(msg_item, zeros as u8);\n    let new_item = byte_into_item(msg_byte, msg_byte_ptr);\n    zeroed_item + new_item\n}\n\n// Get a byte of a message item according to its overall position in the `BLOCK_SIZE` space.\nfn get_item_byte(mut msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR) -> u8 {\n    // How many times do we have to shift to the right to get to the position we want?\n    let max_shifts = INT_SIZE - 1;\n    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n    msg_item = rshift8(msg_item, shifts as u8);\n    // At this point the byte we want is in the rightmost position.\n    msg_item as u8\n}\n\n// Project a byte into a position in a field based on the overall block pointer.\n// For example putting 1 into pointer 5 would be 100, because overall we would\n// have [____, 0100] with indexes [0123,4567].\n#[inline_always]\nfn byte_into_item(msg_byte: u8, msg_byte_ptr: BLOCK_BYTE_PTR) -> u32 {\n    let mut msg_item = msg_byte as u32;\n    // How many times do we have to shift to the left to get to the position we want?\n    let max_shifts = INT_SIZE - 1;\n    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n    lshift8(msg_item, shifts as u8)\n}\n\n// Construct a field out of 4 bytes.\n#[inline_always]\nfn make_item(b0: u8, b1: u8, b2: u8, b3: u8) -> u32 {\n    let mut item = b0 as u32;\n    item = lshift8(item, 1) + b1 as u32;\n    item = lshift8(item, 1) + b2 as u32;\n    item = lshift8(item, 1) + b3 as u32;\n    item\n}\n\n// Shift by 8 bits to the left between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise multiplies by 256.\n#[inline_always]\nfn lshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        // Brillig wouldn't shift 0<<4 without overflow.\n        if shifts >= 4 {\n            0\n        } else {\n            item << (8 * shifts)\n        }\n    } else {\n        // We can do a for loop up to INT_SIZE or an if-else.\n        if shifts == 0 {\n            item\n        } else if shifts == 1 {\n            item * TWO_POW_8\n        } else if shifts == 2 {\n            item * TWO_POW_16\n        } else if shifts == 3 {\n            item * TWO_POW_24\n        } else {\n            // Doesn't make sense, but it's most likely called on 0 anyway.\n            0\n        }\n    }\n}\n\n// Shift by 8 bits to the right between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise divides by 256.\nfn rshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        item >> (8 * shifts)\n    } else {\n        // Division wouldn't work on `Field`.\n        if shifts == 0 {\n            item\n        } else if shifts == 1 {\n            item / TWO_POW_8\n        } else if shifts == 2 {\n            item / TWO_POW_16\n        } else if shifts == 3 {\n            item / TWO_POW_24\n        } else {\n            0\n        }\n    }\n}\n\n// Zero out all bytes between the end of the message and where the length is appended,\n// then write the length into the last 8 bytes of the block.\nunconstrained fn attach_len_to_msg_block(\n    mut msg_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n    message_size: u32,\n) -> MSG_BLOCK {\n    // We assume that `msg_byte_ptr` is less than 57 because if not then it is reset to zero before calling this function.\n    // In any case, fill blocks up with zeros until the last 64 bits (i.e. until msg_byte_ptr = 56).\n    // There can be one item which has to be partially zeroed.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        // Index of the block in which we find the item we need to partially zero.\n        let i = msg_byte_ptr / INT_SIZE;\n        let zeros = INT_SIZE - modulo;\n        msg_block[i] = set_item_zeros(msg_block[i], zeros as u8);\n        msg_byte_ptr = msg_byte_ptr + zeros;\n    }\n\n    // The rest can be zeroed without bit shifting anything.\n    for i in (msg_byte_ptr / INT_SIZE)..INT_SIZE_PTR {\n        msg_block[i] = 0;\n    }\n\n    // Set the last two 4 byte ints as the first/second half of the 8 bytes of the length.\n    let len = 8 * message_size;\n    let len_bytes: [u8; 8] = (len as Field).to_be_bytes();\n    for i in 0..=1 {\n        let shift = i * 4;\n        msg_block[INT_SIZE_PTR + i] = make_item(\n            len_bytes[shift],\n            len_bytes[shift + 1],\n            len_bytes[shift + 2],\n            len_bytes[shift + 3],\n        );\n    }\n    msg_block\n}\n\n// Verify that the message length was correctly written by `attach_len_to_msg_block`,\n// and that everything between the byte pointer and the size pointer was zeroed,\n// and that everything before the byte pointer was untouched.\nfn verify_msg_len(\n    msg_block: MSG_BLOCK,\n    last_block: MSG_BLOCK,\n    msg_byte_ptr: BLOCK_BYTE_PTR,\n    message_size: u32,\n) {\n    // Check zeros up to the size pointer.\n    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_SIZE_PTR);\n\n    // Check that up to the pointer we match the last block.\n    verify_msg_block_equals_last(msg_block, last_block, msg_byte_ptr);\n\n    // We verify the message length was inserted correctly by reversing the byte decomposition.\n    let mut reconstructed_len: u64 = 0;\n    for i in INT_SIZE_PTR..INT_BLOCK_SIZE {\n        reconstructed_len = reconstructed_len * TWO_POW_32;\n        reconstructed_len = reconstructed_len + msg_block[i] as u64;\n    }\n    let len = 8 * message_size as u64;\n    assert_eq(reconstructed_len, len);\n}\n\n// Perform the final compression, then transform the `STATE` into `HASH`.\nfn hash_final_block(msg_block: MSG_BLOCK, mut state: STATE) -> HASH {\n    let mut out_h: HASH = [0; 32]; // Digest as sequence of bytes\n    // Hash final padded block\n    state = sha256_compression(msg_block, state);\n\n    // Return final hash as byte array\n    for j in 0..8 {\n        let h_bytes: [u8; 4] = (state[j] as Field).to_be_bytes();\n        for k in 0..4 {\n            out_h[4 * j + k] = h_bytes[k];\n        }\n    }\n\n    out_h\n}\n\nmod equivalence_test {\n\n    #[test]\n    fn test_implementations_agree(msg: [u8; 100], message_size: u64) {\n        let message_size = message_size % 100;\n        let unconstrained_sha = unsafe { super::__sha256_var(msg, message_size as u32) };\n        let sha = super::sha256_var(msg, message_size);\n        assert_eq(sha, unconstrained_sha);\n    }\n}\n"
     },
@@ -3027,7 +3029,7 @@
     },
     "55": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/capsules/mod.nr",
-      "source": "use crate::oracle::capsules;\nuse protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// A dynamically sized array backed by PXE's non-volatile database (called capsules). Values are persisted until\n/// deleted, so they can be e.g. stored during simulation of a transaction and later retrieved during witness\n/// generation. All values are scoped per contract address, so external contracts cannot access them.\npub struct CapsuleArray<T> {\n    contract_address: AztecAddress,\n    /// The base slot is where the array length is stored in capsules. Array elements are stored in consecutive slots\n    /// after the base slot. For example, with base slot 5: the length is at slot 5, the first element (index 0) is at\n    /// slot 6, the second element (index 1) is at slot 7, and so on.\n    base_slot: Field,\n}\n\nimpl<T> CapsuleArray<T> {\n    /// Returns a CapsuleArray connected to a contract's capsules at a base slot. Array elements are stored in\n    /// contiguous slots following the base slot, so there should be sufficient space between array base slots to\n    /// accommodate elements. A reasonable strategy is to make the base slot a hash of a unique value.\n    pub unconstrained fn at(contract_address: AztecAddress, base_slot: Field) -> Self {\n        Self { contract_address, base_slot }\n    }\n\n    /// Returns the number of elements stored in the array.\n    pub unconstrained fn len(self) -> u32 {\n        // An uninitialized array defaults to a length of 0.\n        capsules::load(self.contract_address, self.base_slot).unwrap_or(0) as u32\n    }\n\n    /// Stores a value at the end of the array.\n    pub unconstrained fn push<let N: u32>(self, value: T)\n    where\n        T: Serialize<N>,\n    {\n        let current_length = self.len();\n\n        // The slot corresponding to the index `current_length` is the first slot immediately after the end of the\n        // array, which is where we want to place the new value.\n        capsules::store(self.contract_address, self.slot_at(current_length), value);\n\n        // Then we simply update the length.\n        let new_length = current_length + 1;\n        capsules::store(self.contract_address, self.base_slot, new_length);\n    }\n\n    /// Retrieves the value stored in the array at `index`. Throws if the index is out of bounds.\n    pub unconstrained fn get<let N: u32>(self, index: u32) -> T\n    where\n        T: Deserialize<N>,\n    {\n        assert(index < self.len(), \"Attempted to read past the length of a CapsuleArray\");\n\n        capsules::load(self.contract_address, self.slot_at(index)).unwrap()\n    }\n\n    /// Deletes the value stored in the array at `index`. Throws if the index is out of bounds.\n    pub unconstrained fn remove(self, index: u32) {\n        let current_length = self.len();\n        assert(index < current_length, \"Attempted to delete past the length of a CapsuleArray\");\n\n        // In order to be able to remove elements at arbitrary indices, we need to shift the entire contents of the\n        // array past the removed element one slot backward so that we don't end up with a gap and preserve the\n        // contiguous slots. We can skip this when deleting the last element however.\n        if index != current_length - 1 {\n            // The source and destination regions overlap, but `copy` supports this.\n            capsules::copy(\n                self.contract_address,\n                self.slot_at(index + 1),\n                self.slot_at(index),\n                current_length - index - 1,\n            );\n        }\n\n        // We can now delete the last element (which has either been copied to the slot immediately before it, or was\n        // the element we meant to delete in the first place) and update the length.\n        capsules::delete(self.contract_address, self.slot_at(current_length - 1));\n        capsules::store(self.contract_address, self.base_slot, current_length - 1);\n    }\n\n    unconstrained fn slot_at(self, index: u32) -> Field {\n        // Elements are stored immediately after the base slot, so we add 1 to it to compute the slot for the first\n        // element.\n        self.base_slot + 1 + index as Field\n    }\n}\n\nmod test {\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use super::CapsuleArray;\n    use protocol_types::address::AztecAddress;\n\n    global SLOT: Field = 1230;\n\n    unconstrained fn setup() -> AztecAddress {\n        TestEnvironment::new().unkonstrained().this_address()\n    }\n\n    #[test]\n    unconstrained fn empty_array() {\n        let contract_address = setup();\n\n        let array: CapsuleArray<Field> = CapsuleArray::at(contract_address, SLOT);\n        assert_eq(array.len(), 0);\n    }\n\n    #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n    unconstrained fn empty_array_read() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n        let _: Field = array.get(0);\n    }\n\n    #[test]\n    unconstrained fn array_push() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n        array.push(5);\n\n        assert_eq(array.len(), 1);\n        assert_eq(array.get(0), 5);\n    }\n\n    #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n    unconstrained fn read_past_len() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n        array.push(5);\n\n        let _ = array.get(1);\n    }\n\n    #[test]\n    unconstrained fn array_remove_last() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n\n        array.push(5);\n        array.remove(0);\n\n        assert_eq(array.len(), 0);\n    }\n\n    #[test]\n    unconstrained fn array_remove_some() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n\n        array.push(7);\n        array.push(8);\n        array.push(9);\n\n        assert_eq(array.len(), 3);\n        assert_eq(array.get(0), 7);\n        assert_eq(array.get(1), 8);\n        assert_eq(array.get(2), 9);\n\n        array.remove(1);\n\n        assert_eq(array.len(), 2);\n        assert_eq(array.get(0), 7);\n        assert_eq(array.get(1), 9);\n    }\n\n    #[test]\n    unconstrained fn array_remove_all() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n\n        array.push(7);\n        array.push(8);\n        array.push(9);\n\n        array.remove(1);\n        array.remove(1);\n        array.remove(0);\n\n        assert_eq(array.len(), 0);\n    }\n}\n"
+      "source": "use crate::oracle::capsules;\nuse protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// A dynamically sized array backed by PXE's non-volatile database (called capsules). Values are persisted until\n/// deleted, so they can be e.g. stored during simulation of a transaction and later retrieved during witness\n/// generation. All values are scoped per contract address, so external contracts cannot access them.\npub struct CapsuleArray<T> {\n    contract_address: AztecAddress,\n    /// The base slot is where the array length is stored in capsules. Array elements are stored in consecutive slots\n    /// after the base slot. For example, with base slot 5: the length is at slot 5, the first element (index 0) is at\n    /// slot 6, the second element (index 1) is at slot 7, and so on.\n    base_slot: Field,\n}\n\nimpl<T> CapsuleArray<T> {\n    /// Returns a CapsuleArray connected to a contract's capsules at a base slot. Array elements are stored in\n    /// contiguous slots following the base slot, so there should be sufficient space between array base slots to\n    /// accommodate elements. A reasonable strategy is to make the base slot a hash of a unique value.\n    pub unconstrained fn at(contract_address: AztecAddress, base_slot: Field) -> Self {\n        Self { contract_address, base_slot }\n    }\n\n    /// Returns the number of elements stored in the array.\n    pub unconstrained fn len(self) -> u32 {\n        // An uninitialized array defaults to a length of 0.\n        capsules::load(self.contract_address, self.base_slot).unwrap_or(0) as u32\n    }\n\n    /// Stores a value at the end of the array.\n    pub unconstrained fn push<let N: u32>(self, value: T)\n    where\n        T: Serialize<N>,\n    {\n        let current_length = self.len();\n\n        // The slot corresponding to the index `current_length` is the first slot immediately after the end of the\n        // array, which is where we want to place the new value.\n        capsules::store(self.contract_address, self.slot_at(current_length), value);\n\n        // Then we simply update the length.\n        let new_length = current_length + 1;\n        capsules::store(self.contract_address, self.base_slot, new_length);\n    }\n\n    /// Retrieves the value stored in the array at `index`. Throws if the index is out of bounds.\n    pub unconstrained fn get<let N: u32>(self, index: u32) -> T\n    where\n        T: Deserialize<N>,\n    {\n        assert(index < self.len(), \"Attempted to read past the length of a CapsuleArray\");\n\n        capsules::load(self.contract_address, self.slot_at(index)).unwrap()\n    }\n\n    /// Deletes the value stored in the array at `index`. Throws if the index is out of bounds.\n    pub unconstrained fn remove(self, index: u32) {\n        let current_length = self.len();\n        assert(index < current_length, \"Attempted to delete past the length of a CapsuleArray\");\n\n        // In order to be able to remove elements at arbitrary indices, we need to shift the entire contents of the\n        // array past the removed element one slot backward so that we don't end up with a gap and preserve the\n        // contiguous slots. We can skip this when deleting the last element however.\n        if index != current_length - 1 {\n            // The source and destination regions overlap, but `copy` supports this.\n            capsules::copy(\n                self.contract_address,\n                self.slot_at(index + 1),\n                self.slot_at(index),\n                current_length - index - 1,\n            );\n        }\n\n        // We can now delete the last element (which has either been copied to the slot immediately before it, or was\n        // the element we meant to delete in the first place) and update the length.\n        capsules::delete(self.contract_address, self.slot_at(current_length - 1));\n        capsules::store(self.contract_address, self.base_slot, current_length - 1);\n    }\n\n    unconstrained fn slot_at(self, index: u32) -> Field {\n        // Elements are stored immediately after the base slot, so we add 1 to it to compute the slot for the first\n        // element.\n        self.base_slot + 1 + index as Field\n    }\n}\n\nmod test {\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use super::CapsuleArray;\n    use protocol_types::address::AztecAddress;\n\n    global SLOT: Field = 1230;\n\n    unconstrained fn setup() -> AztecAddress {\n        TestEnvironment::new().utility().this_address()\n    }\n\n    #[test]\n    unconstrained fn empty_array() {\n        let contract_address = setup();\n\n        let array: CapsuleArray<Field> = CapsuleArray::at(contract_address, SLOT);\n        assert_eq(array.len(), 0);\n    }\n\n    #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n    unconstrained fn empty_array_read() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n        let _: Field = array.get(0);\n    }\n\n    #[test]\n    unconstrained fn array_push() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n        array.push(5);\n\n        assert_eq(array.len(), 1);\n        assert_eq(array.get(0), 5);\n    }\n\n    #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n    unconstrained fn read_past_len() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n        array.push(5);\n\n        let _ = array.get(1);\n    }\n\n    #[test]\n    unconstrained fn array_remove_last() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n\n        array.push(5);\n        array.remove(0);\n\n        assert_eq(array.len(), 0);\n    }\n\n    #[test]\n    unconstrained fn array_remove_some() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n\n        array.push(7);\n        array.push(8);\n        array.push(9);\n\n        assert_eq(array.len(), 3);\n        assert_eq(array.get(0), 7);\n        assert_eq(array.get(1), 8);\n        assert_eq(array.get(2), 9);\n\n        array.remove(1);\n\n        assert_eq(array.len(), 2);\n        assert_eq(array.get(0), 7);\n        assert_eq(array.get(1), 9);\n    }\n\n    #[test]\n    unconstrained fn array_remove_all() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n\n        array.push(7);\n        array.push(8);\n        array.push(9);\n\n        array.remove(1);\n        array.remove(1);\n        array.remove(0);\n\n        assert_eq(array.len(), 0);\n    }\n}\n"
     },
     "56": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr",
@@ -3050,8 +3052,8 @@
       "source": "use crate::{hash::hash_args_array, oracle::execution_cache};\nuse dep::protocol_types::traits::Deserialize;\n\npub struct ReturnsHash {\n    hash: Field,\n}\n\nimpl ReturnsHash {\n    pub fn new(hash: Field) -> Self {\n        ReturnsHash { hash }\n    }\n\n    pub fn assert_empty(self) {\n        assert_eq(self.hash, 0);\n    }\n\n    pub fn raw(self) -> Field {\n        self.hash\n    }\n\n    /// This is only used during private execution, since in public it is the VM itself that keeps track of return\n    /// values.\n    pub fn get_preimage<T, let N: u32>(self) -> T\n    where\n        T: Deserialize<N>,\n    {\n        // Safety: We verify that the value returned by `load` is the preimage of `hash`, fully constraining it.\n        let preimage: [Field; N] = unsafe { execution_cache::load(self.hash) };\n        assert_eq(self.hash, hash_args_array(preimage));\n\n        Deserialize::deserialize(preimage)\n    }\n}\n"
     },
     "66": {
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/unconstrained_context.nr",
-      "source": "use crate::oracle::{\n    execution::{get_block_number, get_chain_id, get_contract_address, get_version},\n    storage::storage_read,\n};\nuse dep::protocol_types::{address::AztecAddress, traits::Packable};\n\npub struct UnconstrainedContext {\n    block_number: u32,\n    contract_address: AztecAddress,\n    version: Field,\n    chain_id: Field,\n}\n\nimpl UnconstrainedContext {\n    pub unconstrained fn new() -> Self {\n        // We could call these oracles on the getters instead of at creation, which makes sense given that they might\n        // not even be accessed. However any performance gains are minimal, and we'd rather fail early if a user\n        // incorrectly attempts to create an UnconstrainedContext in an environment in which these oracles are not\n        // available.\n        let block_number = get_block_number();\n        let contract_address = get_contract_address();\n        let chain_id = get_chain_id();\n        let version = get_version();\n        Self { block_number, contract_address, version, chain_id }\n    }\n\n    pub unconstrained fn at(contract_address: AztecAddress) -> Self {\n        let block_number = get_block_number();\n        let chain_id = get_chain_id();\n        let version = get_version();\n        Self { block_number, contract_address, version, chain_id }\n    }\n\n    pub unconstrained fn at_historical(contract_address: AztecAddress, block_number: u32) -> Self {\n        let chain_id = get_chain_id();\n        let version = get_version();\n        Self { block_number, contract_address, version, chain_id }\n    }\n\n    pub fn block_number(self) -> u32 {\n        self.block_number\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.contract_address\n    }\n\n    pub fn version(self) -> Field {\n        self.version\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.chain_id\n    }\n\n    pub unconstrained fn raw_storage_read<let N: u32>(\n        self: Self,\n        storage_slot: Field,\n    ) -> [Field; N] {\n        storage_read(self.this_address(), storage_slot, self.block_number())\n    }\n\n    pub unconstrained 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"
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/utility_context.nr",
+      "source": "use crate::oracle::{\n    execution::{get_block_number, get_chain_id, get_contract_address, get_version},\n    storage::storage_read,\n};\nuse dep::protocol_types::{address::AztecAddress, traits::Packable};\n\npub struct UtilityContext {\n    block_number: u32,\n    contract_address: AztecAddress,\n    version: Field,\n    chain_id: Field,\n}\n\nimpl UtilityContext {\n    pub unconstrained fn new() -> Self {\n        // We could call these oracles on the getters instead of at creation, which makes sense given that they might\n        // not even be accessed. However any performance gains are minimal, and we'd rather fail early if a user\n        // incorrectly attempts to create a UtilityContext in an environment in which these oracles are not\n        // available.\n        let block_number = get_block_number();\n        let contract_address = get_contract_address();\n        let chain_id = get_chain_id();\n        let version = get_version();\n        Self { block_number, contract_address, version, chain_id }\n    }\n\n    pub unconstrained fn at(contract_address: AztecAddress) -> Self {\n        let block_number = get_block_number();\n        let chain_id = get_chain_id();\n        let version = get_version();\n        Self { block_number, contract_address, version, chain_id }\n    }\n\n    pub unconstrained fn at_historical(contract_address: AztecAddress, block_number: u32) -> Self {\n        let chain_id = get_chain_id();\n        let version = get_version();\n        Self { block_number, contract_address, version, chain_id }\n    }\n\n    pub fn block_number(self) -> u32 {\n        self.block_number\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.contract_address\n    }\n\n    pub fn version(self) -> Field {\n        self.version\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.chain_id\n    }\n\n    pub unconstrained fn raw_storage_read<let N: u32>(\n        self: Self,\n        storage_slot: Field,\n    ) -> [Field; N] {\n        storage_read(self.this_address(), storage_slot, self.block_number())\n    }\n\n    pub unconstrained 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"
     },
     "68": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/mod.nr",