@aztec/protocol-contracts 0.86.0 → 0.87.0

package/artifacts/ContractInstanceDeployer.json

@@ -1,278 +1,8 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.4+0000000000000000000000000000000000000000",
+  "noir_version": "1.0.0-beta.5+0000000000000000000000000000000000000000",
   "name": "ContractInstanceDeployer",
   "functions": [
-    {
-      "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"
-          },
-          "14225679739041873922": {
-            "error_kind": "string",
-            "string": "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"
-          },
-          "14225679739041873922": {
-            "error_kind": "string",
-            "string": "Index out of bounds"
-          },
-          "15573886522241766899": {
-            "error_kind": "string",
-            "string": "New update delay is too low"
-          },
-          "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": "update",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public"
-      ],
-      "abi": {
-        "parameters": [
-          {
-            "name": "new_contract_class_id",
-            "type": {
-              "kind": "struct",
-              "path": "aztec::protocol_types::contract_class_id::ContractClassId",
-              "fields": [
-                {
-                  "name": "inner",
-                  "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."
-          },
-          "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"
-          },
-          "14225679739041873922": {
-            "error_kind": "string",
-            "string": "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": [
-        "update"
-      ]
-    },
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "aztec::macros::functions::utility"
-      ],
-      "abi": {
-        "parameters": [],
-        "return_type": null,
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        }
-      },
-      "bytecode": "H4sIAAAAAAAA/7WTPQ+CMBCGi2KUjzjgoD+jBAyM+LG4OLpXCkpUSAB3frqQXENtwKjAJU17FJ5736OVUB0SzDLqEAyyglmBecTtj8vhQY67hakIdfvku9i2lQZ/Peq3FGBKw/Ax4w/UfzwFzr6o+bwXVndWDo1b66g+H0P5Z/9vSP+LD5418GpAXnmew/oS5Nt74t+Oz8c5SNnXTR1EgnIxdK5CSd0lcZ4SP99QmgZZJhJGDWTUQlU56pVE8YG26fmRdgrSLEpikSZ/Sav6yu6lXLyr8eA57hCOizHTMAb+BDV3X+b2+feXkKuCJ+bT+1Nn6BAztEhI1oRS2yeGwK+CP38vlizs4eEFAAA=",
-      "debug_symbols": "rZJLioQwFEX38sYZ5P9xK0VTRI1FIESJ2tCIe+9YxELKpnri5JEXDpdDchdoXT0/7j52/QjVbYHQN3byfczbsiKokw/BP+7Ha8DbIOzJj4ON2zpONk1QEcwJQ+Bi+zwrmjM6HxxURqzohCstC6wxf6GS/oEKKgoqBH6hhKn1CwHhF8hopnYZYT7LcGYKyqU+yYgrZDTfZYz+LCPx/jKSypOMvEDGUFpgw8Q/MhoXVOG3b1rz+m2Tt3VwpV7dHJtD26afwb0Vb0h949o5ua2Ch/bleSMaUZZjc/Qv",
-      "brillig_names": [
-        "sync_notes"
-      ]
-    },
-    {
-      "name": "set_update_delay",
-      "is_unconstrained": true,
-      "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"
-          },
-          "14225679739041873922": {
-            "error_kind": "string",
-            "string": "Index out of bounds"
-          },
-          "15573886522241766899": {
-            "error_kind": "string",
-            "string": "New update delay is too low"
-          },
-          "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,
@@ -1546,6 +1276,14 @@
                                   "kind": "field"
                                 }
                               }
+                            },
+                            {
+                              "name": "length",
+                              "type": {
+                                "kind": "integer",
+                                "sign": "unsigned",
+                                "width": 32
+                              }
                             }
                           ]
                         }
@@ -1576,25 +1314,34 @@
                   "kind": "array",
                   "length": 1,
                   "type": {
-                    "kind": "struct",
-                    "path": "aztec::protocol_types::abis::log_hash::LogHash",
-                    "fields": [
-                      {
-                        "name": "value",
-                        "type": {
-                          "kind": "field"
-                        }
-                      },
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::side_effect::counted::Counted",
+                    "fields": [
                       {
-                        "name": "counter",
+                        "name": "inner",
                         "type": {
-                          "kind": "integer",
-                          "sign": "unsigned",
-                          "width": 32
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::abis::log_hash::LogHash",
+                          "fields": [
+                            {
+                              "name": "value",
+                              "type": {
+                                "kind": "field"
+                              }
+                            },
+                            {
+                              "name": "length",
+                              "type": {
+                                "kind": "integer",
+                                "sign": "unsigned",
+                                "width": 32
+                              }
+                            }
+                          ]
                         }
                       },
                       {
-                        "name": "length",
+                        "name": "counter",
                         "type": {
                           "kind": "integer",
                           "sign": "unsigned",
@@ -2021,42 +1768,312 @@
                     }
                   ]
                 }
-              }
-            ]
-          },
-          "visibility": "databus"
-        },
+              }
+            ]
+          },
+          "visibility": "databus"
+        },
+        "error_types": {
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "6485997221020871071": {
+            "error_kind": "string",
+            "string": "call to assert_max_bit_size"
+          },
+          "14225679739041873922": {
+            "error_kind": "string",
+            "string": "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": [
+        "store_in_execution_cache_oracle_wrapper",
+        "call_private_function_internal",
+        "decompose_hint",
+        "lte_hint",
+        "notify_created_nullifier_oracle_wrapper",
+        "debug_log_oracle_wrapper",
+        "directive_invert"
+      ],
+      "verification_key": "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"
+    },
+    {
+      "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"
+          },
+          "14225679739041873922": {
+            "error_kind": "string",
+            "string": "Index out of bounds"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        }
+      },
+      "bytecode": "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",
+      "debug_symbols": "tZnbbhs5DIbfxde5kCgepLxKURRu6hYGDCdwkwUWRd59SY1I2wVm0GjRm8w3tPQPSVGHmfzafTt8ffvx5Xj+/vxz9/jp1+7r5Xg6HX98OT0/7V+Pz2e1/tol+5OzXsqDXmn3iHqFNK7jvpRxrbtH0SvqfTYD1gEEDjKA3cJuEbcID6jJgRzagIYO9gh62EFuA6A4+E/FLcUt6BaUAZQdeAAnB3LwRwg6mKCmBio4yICWHWiBkpIDOozuJReHNgDcAt6mWC82aAN6FB1kQI+iAzl4Y/bGXAeIW8S79yg68ICWHPzpbXTHBA6jMebs4BarlFwNrHtTKDAAkwM5qKuQFAgd6gCrlgV4gCQHbyzevbqlevfm3dvoTik5oMNoTBkczJIVgAcU64UGNMCGoINlfgFrrCETm6UZ8ABxi1V4scaW8MIGMsBcLWJgFtVhG/cFNMCi3RnRwS2WMUwGakF1ldksYNAGiFssUagVxZYoVDcEsoM6hlrYUrKDW9AsbGAW9VAsZKwGPIDdYiGjOiYWMiUDtZA6JjU7uKV5L5spZqk2Ogu4xZYgc75mXPypNlM6gFtALaRxNatn0nBafxYZtAGWVYOcrHwHsZM9hdjI4ifpREHNyUZ9kDhRtOP41aYaVSNL/kLdp4XYyQZ9kAzKCYKsXTOy4Ac1JxAnm1qDoofNskHRl9Q/Tp2qk02wQexkU2wQBkWPGio1bC1UmqtASkGmko0sz4PECSCoOtnCvZBV3yDPM6CPB1AJCpvtGQy2K1n+2Pav0p+7EAY1J1tyqe9j5sFCPacLiROGDcNGYaOwcdg49CRsfUIsu2YKwqDo0aKH1UaPCJNlo2+w3ftO5n2PA3v+OpWwmfcL9UxSJ3aisFkVs80AtO1vEAaFsnj+0Op5kOe5r7eD/LmUIMjbUYwHxXj0VXch6H3f3x92fib58no5HOxIcnNI0aPLy/5yOL/uHs9vp9PD7p/96a03+vmyP/fr6/6iv2oNHs7f9KqC34+ng9H7w7V3Wu+aga34enflWkKi0Z1GXteQYmtMl5AiORT43gtYV2iQXKHpJFlT+EActBbHhoZk9EyKLiChQPde0LqCbrWuoLgaB68rVMqeiaqb8kQmRJfQiKK0tSjqRi6LzbsllZgxFDLdp7JtSNhe0xUgQQiUXO9raisMsV12CUMahwbU+zjyRmHq2jUk9Nx2VUi/KWwUpp69PZkAqa1rlI2iAA/kdkA/pNBkKHCmuTiguhNQbkbkQxqSY1BlKxL5uxq6j/sk01esOqchUlxDGsxptOQ51ePBusbWTMMYlkzIqzMNNoaFJcV8B75Zv+/nGpStSGIBz02ukWimp1YdWV11YGPxLLV4MvQtDVe9gI3lk0txN/Ttgla3oo1hrXqO9xW43kwVnoxEynokmxrVK1RfVWlVo2wMChH4bCN9jVvX2Nrca4lNsdLq5l42KlQ4VkB9fVrdFctWhep5Kyasnp94VWQzHdfdmWG9wAptbQgxLLo38M3WRn+uAfbhYGwqRLMaEhrc5jRKrBxQcp7UAAoNmvUDMDRupsuHNPSjjWtgntWAyCnenP8+qBEbHMpkTrFFfegxck6DIPJxO/U/qBH1QTxZpxTzVj874pwGX+cLY53ViLHVN4VJjXrVaLKq8cfLem6raxDB1nYdByA9a9zWev7j16UU5aEfYdbPlFsSOTYGXZ3rnASHF7nOeVHibKw45wVBuh7CZE6Cr+e42uYCuZ4mC8wFUjDe2/RjzYyEoA+IIM8INIwXeZoKoiWJLwFzHkRNNaH/GcLvAp/1dv90vNz9K+ndpC7H/dfTYdx+fzs/3fz6+u+L/+L/inq5PD8dvr1dDqZ0/X+U/vkErT0USJ/tm6neZq0s/Uppt/o56lPRJVk/531+N2f+Aw==",
+      "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"
+          },
+          "14225679739041873922": {
+            "error_kind": "string",
+            "string": "Index out of bounds"
+          },
+          "15573886522241766899": {
+            "error_kind": "string",
+            "string": "New update delay is too low"
+          },
+          "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": "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"
+          },
+          "14225679739041873922": {
+            "error_kind": "string",
+            "string": "Index out of bounds"
+          },
+          "15573886522241766899": {
+            "error_kind": "string",
+            "string": "New update delay is too low"
+          },
+          "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": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "utility"
+      ],
+      "abi": {
+        "parameters": [],
+        "return_type": null,
+        "error_types": {
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        }
+      },
+      "bytecode": "H4sIAAAAAAAA/7WTPQ+CMBCGi2KUjzjgoD+jBAyM+LG4OLpXCkpUSAB3frqQXENtwKjAJU17FJ5736OVUB0SzDLqEAyyglmBecTtj8vhQY67hakIdfvku9i2lQZ/Peq3FGBKw/Ax4w/UfzwFzr6o+bwXVndWDo1b66g+H0P5Z/9vSP+LD5418GpAXnmew/oS5Nt74t+Oz8c5SNnXTR1EgnIxdK5CSd0lcZ4SP99QmgZZJhJGDWTUQlU56pVE8YG26fmRdgrSLEpikSZ/Sav6yu6lXLyr8eA57hCOizHTMAb+BDV3X+b2+feXkKuCJ+bT+1Nn6BAztEhI1oRS2yeGwK+CP38vlizs4eEFAAA=",
+      "debug_symbols": "nZPfioQgFIff5Vx34f+0VxmGwcoGQSycWliid18bdKYWXJa58WSe7+tX6Qq9aZf7zfphfEBzWaEN1jl7v7mx07Mdfby7AtoHTKGhFWAGDY+FQ1PHIqBR21ZB7r/NwZi9/SCI2kkH42do/OJcBV/aLc+mx6T9s846xFVUgfF9rFE4WGf2q61606iMYsSZSDhGAvGXQvGTA5cdtcwGidiLF+TEkzLPCU885+9XwLT+bwBJ6xyAq1IAVuYZVYlnQn4UQLIcQMlSAFHm43dPvCDikwCKkCRQlJcCyD8CyLyHavTrF1zjVHc2nLb2tquC1a0zaTosvjuszt9TXslHYwpjZ/olmN10OB9xvGBZEXrd9qf9AA==",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
+    {
+      "name": "update",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public"
+      ],
+      "abi": {
+        "parameters": [
+          {
+            "name": "new_contract_class_id",
+            "type": {
+              "kind": "struct",
+              "path": "aztec::protocol_types::contract_class_id::ContractClassId",
+              "fields": [
+                {
+                  "name": "inner",
+                  "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."
+          },
+          "2920182694213909827": {
+            "error_kind": "string",
+            "string": "attempt to subtract with overflow"
+          },
           "5019202896831570965": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "6485997221020871071": {
+          "6504213605561840204": {
             "error_kind": "string",
-            "string": "call to assert_max_bit_size"
+            "string": "New contract class is not registered"
+          },
+          "10019982601749771606": {
+            "error_kind": "string",
+            "string": "msg.sender is not deployed"
           },
           "14225679739041873922": {
             "error_kind": "string",
             "string": "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": "7V3bbts4EP0XP/uBcyWnv7JYFGmbFgGCpEjTBRZF/r2SE5GMTUlgbLd0y5cgsudQh+dI5JCi6B+bT9cfvn95f3P3+f7b5t0/Pza39x+vHm/u74ajHxsIu8++fb26Gw+/PV49PG7eobDfbq7vPg3/KuDTdvP55vZ6887kaXsYjOymYNQUrFoIJmfyEkygYTkYxGCKHv7HFI7eSvEqYQpX71O0FUsnpSmawb2K/ne7AevKlJVB15WZUQa6MjPKYFdmRhnqyswow12ZGWWkKzOjjHZlZpTxXZkZZXoOPKdMz4FnlKGeA88p03PgOWV6DjynTM+B55ThrsyMMj0HnlOm58BzyjSeAwsmZcaYRWUQUCcmwHKkMo3nwL9RmcZz4N+nDJdzYA6QlKFlZRiAX4IZJJ1BbHcCOPcJihnZgLEJg5AcGOEHwZIUFVJLbKDkLcQLgUCS/IKXfSFQl/EUMnKX8RQyyqqMeWVLMhJhVCaXsayMnxIUJoihQGFHRk9Axk/BxKTLZEDRR3GUg+23eL4xPuEX8/FZPuk1yD4fa4uPuJPyUQfLfIZ7aIp12U0OOy7F7phZYg8rRMtcADHWFi3L/ZUL0apTRx+cZbGlRiFg7OgDCqw0ON54as28Ga5EU2zMGJKfYMWmDMOkNpLDlWgYmtVJD8rGQjPRDmOr6lReRY/+YPenaX+o+9O0P9z9WffHQ0zVPLk1xX3q/b3hkf5I96dpf/R4fyD5Q6805+IwIw4bQE1WortDG/HdocYdKo+HJA4SWDPRy/k+hDSst2zorcVJgMRnmA9ILSI56VlC0SHrDrXtkLruUOMOQXeocYewO9S4Q9Qdatwh7g417pB0hxp3SLtDjTvku0ONO9TnFFp3qM8pNO6Q73MKrTvU5xRad6jPKbTuUJ9TaPz5kOfuUOMOnWBOAXF6uYAohBWHuuYbr13zX675Ccb9TFFzDrDWEoHzqSXK+BTXiBtNa3fAsmYL/I57aJk7OhdfF3JIOffDYImWiiXKsFt87q3tanK8dl22yL66msE1XU2IPBAC712JAZrmnqeiGJYtAkqtCxnsVxT/lorSn1NRia8ZgDAecYdy1+RAE/mDNIkLZYfGjo/QRLsmB5qcIs+C9EZSwBVN2GwqWpzYsiYsFteOKrs8eOQeTsx9bbQKHP0EprDMXX3Ms9TjAXe7XO7mLpg7XDB3bJp7iIuxNbDuc6cL5s4XzF0umLu2zN2bj5M0DvzKhIGzNJHuTA6q6v+eqjbdawfE+FZWvpnK26radCd/VFVtr6rgmk4KTlzXppOIhbruyDedRayRp8sZrtABeb5k8uVEwscOnD2vbR9jkgai2UMQKT4fCBKvGnNZn8P2zEeP5qMuTA9OFLJH4UU+484x2S4yB1tpDEP91ggVO1pJE8aCWcpVJBRc7PcpXT7ow/MJit2bEESXifzyCYAwbVBC6OXIOoNri9Jw8OHh5vb25sv7Vz+M4sY/5a2EJD5aEp8lFEsb/ixDfD0k1EOsEjIcwRhZ/oECJYsJZzZvRjy/c/8yROohWg/x9ZBQDylKHTBC8geSz5DyftLLEKiHYD2E6iFcD5F6SNH9EGJ7mM+kUul1c9K4o5lPE7QkPL9V6OmKD+ct3s5afHnnx9MVD+ctHs9bPJ23eD5h8YEOipfzFq/nLb5411rM8CzLLV7akXJXugyxakh5H7dlCNRDsB5C9RCuhpRftFuGaD2k3n2td1/r3ff17vt698vrqzGuPUP1+/dLecHvMoTrIeWt2n3cQdkObuTyir5liK+HhHqIVUPK65OWIVAJGY5wjIRy++owTdmky6b0KFp5aopVXi09G1iBP2fh4djC47bQGvYX/JV/zLGq8Omxn3f7zMu/h3iSwocDWrDVqNRtLtTYKLYf4pdJDSN1HzfqH2YSMkmfB4e8I1ZuDQLENW9Bs6ek/DziljG2fL9aiAztYEKjfL8uQ6waUr5flyFQD8F6CNVDuB4i9RCth9S7H+rdD/XuW737Vu++1btv9e5bvfvlx9GmU8M9PEbCA4y+AePfgAlvwFg9ZuZR2RLoaTj87+rh5urD7fU4fzh++/3u4zSdOBw+/v91+maacPz6cP/x+tP3h+tx6jHNOo4+E24Zd1SGA4GtaJyPe/4obJXG78dLL/htsJQCjN8jb9FS97H7yG8JU8M9fgS6RYgN8nhepa2n6bzDDPd26AWGyg0V/Ak=",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "store_in_execution_cache_oracle_wrapper",
-        "call_private_function_internal",
-        "decompose_hint",
-        "lte_hint",
-        "notify_created_nullifier_oracle_wrapper",
-        "debug_log_oracle_wrapper",
-        "directive_invert"
-      ],
-      "verification_key": "AAAAAAAEAAAAAAAAAAAAEgAAAAAAAAAQAAAAAAAAVgkAAAAA//////////8AGOCCpDSiJTBrTNrACftcVIpDP0gAUgOfr61Rf1joqhofgWCThwZt/jv2kereHZxpXZaHfOrQXAJfbaEZK/ySgyOpvxlgUWbPhQeZuL84z3NPBHHNv4I2qhOYG96powtQKsK9LNUUHCDged5eO3NwlJaqCJuSsG4hdiuyOH/SveAS1rb1+8MRm94IDWr6xij8Y38RBu5sriBmS2WnWBeZwy5vl6NShiHV4FPDtfzoWza45O/bO0S+UObSmeaPPs9bCsexgAxe6u62RKgMBSU9aZScX50ygsNCvfSZE71hQbgY1w/KXmDcvlUc02Q2x7M+dnwYyoZijoc921LB3NFziwfytnBJRWekOIby1r7JheYBJgl4kgJBtjPKzXj3HGxTCWsCFXYIf+TdtH6Ak9qGDWdovJ06ccwA5rJGZnhBsgkYnlaCx3CGFw4amrFsFXgncZRkjMkfOV/8ngpTjMKq+Awhahc1m7/Qb+0352eJgb64aBH2xl2wp7wppa/1aDTzIuSmLVifXcWOAD4X0sKeZqqcjXq3WBuYEO2nPlPhfd8OP4PTyf+mJHwLpRXOLm9SrLCVbfb6d5ltuCSwof5icCmMMxH8kXD5LelAsEKquZDVPGo7JjOc2mtz35IIMUFZB7BfQIphKEclkBa5IErkvzdTfrGWsFwdmPpRAWqbrLsfNY59QrcOaU1aZJ8elDJYxJPxRxWWvMUwI4RHpzoF9jAUnRq6iJhTkEUKZz6huOwts8iJe/x7ir7PD8afRNIjL44LCn6UMQphDA06F8RT3eZTIXQSd22b1QR+mEl5/WQTtN9b82eFw0c4x2ywwQZIUNSPnd1B0yhJQ1YPww7bYBmz7hM37OYMZEaDHOA0ls4ypkWhz4tfCGNY/9jEfYwFJnnwhPJ7oSVWC6jwqzoIu2mEI4Ktt7EbaGmvMSBwJ7ARRPkkuRVzu5l42nf5CMf6LO0T/Y1+n3qNoK6J5qowYwFm5l0Nm/6f69sf3AZjYN/oQO8ynvkdG6P6slyKuop0CFhw1LUjn/rR9qAWUD/gH3dbynR7chtR69l1bhFoITEpnvkUHLLF65e95nLgfscAitSWQ/pSHJ6/mTCgO+XebRe3nt2YQPlHFtxxP3mgPqHLbw6Yn41Uw36xTpijccsxB5z4yQ5Zx3jAx96mrrYSxjbOZdDchcRuNt7++9OMpt0gHIYjM960V+OSBj3F/gtxo5+W8z/oSZZNItE2JMr+2QPf1uLDN2I9iLA6MvIm9uGXNm9k10riGbvl/Osi5Ek9Jnj60rIdDvqBJ+sqvmBbofV+9KZ1csfuuY7YOihfv8QhdRR0DLCHAepE+oEW7AUlMxpdfxd3gq0PTiehNu8fcxfq3SGG3U0+gWHeuauR7/6cXZqYB9fzblDgo0L10vh6K9z1erXch9xvcAaciLVCzxeofa9m5TIjJTGqxSeJGLUtIJ5IremTJoiB0jRiM3MGfwT+VR+qJhkbqqcCgmGMwx84aPwAwBytJK48rQT1hQTll2gap0wY8W+fy2+h6Uo4KFK4/wPiDr21VBsPzjSS7QB3VhMmsjuvZptDBlNVJ2wlf/5HovAbpydY2Vt+P9jn/A0BC4jyHbPxLNXflH+gJSvnf7ZFW7gXvH8Zu9k6D9Z2Ru2gbogDe+SsTvAkvqtyGjwrispcMF5b+Rd7Mao3E5Gp7cEpnM0Lu6VSD62sKhATt9PqtaK15HdAwpcneGuYc9z1DVW0+q6bZ4w+W18iCAJQu/2KWphNZ1/cfhlhdcZs73bH6QMOTSsStI4T4rlJBmxuufssAmvE4bjup5S4vYeaOGebZodanwpZxCW5/ksbYUqEYBIyxMmCy4L06WNuWLGgQdAEq3Uv8ciOLfTQiArcicSNdbVxY29bvrSoBvb0WWICMBtq5OsOu+rdIDNABm8oE1dI8RljHD/gf6nXAANOPidFTvmStL+EuXuqdHEuJXg1Ud9QwATsfNH03Ys7ZKZvKsSXm2XlZWjFoxsU7Rj3bPDO7MtHmN50GuibZOglj4RHfBtiVlpVm6e7OIMuLSmftoZ40BULzFsW3IJSNT1D+nDpkjnBwcZ+JxoO6sUV06xaGZq7dJM6TvyYxZsoFO3nzSfa7QDDPBKGC8SwRi041tS6Hkdjp07NsRyh80aWgMJw5VFRU0RZL1kYj6dlEts56JKCazJhDuCCUeAF/OkXwNXcoBlHfFL2B1MythIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDt0u+U0u3pNT3r1l32scxIyP8edh8Ps4+y2VaI2VGR0ez8ZxpW5a4/CwXueFN/2VG1x+QLESaScFnVHiR+3HNgDENyb3W2/aDeIs4ODfq2vMegX/lalrKJQkxfczZw2WL5tuC04sAZaN5cMkgqp9HQoJ1xeOyTuteFj5bmTwtI0dWKphxkrVIgQ9ecSAIhnlW6GXUa3+bDYyTT+2wtoJiS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH"
+        "update"
+      ]
     }
   ],
   "outputs": {
@@ -2102,71 +2119,6 @@
     },
     "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": [
             {
@@ -2396,39 +2348,74 @@
           ],
           "kind": "struct",
           "path": "ContractInstanceDeployer::ContractInstanceDeployed"
-        }
-      ],
-      "functions": [
+        },
         {
           "fields": [
             {
-              "name": "parameters",
+              "name": "DEPLOYER_CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE",
+              "type": {
+                "kind": "field"
+              }
+            },
+            {
+              "name": "address",
               "type": {
                 "fields": [
                   {
-                    "name": "new_contract_class_id",
+                    "name": "inner",
                     "type": {
-                      "fields": [
-                        {
-                          "name": "inner",
-                          "type": {
-                            "kind": "field"
-                          }
-                        }
-                      ],
-                      "kind": "struct",
-                      "path": "aztec::protocol_types::contract_class_id::ContractClassId"
+                      "kind": "field"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "ContractInstanceDeployer::update_parameters"
+                "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::update_abi"
-        },
+          "path": "ContractInstanceDeployer::ContractInstanceUpdated"
+        }
+      ],
+      "functions": [
         {
           "fields": [
             {
@@ -2630,6 +2617,28 @@
           "kind": "struct",
           "path": "ContractInstanceDeployer::deploy_abi"
         },
+        {
+          "fields": [
+            {
+              "name": "parameters",
+              "type": {
+                "fields": [],
+                "kind": "struct",
+                "path": "ContractInstanceDeployer::get_update_delay_parameters"
+              }
+            },
+            {
+              "name": "return_type",
+              "type": {
+                "kind": "integer",
+                "sign": "unsigned",
+                "width": 32
+              }
+            }
+          ],
+          "kind": "struct",
+          "path": "ContractInstanceDeployer::get_update_delay_abi"
+        },
         {
           "fields": [
             {
@@ -2660,20 +2669,42 @@
               "type": {
                 "fields": [],
                 "kind": "struct",
-                "path": "ContractInstanceDeployer::get_update_delay_parameters"
+                "path": "ContractInstanceDeployer::sync_notes_parameters"
               }
-            },
+            }
+          ],
+          "kind": "struct",
+          "path": "ContractInstanceDeployer::sync_notes_abi"
+        },
+        {
+          "fields": [
             {
-              "name": "return_type",
+              "name": "parameters",
               "type": {
-                "kind": "integer",
-                "sign": "unsigned",
-                "width": 32
+                "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::get_update_delay_abi"
+          "path": "ContractInstanceDeployer::update_abi"
         }
       ]
     }
@@ -2693,17 +2724,17 @@
     },
     "149": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
-      "source": "use crate::{\n    note::{note_interface::NoteType, note_metadata::NoteMetadata, retrieved_note::RetrievedNote},\n    utils::array,\n};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::IndexedTaggingSecret,\n    traits::{FromField, Packable},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\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 {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            packed_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call.\n    unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    notify_created_note_oracle(storage_slot, note_type_id, packed_note, note_hash, counter);\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _packed_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(_nullifier: Field, _note_hash: Field, _counter: u32) {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n    notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let ORACLE_RETURN_FIELD_LENGTH: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n) -> [Field; ORACLE_RETURN_FIELD_LENGTH] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let ORACLE_RETURN_FIELD_LENGTH: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n) -> [Field; ORACLE_RETURN_FIELD_LENGTH] {\n    // This wrapper exists to extract the ORACLE_RETURN_FIELD_LENGTH generic numeric param into a value and pass it to\n    // the oracle, so that it knows how big the return array must be.\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        ORACLE_RETURN_FIELD_LENGTH,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let MAX_NOTES: u32, let ORACLE_RETURN_FIELD_LENGTH: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    _placeholder_fields: [Field; ORACLE_RETURN_FIELD_LENGTH], // TODO: Compute this value automatically from MAX_NOTES\n) -> [Option<RetrievedNote<Note>>; MAX_NOTES]\nwhere\n    Note: NoteType + Packable<N>,\n{\n    let fields: [_; ORACLE_RETURN_FIELD_LENGTH] = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n\n    let mut opt_notes = [Option::none(); MAX_NOTES];\n    for i in 0..opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n            let maybe_nonce = fields[read_offset];\n            let maybe_note_hash_counter = fields[read_offset + 1] as u32;\n            let packed_note = array::subarray(fields, read_offset + 2);\n\n            let note = Note::unpack(packed_note);\n            let retrieved_note = RetrievedNote {\n                note,\n                contract_address,\n                metadata: NoteMetadata::from_raw_data(maybe_note_hash_counter != 0, maybe_nonce),\n            };\n\n            opt_notes[i] = Option::some(retrieved_note);\n        };\n    }\n    opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier)\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> bool {}\n\n/// Returns the derived app tagging secret ready to be included in a log for a given sender and recipient pair,\n/// siloed for the current contract address.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_indexed_tagging_secret_as_sender_oracle(sender, recipient).compute_tag(recipient)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> IndexedTaggingSecret {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n"
+      "source": "use crate::note::{\n    note_interface::NoteType,\n    retrieved_note::{RETRIEVED_NOTE_OVERHEAD, RetrievedNote, unpack_retrieved_note},\n};\n\nuse dep::protocol_types::{\n    address::AztecAddress, indexed_tagging_secret::IndexedTaggingSecret, traits::Packable,\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\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 {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            packed_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call.\n    unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    notify_created_note_oracle(storage_slot, note_type_id, packed_note, note_hash, counter);\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _packed_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(_nullifier: Field, _note_hash: Field, _counter: u32) {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n    notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let NOTE_PCKD_LEN: u32, let M: u32, let MAX_NOTES: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; M],\n    _select_by_offsets: [u8; M],\n    _select_by_lengths: [u8; M],\n    _select_values: [Field; M],\n    _select_comparators: [u8; M],\n    _sort_by_indexes: [u8; M],\n    _sort_by_offsets: [u8; M],\n    _sort_by_lengths: [u8; M],\n    _sort_order: [u8; M],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    // This is always set to MAX_NOTES. We need to pass it to TS in order to correctly construct the BoundedVec\n    _max_notes: u32,\n    // This is always set to NOTE_PCKD_LEN + RETRIEVED_NOTE_OVERHEAD. We need to pass it to TS in order to be able to\n    // correctly construct the BoundedVec there.\n    _packed_retrieved_note_length: u32,\n) -> BoundedVec<[Field; NOTE_PCKD_LEN + RETRIEVED_NOTE_OVERHEAD], MAX_NOTES> {}\n\npub unconstrained fn get_notes<Note, let NOTE_PCKD_LEN: u32, let M: u32, let MAX_NOTES: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n) -> [Option<RetrievedNote<Note>>; MAX_NOTES]\nwhere\n    Note: NoteType + Packable<NOTE_PCKD_LEN>,\n{\n    // N + 3 because of the contract address, nonce, and note_hash_counter that are stored out of the packed note.\n    let packed_retrieved_notes: BoundedVec<[Field; NOTE_PCKD_LEN + RETRIEVED_NOTE_OVERHEAD], MAX_NOTES> = get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        MAX_NOTES,\n        NOTE_PCKD_LEN + RETRIEVED_NOTE_OVERHEAD,\n    );\n\n    let mut notes = BoundedVec::<_, MAX_NOTES>::new();\n    for i in 0..packed_retrieved_notes.len() {\n        let retrieved_note = unpack_retrieved_note(packed_retrieved_notes.get(i));\n        notes.push(retrieved_note);\n    }\n\n    // At last we convert the bounded vector to an array of options. We do this because that is what the filter\n    // function needs to have on the output and we've decided to have the same type on the input and output of\n    // the filter and preprocessor functions.\n    //\n    // We have decided to have the same type on the input and output of the filter and preprocessor functions because\n    // it allows us to chain multiple filters and preprocessors together.\n    //\n    // So why do we want the array of options on the output of the filter function?\n    //\n    // Filter returns an array of options rather than a BoundedVec for performance reasons. Using an array of options\n    // allows setting values at known indices in the output array which is much more efficient than pushing to a\n    // BoundedVec where the write position depends on previous iterations. The array can then be efficiently converted\n    // to a BoundedVec using utils/array/collapse.nr::collapse function from Aztec.nr. This avoids expensive dynamic\n    // memory access patterns that would be required when building up a BoundedVec incrementally. For preprocessor\n    // functions we could use BoundedVec return value as there the optimization does not matter since it is applied in\n    // an unconstrained context. We, however, use the same return value type to be able to use the same function as\n    // both a preprocessor and a filter.\n    let mut notes_array = [Option::none(); MAX_NOTES];\n    for i in 0..notes.len() {\n        if i < notes.len() {\n            notes_array[i] = Option::some(notes.get_unchecked(i));\n        }\n    }\n\n    notes_array\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier)\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> bool {}\n\n/// Returns the derived app tagging secret ready to be included in a log for a given sender and recipient pair,\n/// siloed for the current contract address.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_indexed_tagging_secret_as_sender_oracle(sender, recipient).compute_tag(recipient)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> IndexedTaggingSecret {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n"
     },
-    "154": {
+    "155": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/state_vars/map.nr",
-      "source": "use crate::state_vars::storage::Storage;\nuse dep::protocol_types::{storage::map::derive_storage_slot_in_map, traits::{Packable, ToField}};\n\n// docs:start:map\npub struct Map<K, V, Context> {\n    context: Context,\n    storage_slot: Field,\n    state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\nimpl<K, T, Context, let N: u32> Storage<N> for Map<K, T, Context>\nwhere\n    T: Packable<N>,\n{\n    fn get_storage_slot(self) -> Field {\n        self.storage_slot\n    }\n}\n\nimpl<K, V, Context> Map<K, V, Context> {\n    // docs:start:new\n    pub fn new(\n        context: Context,\n        storage_slot: Field,\n        state_var_constructor: fn(Context, Field) -> V,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Map { context, storage_slot, state_var_constructor }\n    }\n    // docs:end:new\n\n    // docs:start:at\n    pub fn at(self, key: K) -> V\n    where\n        K: ToField,\n    {\n        // TODO(#1204): use a generator index for the storage slot\n        let derived_storage_slot = derive_storage_slot_in_map(self.storage_slot, key);\n\n        let state_var_constructor = self.state_var_constructor;\n        state_var_constructor(self.context, derived_storage_slot)\n    }\n    // docs:end:at\n}\n"
+      "source": "use crate::state_vars::storage::Storage;\nuse dep::protocol_types::{storage::map::derive_storage_slot_in_map, traits::ToField};\n\n// docs:start:map\npub struct Map<K, V, Context> {\n    context: Context,\n    storage_slot: Field,\n    state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\n// Map reserves a single storage slot regardless of what it stores because nothing is stored at said slot: it is only\n// used to derive the storage slots of nested state variables, which is expected to never result in collisions or slots\n// being close to one another due to these being hashes. This mirrors the strategy adopted by Solidity mappings.\nimpl<K, T, Context> Storage<1> for Map<K, T, Context> {\n    fn get_storage_slot(self) -> Field {\n        self.storage_slot\n    }\n}\n\nimpl<K, V, Context> Map<K, V, Context> {\n    // docs:start:new\n    pub fn new(\n        context: Context,\n        storage_slot: Field,\n        state_var_constructor: fn(Context, Field) -> V,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Map { context, storage_slot, state_var_constructor }\n    }\n    // docs:end:new\n\n    // docs:start:at\n    pub fn at(self, key: K) -> V\n    where\n        K: ToField,\n    {\n        // TODO(#1204): use a generator index for the storage slot\n        let derived_storage_slot = derive_storage_slot_in_map(self.storage_slot, key);\n\n        let state_var_constructor = self.state_var_constructor;\n        state_var_constructor(self.context, derived_storage_slot)\n    }\n    // docs:end:at\n}\n"
     },
     "16": {
       "path": "std/embedded_curve_ops.nr",
-      "source": "use crate::cmp::Eq;\nuse crate::hash::Hash;\nuse crate::ops::arith::{Add, Neg, Sub};\n\n/// A point on the embedded elliptic curve\n/// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.\n/// x and y denotes the Weierstrass coordinates of the point, if is_infinite is false.\npub struct EmbeddedCurvePoint {\n    pub x: Field,\n    pub y: Field,\n    pub is_infinite: bool,\n}\n\nimpl EmbeddedCurvePoint {\n    /// Elliptic curve point doubling operation\n    /// returns the doubled point of a point P, i.e P+P\n    pub fn double(self) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, self)\n    }\n\n    /// Returns the null element of the curve; 'the point at infinity'\n    pub fn point_at_infinity() -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }\n    }\n\n    /// Returns the curve's generator point.\n    pub fn generator() -> EmbeddedCurvePoint {\n        // Generator point for the grumpkin curve (y^2 = x^3 - 17)\n        EmbeddedCurvePoint {\n            x: 1,\n            y: 17631683881184975370165255887551781615748388533673675138860, // sqrt(-16)\n            is_infinite: false,\n        }\n    }\n}\n\nimpl Add for EmbeddedCurvePoint {\n    /// Adds two points P+Q, using the curve addition formula, and also handles point at infinity\n    fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, other)\n    }\n}\n\nimpl Sub for EmbeddedCurvePoint {\n    /// Points subtraction operation, using addition and negation\n    fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        self + other.neg()\n    }\n}\n\nimpl Neg for EmbeddedCurvePoint {\n    /// Negates a point P, i.e returns -P, by negating the y coordinate.\n    /// If the point is at infinity, then the result is also at infinity.\n    fn neg(self) -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: self.x, y: -self.y, is_infinite: self.is_infinite }\n    }\n}\n\nimpl Eq for EmbeddedCurvePoint {\n    /// Checks whether two points are equal\n    fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {\n        (self.is_infinite & b.is_infinite)\n            | ((self.is_infinite == b.is_infinite) & (self.x == b.x) & (self.y == b.y))\n    }\n}\n\nimpl Hash for EmbeddedCurvePoint {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: crate::hash::Hasher,\n    {\n        if self.is_infinite {\n            self.is_infinite.hash(state);\n        } else {\n            self.x.hash(state);\n            self.y.hash(state);\n        }\n    }\n}\n\n/// Scalar for the embedded curve represented as low and high limbs\n/// By definition, the scalar field of the embedded curve is base field of the proving system curve.\n/// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.\npub struct EmbeddedCurveScalar {\n    pub lo: Field,\n    pub hi: Field,\n}\n\nimpl EmbeddedCurveScalar {\n    pub fn new(lo: Field, hi: Field) -> Self {\n        EmbeddedCurveScalar { lo, hi }\n    }\n\n    #[field(bn254)]\n    pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {\n        let (a, b) = crate::field::bn254::decompose(scalar);\n        EmbeddedCurveScalar { lo: a, hi: b }\n    }\n\n    //Bytes to scalar: take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value\n    #[field(bn254)]\n    pub(crate) fn from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n        let mut v = 1;\n        let mut lo = 0 as Field;\n        let mut hi = 0 as Field;\n        for i in 0..16 {\n            lo = lo + (bytes[offset + 31 - i] as Field) * v;\n            hi = hi + (bytes[offset + 15 - i] as Field) * v;\n            v = v * 256;\n        }\n        let sig_s = crate::embedded_curve_ops::EmbeddedCurveScalar { lo, hi };\n        sig_s\n    }\n}\n\nimpl Eq for EmbeddedCurveScalar {\n    fn eq(self, other: Self) -> bool {\n        (other.hi == self.hi) & (other.lo == self.lo)\n    }\n}\n\nimpl Hash for EmbeddedCurveScalar {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: crate::hash::Hasher,\n    {\n        self.hi.hash(state);\n        self.lo.hash(state);\n    }\n}\n\n// Computes a multi scalar multiplication over the embedded curve.\n// For bn254, We have Grumpkin and Baby JubJub.\n// For bls12-381, we have JubJub and Bandersnatch.\n//\n// The embedded curve being used is decided by the\n// underlying proof system.\n// docs:start:multi_scalar_mul\npub fn multi_scalar_mul<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n) -> EmbeddedCurvePoint\n// docs:end:multi_scalar_mul\n{\n    multi_scalar_mul_array_return(points, scalars)[0]\n}\n\n#[foreign(multi_scalar_mul)]\npub(crate) fn multi_scalar_mul_array_return<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n) -> [EmbeddedCurvePoint; 1] {}\n\n// docs:start:fixed_base_scalar_mul\npub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint\n// docs:end:fixed_base_scalar_mul\n{\n    multi_scalar_mul([EmbeddedCurvePoint::generator()], [scalar])\n}\n\n/// This function only assumes that the points are on the curve\n/// It handles corner cases around the infinity point causing some overhead compared to embedded_curve_add_not_nul and embedded_curve_add_unsafe\n// docs:start:embedded_curve_add\npub fn embedded_curve_add(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    // docs:end:embedded_curve_add\n    if crate::runtime::is_unconstrained() {\n        // `embedded_curve_add_unsafe` requires the inputs not to be the infinity point, so we check it here.\n        // This is because `embedded_curve_add_unsafe` uses the `embedded_curve_add` opcode.\n        // For efficiency, the backend does not check the inputs for the infinity point, but it assumes that they are not the infinity point\n        // so that it can apply the ec addition formula directly.\n        if point1.is_infinite {\n            point2\n        } else if point2.is_infinite {\n            point1\n        } else {\n            embedded_curve_add_unsafe(point1, point2)\n        }\n    } else {\n        // In a constrained context, we also need to check the inputs are not the infinity point because we also use `embedded_curve_add_unsafe`\n        // However we also need to identify the case where the two inputs are the same, because then\n        // the addition formula does not work and we need to use the doubling formula instead.\n        // In unconstrained context, we can check directly if the input values are the same when solving the opcode, so it is not an issue.\n\n        // x_coordinates_match is true if both abscissae are the same\n        let x_coordinates_match = point1.x == point2.x;\n        // y_coordinates_match is true if both ordinates are the same\n        let y_coordinates_match = point1.y == point2.y;\n        // double_predicate is true if both abscissae and ordinates are the same\n        let double_predicate = (x_coordinates_match & y_coordinates_match);\n        // If the abscissae are the same, but not the ordinates, then one point is the opposite of the other\n        let infinity_predicate = (x_coordinates_match & !y_coordinates_match);\n        let point1_1 = EmbeddedCurvePoint {\n            x: point1.x + (x_coordinates_match as Field),\n            y: point1.y,\n            is_infinite: x_coordinates_match,\n        };\n        // point1_1 is guaranteed to have a different abscissa than point2:\n        // - if x_coordinates_match is 0, that means point1.x != point2.x, and point1_1.x = point1.x + 0\n        // - if x_coordinates_match is 1, that means point1.x = point2.x, but point1_1.x = point1.x + 1 in this case\n        // Because the abscissa is different, the addition formula is guaranteed to succeed, so we can safely use `embedded_curve_add_unsafe`\n        // Note that this computation may be garbage: if x_coordinates_match is 1, or if one of the input is the point at infinity.\n        let mut result = embedded_curve_add_unsafe(point1_1, point2);\n\n        // `embedded_curve_add_unsafe` is doing a doubling if the input is the same variable, because in this case it is guaranteed (at 'compile time') that the input is the same.\n        let double = embedded_curve_add_unsafe(point1, point1);\n        // `embedded_curve_add_unsafe` would not perform doubling, even if the inputs point1 and point2 are the same, because it cannot know this without adding some logic (and some constraints)\n        // However we did this logic when we computed `double_predicate`, so we set the result to 2*point1 if point1 and point2 are the same\n        result = if double_predicate { double } else { result };\n\n        // Same logic as above for unconstrained context, we set the proper result when one of the inputs is the infinity point\n        if point1.is_infinite {\n            result = point2;\n        }\n        if point2.is_infinite {\n            result = point1;\n        }\n\n        // Finally, we set the is_infinity flag of the result:\n        // Opposite points should sum into the infinity point, however, if one of them is point at infinity, their coordinates are not meaningful\n        // so we should not use the fact that the inputs are opposite in this case:\n        let mut result_is_infinity =\n            infinity_predicate & (!point1.is_infinite & !point2.is_infinite);\n        // However, if both of them are at infinity, then the result is also at infinity\n        result.is_infinite = result_is_infinity | (point1.is_infinite & point2.is_infinite);\n        result\n    }\n}\n\n#[foreign(embedded_curve_add)]\nfn embedded_curve_add_array_return(\n    _point1: EmbeddedCurvePoint,\n    _point2: EmbeddedCurvePoint,\n) -> [EmbeddedCurvePoint; 1] {}\n\n/// This function assumes that:\n/// The points are on the curve, and\n/// The points don't share an x-coordinate, and\n/// Neither point is the infinity point.\n/// If it is used with correct input, the function ensures the correct non-zero result is returned.\n/// Except for points on the curve, the other assumptions are checked by the function. It will cause assertion failure if they are not respected.\npub fn embedded_curve_add_not_nul(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    assert(point1.x != point2.x);\n    assert(!point1.is_infinite);\n    assert(!point2.is_infinite);\n    embedded_curve_add_unsafe(point1, point2)\n}\n\n/// Unsafe ec addition\n/// If the inputs are the same, it will perform a doubling, but only if point1 and point2 are the same variable.\n/// If they have the same value but are different variables, the result will be incorrect because in this case\n/// it assumes (but does not check) that the points' x-coordinates are not equal.\n/// It also assumes neither point is the infinity point.\npub fn embedded_curve_add_unsafe(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    embedded_curve_add_array_return(point1, point2)[0]\n}\n"
+      "source": "use crate::cmp::Eq;\nuse crate::hash::Hash;\nuse crate::ops::arith::{Add, Neg, Sub};\n\n/// A point on the embedded elliptic curve\n/// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.\n/// x and y denotes the Weierstrass coordinates of the point, if is_infinite is false.\npub struct EmbeddedCurvePoint {\n    pub x: Field,\n    pub y: Field,\n    pub is_infinite: bool,\n}\n\nimpl EmbeddedCurvePoint {\n    /// Elliptic curve point doubling operation\n    /// returns the doubled point of a point P, i.e P+P\n    pub fn double(self) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, self)\n    }\n\n    /// Returns the null element of the curve; 'the point at infinity'\n    pub fn point_at_infinity() -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }\n    }\n\n    /// Returns the curve's generator point.\n    pub fn generator() -> EmbeddedCurvePoint {\n        // Generator point for the grumpkin curve (y^2 = x^3 - 17)\n        EmbeddedCurvePoint {\n            x: 1,\n            y: 17631683881184975370165255887551781615748388533673675138860, // sqrt(-16)\n            is_infinite: false,\n        }\n    }\n}\n\nimpl Add for EmbeddedCurvePoint {\n    /// Adds two points P+Q, using the curve addition formula, and also handles point at infinity\n    fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, other)\n    }\n}\n\nimpl Sub for EmbeddedCurvePoint {\n    /// Points subtraction operation, using addition and negation\n    fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        self + other.neg()\n    }\n}\n\nimpl Neg for EmbeddedCurvePoint {\n    /// Negates a point P, i.e returns -P, by negating the y coordinate.\n    /// If the point is at infinity, then the result is also at infinity.\n    fn neg(self) -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: self.x, y: -self.y, is_infinite: self.is_infinite }\n    }\n}\n\nimpl Eq for EmbeddedCurvePoint {\n    /// Checks whether two points are equal\n    fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {\n        (self.is_infinite & b.is_infinite)\n            | ((self.is_infinite == b.is_infinite) & (self.x == b.x) & (self.y == b.y))\n    }\n}\n\nimpl Hash for EmbeddedCurvePoint {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: crate::hash::Hasher,\n    {\n        if self.is_infinite {\n            self.is_infinite.hash(state);\n        } else {\n            self.x.hash(state);\n            self.y.hash(state);\n        }\n    }\n}\n\n/// Scalar for the embedded curve represented as low and high limbs\n/// By definition, the scalar field of the embedded curve is base field of the proving system curve.\n/// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.\npub struct EmbeddedCurveScalar {\n    pub lo: Field,\n    pub hi: Field,\n}\n\nimpl EmbeddedCurveScalar {\n    pub fn new(lo: Field, hi: Field) -> Self {\n        EmbeddedCurveScalar { lo, hi }\n    }\n\n    #[field(bn254)]\n    pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {\n        let (a, b) = crate::field::bn254::decompose(scalar);\n        EmbeddedCurveScalar { lo: a, hi: b }\n    }\n\n    //Bytes to scalar: take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value\n    #[field(bn254)]\n    pub(crate) fn from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n        let mut v = 1;\n        let mut lo = 0 as Field;\n        let mut hi = 0 as Field;\n        for i in 0..16 {\n            lo = lo + (bytes[offset + 31 - i] as Field) * v;\n            hi = hi + (bytes[offset + 15 - i] as Field) * v;\n            v = v * 256;\n        }\n        let sig_s = crate::embedded_curve_ops::EmbeddedCurveScalar { lo, hi };\n        sig_s\n    }\n}\n\nimpl Eq for EmbeddedCurveScalar {\n    fn eq(self, other: Self) -> bool {\n        (other.hi == self.hi) & (other.lo == self.lo)\n    }\n}\n\nimpl Hash for EmbeddedCurveScalar {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: crate::hash::Hasher,\n    {\n        self.hi.hash(state);\n        self.lo.hash(state);\n    }\n}\n\n// Computes a multi scalar multiplication over the embedded curve.\n// For bn254, We have Grumpkin and Baby JubJub.\n// For bls12-381, we have JubJub and Bandersnatch.\n//\n// The embedded curve being used is decided by the\n// underlying proof system.\n// docs:start:multi_scalar_mul\npub fn multi_scalar_mul<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n) -> EmbeddedCurvePoint\n// docs:end:multi_scalar_mul\n{\n    multi_scalar_mul_array_return(points, scalars)[0]\n}\n\n#[foreign(multi_scalar_mul)]\npub(crate) fn multi_scalar_mul_array_return<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n) -> [EmbeddedCurvePoint; 1] {}\n\n// docs:start:fixed_base_scalar_mul\npub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint\n// docs:end:fixed_base_scalar_mul\n{\n    multi_scalar_mul([EmbeddedCurvePoint::generator()], [scalar])\n}\n\n/// This function only assumes that the points are on the curve\n/// It handles corner cases around the infinity point causing some overhead compared to embedded_curve_add_not_nul and embedded_curve_add_unsafe\n// docs:start:embedded_curve_add\npub fn embedded_curve_add(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    // docs:end:embedded_curve_add\n    if crate::runtime::is_unconstrained() {\n        // `embedded_curve_add_unsafe` requires the inputs not to be the infinity point, so we check it here.\n        // This is because `embedded_curve_add_unsafe` uses the `embedded_curve_add` opcode.\n        // For efficiency, the backend does not check the inputs for the infinity point, but it assumes that they are not the infinity point\n        // so that it can apply the ec addition formula directly.\n        if point1.is_infinite {\n            point2\n        } else if point2.is_infinite {\n            point1\n        } else {\n            embedded_curve_add_unsafe(point1, point2)\n        }\n    } else {\n        // In a constrained context, we also need to check the inputs are not the infinity point because we also use `embedded_curve_add_unsafe`\n        // However we also need to identify the case where the two inputs are the same, because then\n        // the addition formula does not work and we need to use the doubling formula instead.\n        // In unconstrained context, we can check directly if the input values are the same when solving the opcode, so it is not an issue.\n\n        // x_coordinates_match is true if both abscissae are the same\n        let x_coordinates_match = point1.x == point2.x;\n        // y_coordinates_match is true if both ordinates are the same\n        let y_coordinates_match = point1.y == point2.y;\n        // double_predicate is true if both abscissae and ordinates are the same\n        let double_predicate = (x_coordinates_match & y_coordinates_match);\n        // If the abscissae are the same, but not the ordinates, then one point is the opposite of the other\n        let infinity_predicate = (x_coordinates_match & !y_coordinates_match);\n        let point1_1 = EmbeddedCurvePoint {\n            x: point1.x + (x_coordinates_match as Field),\n            y: point1.y,\n            is_infinite: false,\n        };\n        let point2_1 = EmbeddedCurvePoint { x: point2.x, y: point2.y, is_infinite: false };\n        // point1_1 is guaranteed to have a different abscissa than point2:\n        // - if x_coordinates_match is 0, that means point1.x != point2.x, and point1_1.x = point1.x + 0\n        // - if x_coordinates_match is 1, that means point1.x = point2.x, but point1_1.x = point1.x + 1 in this case\n        // Because the abscissa is different, the addition formula is guaranteed to succeed, so we can safely use `embedded_curve_add_unsafe`\n        // Note that this computation may be garbage: if x_coordinates_match is 1, or if one of the input is the point at infinity.\n        let mut result = embedded_curve_add_unsafe(point1_1, point2_1);\n\n        // `embedded_curve_add_unsafe` is doing a doubling if the input is the same variable, because in this case it is guaranteed (at 'compile time') that the input is the same.\n        let double = embedded_curve_add_unsafe(point1, point1);\n        // `embedded_curve_add_unsafe` would not perform doubling, even if the inputs point1 and point2 are the same, because it cannot know this without adding some logic (and some constraints)\n        // However we did this logic when we computed `double_predicate`, so we set the result to 2*point1 if point1 and point2 are the same\n        result = if double_predicate { double } else { result };\n\n        // Same logic as above for unconstrained context, we set the proper result when one of the inputs is the infinity point\n        if point1.is_infinite {\n            result = point2;\n        }\n        if point2.is_infinite {\n            result = point1;\n        }\n\n        // Finally, we set the is_infinity flag of the result:\n        // Opposite points should sum into the infinity point, however, if one of them is point at infinity, their coordinates are not meaningful\n        // so we should not use the fact that the inputs are opposite in this case:\n        let mut result_is_infinity =\n            infinity_predicate & (!point1.is_infinite & !point2.is_infinite);\n        // However, if both of them are at infinity, then the result is also at infinity\n        result.is_infinite = result_is_infinity | (point1.is_infinite & point2.is_infinite);\n        result\n    }\n}\n\n#[foreign(embedded_curve_add)]\nfn embedded_curve_add_array_return(\n    _point1: EmbeddedCurvePoint,\n    _point2: EmbeddedCurvePoint,\n) -> [EmbeddedCurvePoint; 1] {}\n\n/// This function assumes that:\n/// The points are on the curve, and\n/// The points don't share an x-coordinate, and\n/// Neither point is the infinity point.\n/// If it is used with correct input, the function ensures the correct non-zero result is returned.\n/// Except for points on the curve, the other assumptions are checked by the function. It will cause assertion failure if they are not respected.\npub fn embedded_curve_add_not_nul(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    assert(point1.x != point2.x);\n    assert(!point1.is_infinite);\n    assert(!point2.is_infinite);\n    embedded_curve_add_unsafe(point1, point2)\n}\n\n/// Unsafe ec addition\n/// If the inputs are the same, it will perform a doubling, but only if point1 and point2 are the same variable.\n/// If they have the same value but are different variables, the result will be incorrect because in this case\n/// it assumes (but does not check) that the points' x-coordinates are not equal.\n/// It also assumes neither point is the infinity point.\npub fn embedded_curve_add_unsafe(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    embedded_curve_add_array_return(point1, point2)[0]\n}\n"
     },
-    "165": {
+    "166": {
       "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::{\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"
     },
@@ -2715,79 +2746,79 @@
       "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"
     },
-    "192": {
+    "193": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/with_hash.nr",
       "source": "use crate::{\n    context::{PublicContext, UtilityContext},\n    history::public_storage::PublicStorageHistoricalRead,\n    oracle,\n};\nuse dep::protocol_types::{\n    address::AztecAddress, block_header::BlockHeader, hash::poseidon2_hash, traits::Packable,\n};\n\n/// A struct that allows for efficient reading of value `T` from public storage in private.\n///\n/// The efficient reads are achieved by verifying large values through a single hash check\n/// and then proving inclusion only of the hash in public storage. This reduces the number\n/// of required tree inclusion proofs from `N` to 1.\n///\n/// # Type Parameters\n/// - `T`: The underlying type being wrapped, must implement `Packable<N>`\n/// - `N`: The number of field elements required to pack values of type `T`\npub struct WithHash<T, let N: u32> {\n    value: T,\n    packed: [Field; N],\n    hash: Field,\n}\n\nimpl<T, let N: u32> WithHash<T, N>\nwhere\n    T: Packable<N> + Eq,\n{\n    pub fn new(value: T) -> Self {\n        let packed = value.pack();\n        Self { value, packed, hash: poseidon2_hash(packed) }\n    }\n\n    pub fn get_value(self) -> T {\n        self.value\n    }\n\n    pub fn get_hash(self) -> Field {\n        self.hash\n    }\n\n    pub fn public_storage_read(context: PublicContext, storage_slot: Field) -> T {\n        context.storage_read(storage_slot)\n    }\n\n    pub unconstrained fn utility_public_storage_read(\n        context: UtilityContext,\n        storage_slot: Field,\n    ) -> T {\n        context.storage_read(storage_slot)\n    }\n\n    pub fn historical_public_storage_read(\n        header: BlockHeader,\n        address: AztecAddress,\n        storage_slot: Field,\n    ) -> T {\n        let historical_block_number = header.global_variables.block_number as u32;\n\n        // We could simply produce historical inclusion proofs for each field in `packed`, but that would require one\n        // full sibling path per storage slot (since due to kernel siloing the storage is not contiguous). Instead, we\n        // get an oracle to provide us the values, and instead we prove inclusion of their hash, which is both a much\n        // smaller proof (a single slot), and also independent of the size of T (except in that we need to pack and hash T).\n        let hint = WithHash::new(\n            // Safety: We verify that a hash of the hint/packed data matches the stored hash.\n            unsafe {\n                oracle::storage::storage_read(address, storage_slot, historical_block_number)\n            },\n        );\n\n        let hash = header.public_storage_historical_read(storage_slot + N as Field, address);\n\n        if hash != 0 {\n            assert_eq(hash, hint.get_hash(), \"Hint values do not match hash\");\n        } else {\n            // The hash slot can only hold a zero if it is uninitialized. Therefore, the hints must then be zero\n            // (i.e. the default value for public storage) as well.\n            assert_eq(\n                hint.get_value(),\n                T::unpack(std::mem::zeroed()),\n                \"Non-zero hint for zero hash\",\n            );\n        };\n\n        hint.get_value()\n    }\n}\n\nimpl<T, let N: u32> Packable<N + 1> for WithHash<T, N>\nwhere\n    T: Packable<N>,\n{\n    fn pack(self) -> [Field; N + 1] {\n        let mut result: [Field; N + 1] = std::mem::zeroed();\n        for i in 0..N {\n            result[i] = self.packed[i];\n        }\n        result[N] = self.hash;\n\n        result\n    }\n\n    fn unpack(packed: [Field; N + 1]) -> Self {\n        let mut value_packed: [Field; N] = std::mem::zeroed();\n        for i in 0..N {\n            value_packed[i] = packed[i];\n        }\n        let hash = packed[N];\n\n        Self { value: T::unpack(value_packed), packed: value_packed, hash }\n    }\n}\n\nmod test {\n    use crate::{\n        oracle::random::random,\n        test::{\n            helpers::{cheatcodes, test_environment::TestEnvironment},\n            mocks::mock_struct::MockStruct,\n        },\n        utils::with_hash::WithHash,\n    };\n    use dep::protocol_types::hash::poseidon2_hash;\n    use dep::protocol_types::traits::{Packable, ToField};\n    use dep::std::{mem, test::OracleMock};\n\n    global storage_slot: Field = 47;\n\n    #[test]\n    unconstrained fn create_and_recover() {\n        let value = MockStruct { a: 5, b: 3 };\n        let value_with_hash = WithHash::new(value);\n        let recovered = WithHash::unpack(value_with_hash.pack());\n\n        assert_eq(recovered.value, value);\n        assert_eq(recovered.packed, value.pack());\n        assert_eq(recovered.hash, poseidon2_hash(value.pack()));\n    }\n\n    #[test]\n    unconstrained fn read_uninitialized_value() {\n        let mut env = TestEnvironment::new();\n\n        let block_header = env.private().historical_header;\n        let address = env.contract_address();\n\n        let result = WithHash::<MockStruct, _>::historical_public_storage_read(\n            block_header,\n            address,\n            storage_slot,\n        );\n\n        // We should get zeroed value\n        let expected: MockStruct = mem::zeroed();\n        assert_eq(result, expected);\n    }\n\n    #[test]\n    unconstrained fn read_initialized_value() {\n        let mut env = TestEnvironment::new();\n\n        let value = MockStruct { a: 5, b: 3 };\n        let value_with_hash = WithHash::new(value);\n\n        // We write the value with hash to storage\n        cheatcodes::direct_storage_write(\n            env.contract_address(),\n            storage_slot,\n            value_with_hash.pack(),\n        );\n\n        // We advance block by 1 because env.private() currently returns context at latest_block - 1\n        env.advance_block_by(1);\n\n        let result = WithHash::<MockStruct, _>::historical_public_storage_read(\n            env.private().historical_header,\n            env.contract_address(),\n            storage_slot,\n        );\n\n        assert_eq(result, value);\n    }\n\n    #[test(should_fail_with = \"Non-zero hint for zero hash\")]\n    unconstrained fn test_bad_hint_uninitialized_value() {\n        let mut env = TestEnvironment::new();\n\n        env.advance_block_to(6);\n\n        let value_packed = MockStruct { a: 1, b: 1 }.pack();\n\n        let block_header = env.private().historical_header;\n        let address = env.contract_address();\n\n        // Mock the oracle to return a non-zero hint/packed value\n        let _ = OracleMock::mock(\"storageRead\")\n            .with_params((\n                address.to_field(), storage_slot, block_header.global_variables.block_number as u32,\n                value_packed.len(),\n            ))\n            .returns(value_packed)\n            .times(1);\n\n        // This should revert because the hint value is non-zero and the hash is zero (default value of storage)\n        let _ = WithHash::<MockStruct, _>::historical_public_storage_read(\n            block_header,\n            address,\n            storage_slot,\n        );\n    }\n\n    #[test(should_fail_with = \"Hint values do not match hash\")]\n    unconstrained fn test_bad_hint_initialized_value() {\n        let mut env = TestEnvironment::new();\n\n        let value_packed = MockStruct { a: 5, b: 3 }.pack();\n\n        // We write the value to storage\n        cheatcodes::direct_storage_write(env.contract_address(), storage_slot, value_packed);\n\n        // Now we write incorrect hash to the hash storage slot\n        let incorrect_hash = random();\n        let hash_storage_slot = storage_slot + (value_packed.len() as Field);\n        cheatcodes::direct_storage_write(\n            env.contract_address(),\n            hash_storage_slot,\n            [incorrect_hash],\n        );\n\n        // We advance block by 1 because env.private() currently returns context at latest_block - 1\n        env.advance_block_by(1);\n\n        let _ = WithHash::<MockStruct, _>::historical_public_storage_read(\n            env.private().historical_header,\n            env.contract_address(),\n            storage_slot,\n        );\n    }\n}\n"
     },
-    "199": {
+    "200": {
       "path": "/home/aztec-dev/nargo/github.com/noir-lang/poseidon/v0.1.0/src/poseidon2.nr",
       "source": "use std::default::Default;\nuse std::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = crate::poseidon2_permutation(self.state, 4);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: &[] }\n    }\n}\n"
     },
-    "261": {
+    "262": {
       "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"
     },
-    "264": {
+    "265": {
       "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"
     },
-    "266": {
+    "267": {
       "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"
     },
-    "270": {
+    "271": {
       "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"
     },
-    "278": {
+    "279": {
       "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"
     },
-    "279": {
+    "280": {
       "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    poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as poseidon::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
+      "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        CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE,\n        GENERATOR_INDEX__OUTER_NULLIFIER, GENERATOR_INDEX__SILOED_NOTE_HASH,\n        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::{arrays::array_concat, field::{field_from_bytes, field_from_bytes_32_trunc}},\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::new(fields, private_log.inner.log.length)\n    }\n}\n\npub fn 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(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n    poseidon2_hash(log)\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a u128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as poseidon::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
     },
-    "293": {
+    "294": {
       "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/// - `should_pack`: A boolean indicating whether the type should be packed.\n///\n/// # Returns\n/// A tuple containing:\n/// - A flattened array of `Quoted` field references representing the serialized fields.\n/// - An array of `Quoted` auxiliary variables needed for serialization, such as byte arrays for strings.\n///\n/// # Examples\n///\n/// ## Struct\n/// Given the following struct:\n/// ```rust\n/// struct MockStruct {\n///     a: Field,\n///     b: Field,\n/// }\n/// ```\n///\n/// Serializing the struct:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_mock_struct }, MockStruct, false)\n/// // Returns:\n/// // ([`my_mock_struct.a`, `my_mock_struct.b`], [])\n/// ```\n///\n/// ## Nested Struct\n/// For a more complex struct:\n/// ```rust\n/// struct NestedStruct {\n///     m1: MockStruct,\n///     m2: MockStruct,\n/// }\n/// ```\n///\n/// Serialization output:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, NestedStruct, false)\n/// // Returns:\n/// // ([`self.m1.a`, `self.m1.b`, `self.m2.a`, `self.m2.b`], [])\n/// ```\n///\n/// ## Array\n/// For an array type:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_array }, [Field; 3], false)\n/// // Returns:\n/// // ([`my_array[0]`, `my_array[1]`, `my_array[2]`], [])\n/// ```\n///\n/// ## String\n/// For a string field, where each character is serialized as a `Field`:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_string }, StringType, false)\n/// // Returns:\n/// // ([`my_string_as_bytes[0] as Field`, `my_string_as_bytes[1] as Field`, ...],\n/// // [`let my_string_as_bytes = my_string.as_bytes()`])\n/// ```\n///\n/// ## Nested Struct with packing enabled\n/// - u128 has a `Packable` implementation hence it will be packed.\n///\n/// For a more complex struct:\n/// ```rust\n/// struct MyStruct {\n///     value: u128,\n///     value2: Field,\n/// }\n/// ```\n///\n/// # Panics\n/// - If the type is unsupported for serialization.\n/// - If the provided `typ` contains invalid constants or incompatible structures.\npub comptime fn generate_serialize_to_fields(\n    name: Quoted,\n    typ: Type,\n    should_pack: bool,\n) -> ([Quoted], [Quoted]) {\n    let mut fields = &[];\n    let mut aux_vars = &[];\n\n    // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n    let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n    let packable_constraint =\n        quote { crate::traits::Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n    if (should_pack & typ.implements(packable_constraint)) {\n        // Packing is enabled and the given type implements the `Packable` trait so we call the `pack()`\n        // method, add the resulting field array to `aux_vars` and each field to `fields`.\n        let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n        // We collapse the name to a one that gets tokenized as a single token (e.g. \"self.value\" -> \"self_value\").\n        let name_at_one_token = collapse_to_one_token(name);\n        let packed_struct_name = f\"{name_at_one_token}_aux_var\".quoted_contents();\n\n        // We add the individual fields to the fields array\n        let pack_method = get_trait_impl_method(\n            typ,\n            quote { crate::traits::Packable<$packed_len> },\n            quote { pack },\n        );\n        let packed_struct = quote { let $packed_struct_name = $pack_method($name) };\n        for i in 0..packed_len {\n            fields = fields.push_back(quote { $packed_struct_name[$i] });\n        }\n\n        // We add the new auxiliary variable to the aux_vars array\n        aux_vars = aux_vars.push_back(packed_struct);\n    } else if typ.is_field() {\n        // For field we just add the value to fields\n        fields = fields.push_back(name);\n    } else if typ.as_integer().is_some() | typ.is_bool() {\n        // For integer and bool we just cast to Field and add the value to fields\n        fields = fields.push_back(quote { $name as Field });\n    } else if typ.as_data_type().is_some() {\n        // For struct we pref\n        let nested_struct = typ.as_data_type().unwrap();\n        let params = nested_struct.0.fields(nested_struct.1);\n        let struct_flattened = params.map(|(param_name, param_type): (Quoted, Type)| {\n            let maybe_prefixed_name = if name == quote {} {\n                // Triggered when the param name is of a value available in the current scope (e.g. a function\n                // argument) --> then we don't prefix the name with anything.\n                param_name\n            } else {\n                // Triggered when we want to prefix the param name with the `name` from function input. This\n                // can typically be `self` when implementing a method on a struct.\n                quote { $name.$param_name }\n            };\n            generate_serialize_to_fields(quote {$maybe_prefixed_name}, param_type, should_pack)\n        });\n        let struct_flattened_fields = struct_flattened.fold(\n            &[],\n            |acc: [Quoted], (fields, _): (_, [Quoted])| acc.append(fields),\n        );\n        let struct_flattened_aux_vars = struct_flattened.fold(\n            &[],\n            |acc: [Quoted], (_, aux_vars): ([Quoted], _)| acc.append(aux_vars),\n        );\n        fields = fields.append(struct_flattened_fields);\n        aux_vars = aux_vars.append(struct_flattened_aux_vars);\n    } else if typ.as_array().is_some() {\n        // For array we recursively call `generate_serialize_to_fields(...)` for each element\n        let (element_type, array_len) = typ.as_array().unwrap();\n        let array_len = array_len.as_constant().unwrap();\n        for i in 0..array_len {\n            let (element_fields, element_aux_vars) =\n                generate_serialize_to_fields(quote { $name[$i] }, element_type, should_pack);\n            fields = fields.append(element_fields);\n            aux_vars = aux_vars.append(element_aux_vars);\n        }\n    } else if typ.as_str().is_some() {\n        // For string we convert the value to bytes, we store the `as_bytes` in an auxiliary variables and\n        // then we add each byte to fields as a Field\n        let length_type = typ.as_str().unwrap();\n        let str_len = length_type.as_constant().unwrap();\n        let as_member = name.as_expr().unwrap().as_member_access();\n        let var_name = if as_member.is_some() {\n            as_member.unwrap().1\n        } else {\n            name\n        };\n        let as_bytes_name = f\"{var_name}_as_bytes\".quoted_contents();\n        let as_bytes = quote { let $as_bytes_name = $name.as_bytes() };\n        for i in 0..str_len {\n            fields = fields.push_back(quote { $as_bytes_name[$i] as Field });\n        }\n        aux_vars = aux_vars.push_back(as_bytes);\n    } else {\n        panic(\n            f\"Unsupported type for serialization of argument {name} and type {typ}\",\n        )\n    }\n\n    (fields, aux_vars)\n}\n\n/// From a quote that gets tokenized to a multiple tokens we collapse it to a single token by replacing all `.` with `_`.\n/// E.g. \"self.values[0]\" -> \"self_values_0_\"\ncomptime fn collapse_to_one_token(q: Quoted) -> Quoted {\n    let tokens = q.tokens();\n\n    let mut single_token = quote {};\n    for token in tokens {\n        let new_token = if ((token == quote {.}) | (token == quote {[}) | (token == quote {]})) {\n            quote {_}\n        } else {\n            token\n        };\n        single_token = f\"{single_token}{new_token}\".quoted_contents();\n    }\n    single_token\n}\n\npub(crate) comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let (fields, aux_vars) = generate_serialize_to_fields(quote { self }, typ, false);\n    let aux_vars_for_serialization = if aux_vars.len() > 0 {\n        let joint = aux_vars.join(quote {;});\n        quote { $joint; }\n    } else {\n        quote {}\n    };\n\n    let field_serializations = fields.join(quote {,});\n    let serialized_len = fields.len();\n    quote {\n        impl Serialize<$serialized_len> for $typ {\n            fn serialize(self) -> [Field; $serialized_len] {\n                $aux_vars_for_serialization\n                [ $field_serializations ]\n            }\n        }\n    }\n}\n\npub(crate) comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let (fields, _) = generate_serialize_to_fields(quote { self }, typ, false);\n    let serialized_len = fields.len();\n    let (deserialized, _) =\n        generate_deserialize_from_fields(quote { self }, typ, quote { serialized }, 0, false);\n    quote {\n        impl Deserialize<$serialized_len> for $typ {\n            fn deserialize(serialized: [Field; $serialized_len]) -> Self {\n                $deserialized\n            }\n        }\n    }\n}\n\n/// Generates `Packable` implementation for a given struct and returns the packed length.\n///\n/// Note: We are having this function separate from `derive_packable` because we use this in the note macros to get\n/// the packed length of a note as well as the `Packable` implementation. We need the length to be able to register\n/// the note in the global `NOTES` map. There the length is used to generate partial note helper functions.\npub comptime fn derive_packable_and_get_packed_len(s: TypeDefinition) -> (Quoted, u32) {\n    let packing_enabled = true;\n\n    let typ = s.as_type();\n    let (fields, aux_vars) = generate_serialize_to_fields(quote { self }, typ, packing_enabled);\n    let aux_vars_for_packing = if aux_vars.len() > 0 {\n        let joint = aux_vars.join(quote {;});\n        quote { $joint; }\n    } else {\n        quote {}\n    };\n\n    let (unpacked, _) =\n        generate_deserialize_from_fields(quote { self }, typ, quote { packed }, 0, packing_enabled);\n\n    let field_packings = fields.join(quote {,});\n    let packed_len = fields.len();\n    let packable_trait: TraitConstraint = quote { Packable<$packed_len> }.as_trait_constraint();\n    (\n        quote {\n        impl $packable_trait for $typ {\n            fn pack(self) -> [Field; $packed_len] {\n                $aux_vars_for_packing\n                [ $field_packings ]\n            }\n\n            fn unpack(packed: [Field; $packed_len]) -> Self {\n                $unpacked\n            }\n        }\n    },\n        packed_len,\n    )\n}\n\npub(crate) comptime fn derive_packable(s: TypeDefinition) -> Quoted {\n    let (packable_impl, _) = derive_packable_and_get_packed_len(s);\n    packable_impl\n}\n\n#[derive(Packable, Serialize, Deserialize, Eq)]\npub struct Smol {\n    a: Field,\n    b: Field,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct HasArray {\n    a: [Field; 2],\n    b: bool,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct Fancier {\n    a: Smol,\n    b: [Field; 2],\n    c: [u8; 3],\n    d: str<16>,\n}\n\nfn main() {\n    assert(false);\n}\n\n#[test]\nfn smol_test() {\n    let smol = Smol { a: 1, b: 2 };\n    let serialized = smol.serialize();\n    assert(serialized == [1, 2], serialized);\n    let deserialized = Smol::deserialize(serialized);\n    assert(deserialized == smol);\n\n    // None of the struct members implements the `Packable` trait so the packed and serialized data should be the same\n    let packed = smol.pack();\n    assert_eq(packed, serialized, \"Packed does not match serialized\");\n}\n\n#[test]\nfn has_array_test() {\n    let has_array = HasArray { a: [1, 2], b: true };\n    let serialized = has_array.serialize();\n    assert(serialized == [1, 2, 1], serialized);\n    let deserialized = HasArray::deserialize(serialized);\n    assert(deserialized == has_array);\n}\n\n#[test]\nfn fancier_test() {\n    let fancier =\n        Fancier { a: Smol { a: 1, b: 2 }, b: [0, 1], c: [1, 2, 3], d: \"metaprogramming!\" };\n    let serialized = fancier.serialize();\n    assert(\n        serialized\n            == [\n                1, 2, 0, 1, 1, 2, 3, 0x6d, 0x65, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61,\n                0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x21,\n            ],\n        serialized,\n    );\n    let deserialized = Fancier::deserialize(serialized);\n    assert(deserialized == fancier);\n}\n"
     },
-    "296": {
+    "297": {
       "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"
     },
-    "305": {
+    "307": {
       "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},\n};\n\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse std::default::Default;\n\npub global PUBLIC_KEYS_LENGTH: u32 = 12;\n\npub struct PublicKeys {\n    pub npk_m: NpkM,\n    pub ivpk_m: IvpkM,\n    pub ovpk_m: OvpkM,\n    pub tpk_m: TpkM,\n}\n\npub trait ToPoint {\n    fn to_point(self) -> Point;\n}\n\npub struct NpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for NpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for NpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\n// Note: If we store npk_m_hash directly we can remove this trait implementation. See #8091\nimpl Hash for NpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\npub struct IvpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for IvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for IvpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\npub struct OvpkM {\n    pub inner: Point,\n}\n\nimpl Hash for OvpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\nimpl ToPoint for OvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for OvpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\npub struct TpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for TpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for TpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\nimpl Default for PublicKeys {\n    fn default() -> Self {\n        PublicKeys {\n            npk_m: NpkM {\n                inner: Point { x: DEFAULT_NPK_M_X, y: DEFAULT_NPK_M_Y, is_infinite: false },\n            },\n            ivpk_m: IvpkM {\n                inner: Point { x: DEFAULT_IVPK_M_X, y: DEFAULT_IVPK_M_Y, is_infinite: false },\n            },\n            ovpk_m: OvpkM {\n                inner: Point { x: DEFAULT_OVPK_M_X, y: DEFAULT_OVPK_M_Y, is_infinite: false },\n            },\n            tpk_m: TpkM {\n                inner: Point { x: DEFAULT_TPK_M_X, y: DEFAULT_TPK_M_Y, is_infinite: false },\n            },\n        }\n    }\n}\n\nimpl Eq for PublicKeys {\n    fn eq(self, other: PublicKeys) -> bool {\n        (self.npk_m.inner == other.npk_m.inner)\n            & (self.ivpk_m.inner == other.ivpk_m.inner)\n            & (self.ovpk_m.inner == other.ovpk_m.inner)\n            & (self.tpk_m.inner == other.tpk_m.inner)\n    }\n}\n\nimpl PublicKeys {\n    pub fn hash(self) -> PublicKeysHash {\n        PublicKeysHash::from_field(poseidon2_hash_with_separator(\n            self.serialize(),\n            GENERATOR_INDEX__PUBLIC_KEYS_HASH as Field,\n        ))\n    }\n}\n\nimpl Serialize<PUBLIC_KEYS_LENGTH> for PublicKeys {\n    fn serialize(self) -> [Field; PUBLIC_KEYS_LENGTH] {\n        [\n            self.npk_m.inner.x,\n            self.npk_m.inner.y,\n            self.npk_m.inner.is_infinite as Field,\n            self.ivpk_m.inner.x,\n            self.ivpk_m.inner.y,\n            self.ivpk_m.inner.is_infinite as Field,\n            self.ovpk_m.inner.x,\n            self.ovpk_m.inner.y,\n            self.ovpk_m.inner.is_infinite as Field,\n            self.tpk_m.inner.x,\n            self.tpk_m.inner.y,\n            self.tpk_m.inner.is_infinite as Field,\n        ]\n    }\n}\n\nimpl Deserialize<PUBLIC_KEYS_LENGTH> for PublicKeys {\n    fn deserialize(serialized: [Field; PUBLIC_KEYS_LENGTH]) -> PublicKeys {\n        PublicKeys {\n            npk_m: NpkM {\n                inner: Point {\n                    x: serialized[0],\n                    y: serialized[1],\n                    is_infinite: serialized[2] as bool,\n                },\n            },\n            ivpk_m: IvpkM {\n                inner: Point {\n                    x: serialized[3],\n                    y: serialized[4],\n                    is_infinite: serialized[5] as bool,\n                },\n            },\n            ovpk_m: OvpkM {\n                inner: Point {\n                    x: serialized[6],\n                    y: serialized[7],\n                    is_infinite: serialized[8] as bool,\n                },\n            },\n            tpk_m: TpkM {\n                inner: Point {\n                    x: serialized[9],\n                    y: serialized[10],\n                    is_infinite: serialized[11] as bool,\n                },\n            },\n        }\n    }\n}\n\npub struct AddressPoint {\n    pub inner: Point,\n}\n\nimpl ToPoint for AddressPoint {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\n#[test]\nunconstrained fn compute_public_keys_hash() {\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n        ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n        ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n        tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n    };\n\n    let actual = keys.hash();\n    let expected_public_keys_hash =\n        0x0fecd9a32db731fec1fded1b9ff957a1625c069245a3613a2538bd527068b0ad;\n\n    assert(actual.to_field() == expected_public_keys_hash);\n}\n\n#[test]\nunconstrained fn compute_default_hash() {\n    let keys = PublicKeys::default();\n\n    let actual = keys.hash();\n    let test_data_default_hash = 0x1d3bf1fb93ae0e9cda83b203dd91c3bfb492a9aecf30ec90e1057eced0f0e62d;\n\n    assert(actual.to_field() == test_data_default_hash);\n}\n\n#[test]\nunconstrained fn test_public_keys_serialization() {\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n        ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n        ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n        tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n    };\n\n    let serialized = keys.serialize();\n    let deserialized = PublicKeys::deserialize(serialized);\n\n    assert_eq(keys.npk_m.inner.x, deserialized.npk_m.inner.x);\n    assert_eq(keys.npk_m.inner.y, deserialized.npk_m.inner.y);\n    assert_eq(keys.ivpk_m.inner.x, deserialized.ivpk_m.inner.x);\n    assert_eq(keys.ivpk_m.inner.y, deserialized.ivpk_m.inner.y);\n    assert_eq(keys.ovpk_m.inner.x, deserialized.ovpk_m.inner.x);\n    assert_eq(keys.ovpk_m.inner.y, deserialized.ovpk_m.inner.y);\n    assert_eq(keys.tpk_m.inner.x, deserialized.tpk_m.inner.x);\n    assert_eq(keys.tpk_m.inner.y, deserialized.tpk_m.inner.y);\n}\n"
     },
-    "309": {
+    "311": {
       "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"
     },
-    "311": {
+    "313": {
       "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"
     },
-    "313": {
+    "315": {
       "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\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"
     },
-    "316": {
+    "318": {
       "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"
     },
-    "334": {
+    "336": {
       "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"
     },
-    "335": {
+    "337": {
       "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"
     },
-    "351": {
+    "353": {
       "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"
+      "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, 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    get_split_order_hints::{get_split_order_hints_asc, 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;\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\n// Returns the number of consecutive elements at the start of the array for which the predicate returns false.\n// This function ensures that any element after the first matching element (predicate returns true) also matches the predicate.\npub fn array_length_until<T, let N: u32, Env>(array: [T; N], predicate: fn[Env](T) -> bool) -> u32 {\n    let mut length = 0;\n    let mut stop = false;\n    for i in 0..N {\n        if predicate(array[i]) {\n            stop = true;\n        } else {\n            assert(\n                stop == false,\n                \"matching element found after already encountering a non-matching element\",\n            );\n            length += 1;\n        }\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\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// Helper function to check if an array is padded with a given value from a given index.\n// Different to padded_array_length in that it allows the elements before the given index to be the same as the padded value.\npub fn array_padded_with<T, let N: u32>(array: [T; N], from_index: u32, padded_with: T) -> bool\nwhere\n    T: Eq,\n{\n    let mut is_valid = true;\n    let mut should_check = false;\n    for i in 0..N {\n        should_check |= i == from_index;\n        is_valid &= !should_check | (array[i] == padded_with);\n    }\n    is_valid\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]\nfn test_array_length_until() {\n    let array = [11, 22, 33, 44, 55];\n    assert_eq(array_length_until(array, |x| x == 55), 4);\n    assert_eq(array_length_until(array, |x| x == 56), 5);\n    assert_eq(array_length_until(array, |x| x > 40), 3);\n    assert_eq(array_length_until(array, |x| x > 10), 0);\n}\n\n#[test(should_fail_with = \"matching element found after already encountering a non-matching element\")]\nfn test_array_length_until_non_consecutive_fails() {\n    let array = [1, 1, 0, 1, 0];\n    let _ = array_length_until(array, |x| x == 0);\n}\n\n#[test(should_fail_with = \"matching element found after already encountering a non-matching element\")]\nfn test_array_length_until_first_non_matching_fails() {\n    let array = [1, 0, 0, 0, 0];\n    let _ = array_length_until(array, |x| x == 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\n#[test]\nfn test_array_padded_with() {\n    let array = [11, 22, 33, 44, 44];\n    assert_eq(array_padded_with(array, 0, 44), false);\n    assert_eq(array_padded_with(array, 1, 44), false);\n    assert_eq(array_padded_with(array, 2, 44), false);\n    assert_eq(array_padded_with(array, 3, 44), true);\n    assert_eq(array_padded_with(array, 4, 44), true);\n    assert_eq(array_padded_with(array, 4, 33), false);\n    assert_eq(array_padded_with(array, 5, 44), true); // Index out of bounds.\n    assert_eq(array_padded_with(array, 0, 11), false);\n}\n"
     },
-    "354": {
+    "356": {
       "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"
     },
@@ -2797,15 +2828,15 @@
     },
     "50": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/contract_instance_deployer_contract/src/main.nr",
-      "source": "use dep::aztec::macros::aztec;\n\n#[aztec]\npub contract ContractInstanceDeployer {\n    use dep::aztec::macros::{events::event, functions::{private, public, view}, storage::storage};\n    use dep::aztec::prelude::{Map, SharedMutable};\n    use dep::aztec::protocol_types::{\n        address::{AztecAddress, PartialAddress},\n        constants::{\n            DEFAULT_UPDATE_DELAY, DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE,\n            DEPLOYER_CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE, MINIMUM_UPDATE_DELAY,\n            REGISTERER_CONTRACT_ADDRESS,\n        },\n        contract_class_id::ContractClassId,\n        public_keys::PublicKeys,\n        traits::{Serialize, ToField},\n        utils::arrays::array_concat,\n    };\n    use dep::contract_class_registerer::ContractClassRegisterer;\n    use std::meta::derive;\n\n    #[derive(Serialize)]\n    #[event]\n    struct ContractInstanceDeployed {\n        DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE: Field,\n        address: AztecAddress,\n        version: u8,\n        salt: Field,\n        contract_class_id: ContractClassId,\n        initialization_hash: Field,\n        public_keys: PublicKeys,\n        deployer: AztecAddress,\n    }\n\n    // We need to impl this separately because ts deserializes a point as two fields only.\n    // We had issues that:\n    // Notice how the 'is_infinite' field is deserialized as the next point.\n    // {\n    //     masterNullifierPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000012>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000000034>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // },\n    // masterIncomingViewingPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000000>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000000056>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // },\n    // masterOutgoingViewingPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000078>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000000000>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // },\n    // masterTaggingPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000910>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000001112>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // }\n\n    impl ContractInstanceDeployed {\n        fn serialize_non_standard(self) -> [Field; 15] {\n            [\n                self.DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE,\n                self.address.to_field(),\n                self.version.to_field(),\n                self.salt,\n                self.contract_class_id.to_field(),\n                self.initialization_hash,\n                self.public_keys.npk_m.serialize()[0],\n                self.public_keys.npk_m.serialize()[1],\n                self.public_keys.ivpk_m.serialize()[0],\n                self.public_keys.ivpk_m.serialize()[1],\n                self.public_keys.ovpk_m.serialize()[0],\n                self.public_keys.ovpk_m.serialize()[1],\n                self.public_keys.tpk_m.serialize()[0],\n                self.public_keys.tpk_m.serialize()[1],\n                self.deployer.to_field(),\n            ]\n        }\n    }\n\n    #[derive(Serialize)]\n    #[event]\n    struct ContractInstanceUpdated {\n        DEPLOYER_CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE: Field,\n        address: AztecAddress,\n        prev_contract_class_id: ContractClassId,\n        new_contract_class_id: ContractClassId,\n        block_of_change: u32,\n    }\n\n    #[storage]\n    struct Storage<Context> {\n        updated_class_ids: Map<AztecAddress, SharedMutable<ContractClassId, DEFAULT_UPDATE_DELAY, Context>, Context>,\n    }\n\n    #[private]\n    fn deploy(\n        salt: Field,\n        contract_class_id: ContractClassId,\n        initialization_hash: Field,\n        public_keys: PublicKeys,\n        universal_deploy: bool,\n    ) {\n        // contract class must be registered to deploy an instance\n        ContractClassRegisterer::at(REGISTERER_CONTRACT_ADDRESS)\n            .assert_class_id_is_registered(contract_class_id)\n            .call(&mut context);\n\n        let deployer = if universal_deploy {\n            AztecAddress::zero()\n        } else {\n            context.msg_sender()\n        };\n\n        let partial_address =\n            PartialAddress::compute(contract_class_id, salt, initialization_hash, deployer);\n\n        let address = AztecAddress::compute(public_keys, partial_address);\n\n        // Emit the address as a nullifier to be able to prove that this instance has been (not) deployed\n        context.push_nullifier(address.to_field());\n\n        // Broadcast the event\n        let event = ContractInstanceDeployed {\n            DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE,\n            contract_class_id,\n            address,\n            public_keys,\n            initialization_hash,\n            salt,\n            deployer,\n            version: 1,\n        };\n\n        let payload = event.serialize_non_standard();\n        dep::aztec::oracle::debug_log::debug_log_format(\"ContractInstanceDeployed: {}\", payload);\n\n        let padded_log = array_concat(payload, [0; 3]);\n        context.emit_private_log(padded_log);\n    }\n\n    #[public]\n    fn update(new_contract_class_id: ContractClassId) {\n        let address = context.msg_sender();\n\n        assert(\n            context.nullifier_exists(address.to_field(), context.this_address()),\n            \"msg.sender is not deployed\",\n        );\n\n        assert(\n            context.nullifier_exists(new_contract_class_id.to_field(), REGISTERER_CONTRACT_ADDRESS),\n            \"New contract class is not registered\",\n        );\n\n        let scheduled_value_update = storage\n            .updated_class_ids\n            .at(address)\n            .schedule_and_return_value_change(new_contract_class_id);\n        let (prev_contract_class_id, block_of_change) = scheduled_value_update.get_previous();\n\n        let event = ContractInstanceUpdated {\n            DEPLOYER_CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE,\n            address,\n            prev_contract_class_id,\n            new_contract_class_id,\n            block_of_change,\n        };\n\n        context.emit_public_log(event);\n    }\n\n    #[public]\n    fn set_update_delay(new_update_delay: u32) {\n        let address = context.msg_sender();\n\n        assert(\n            context.nullifier_exists(address.to_field(), context.this_address()),\n            \"msg.sender is not deployed\",\n        );\n\n        assert(new_update_delay >= MINIMUM_UPDATE_DELAY, \"New update delay is too low\");\n\n        storage.updated_class_ids.at(address).schedule_delay_change(new_update_delay);\n    }\n\n    #[public]\n    #[view]\n    fn get_update_delay() -> u32 {\n        storage.updated_class_ids.at(context.msg_sender()).get_current_delay()\n    }\n}\n"
+      "source": "use dep::aztec::macros::aztec;\n\n#[aztec]\npub contract ContractInstanceDeployer {\n    use dep::aztec::macros::{events::event, functions::{private, public, view}, storage::storage};\n    use dep::aztec::prelude::{Map, SharedMutable};\n    use dep::aztec::protocol_types::{\n        address::{AztecAddress, PartialAddress},\n        constants::{\n            DEFAULT_UPDATE_DELAY, DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE,\n            DEPLOYER_CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE, MINIMUM_UPDATE_DELAY,\n            REGISTERER_CONTRACT_ADDRESS,\n        },\n        contract_class_id::ContractClassId,\n        public_keys::PublicKeys,\n        traits::{Serialize, ToField},\n        utils::arrays::array_concat,\n    };\n    use dep::contract_class_registerer::ContractClassRegisterer;\n    use std::meta::derive;\n\n    #[derive(Serialize)]\n    #[event]\n    struct ContractInstanceDeployed {\n        DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE: Field,\n        address: AztecAddress,\n        version: u8,\n        salt: Field,\n        contract_class_id: ContractClassId,\n        initialization_hash: Field,\n        public_keys: PublicKeys,\n        deployer: AztecAddress,\n    }\n\n    // We need to impl this separately because ts deserializes a point as two fields only.\n    // We had issues that:\n    // Notice how the 'is_infinite' field is deserialized as the next point.\n    // {\n    //     masterNullifierPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000012>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000000034>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // },\n    // masterIncomingViewingPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000000>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000000056>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // },\n    // masterOutgoingViewingPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000078>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000000000>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // },\n    // masterTaggingPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000910>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000001112>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // }\n\n    impl ContractInstanceDeployed {\n        fn serialize_non_standard(self) -> [Field; 15] {\n            [\n                self.DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE,\n                self.address.to_field(),\n                self.version.to_field(),\n                self.salt,\n                self.contract_class_id.to_field(),\n                self.initialization_hash,\n                self.public_keys.npk_m.serialize()[0],\n                self.public_keys.npk_m.serialize()[1],\n                self.public_keys.ivpk_m.serialize()[0],\n                self.public_keys.ivpk_m.serialize()[1],\n                self.public_keys.ovpk_m.serialize()[0],\n                self.public_keys.ovpk_m.serialize()[1],\n                self.public_keys.tpk_m.serialize()[0],\n                self.public_keys.tpk_m.serialize()[1],\n                self.deployer.to_field(),\n            ]\n        }\n    }\n\n    #[derive(Serialize)]\n    #[event]\n    struct ContractInstanceUpdated {\n        DEPLOYER_CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE: Field,\n        address: AztecAddress,\n        prev_contract_class_id: ContractClassId,\n        new_contract_class_id: ContractClassId,\n        block_of_change: u32,\n    }\n\n    #[storage]\n    struct Storage<Context> {\n        updated_class_ids: Map<AztecAddress, SharedMutable<ContractClassId, DEFAULT_UPDATE_DELAY, Context>, Context>,\n    }\n\n    #[private]\n    fn deploy(\n        salt: Field,\n        contract_class_id: ContractClassId,\n        initialization_hash: Field,\n        public_keys: PublicKeys,\n        universal_deploy: bool,\n    ) {\n        // contract class must be registered to deploy an instance\n        ContractClassRegisterer::at(REGISTERER_CONTRACT_ADDRESS)\n            .assert_class_id_is_registered(contract_class_id)\n            .call(&mut context);\n\n        let deployer = if universal_deploy {\n            AztecAddress::zero()\n        } else {\n            context.msg_sender()\n        };\n\n        let partial_address =\n            PartialAddress::compute(contract_class_id, salt, initialization_hash, deployer);\n\n        let address = AztecAddress::compute(public_keys, partial_address);\n\n        // Emit the address as a nullifier to be able to prove that this instance has been (not) deployed\n        context.push_nullifier(address.to_field());\n\n        // Broadcast the event\n        let event = ContractInstanceDeployed {\n            DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE,\n            contract_class_id,\n            address,\n            public_keys,\n            initialization_hash,\n            salt,\n            deployer,\n            version: 1,\n        };\n\n        let payload = event.serialize_non_standard();\n        dep::aztec::oracle::debug_log::debug_log_format(\"ContractInstanceDeployed: {}\", payload);\n\n        let padded_log = array_concat(payload, [0; 3]);\n        // Only the payload needs to be emitted. Since the siloed tag of this event log is publicly known, it's\n        // acceptable to pad the log with 0s and reveal the actual payload length.\n        let length = payload.len();\n        context.emit_private_log(padded_log, length);\n    }\n\n    #[public]\n    fn update(new_contract_class_id: ContractClassId) {\n        let address = context.msg_sender();\n\n        assert(\n            context.nullifier_exists(address.to_field(), context.this_address()),\n            \"msg.sender is not deployed\",\n        );\n\n        assert(\n            context.nullifier_exists(new_contract_class_id.to_field(), REGISTERER_CONTRACT_ADDRESS),\n            \"New contract class is not registered\",\n        );\n\n        let scheduled_value_update = storage\n            .updated_class_ids\n            .at(address)\n            .schedule_and_return_value_change(new_contract_class_id);\n        let (prev_contract_class_id, block_of_change) = scheduled_value_update.get_previous();\n\n        let event = ContractInstanceUpdated {\n            DEPLOYER_CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE,\n            address,\n            prev_contract_class_id,\n            new_contract_class_id,\n            block_of_change,\n        };\n\n        context.emit_public_log(event);\n    }\n\n    #[public]\n    fn set_update_delay(new_update_delay: u32) {\n        let address = context.msg_sender();\n\n        assert(\n            context.nullifier_exists(address.to_field(), context.this_address()),\n            \"msg.sender is not deployed\",\n        );\n\n        assert(new_update_delay >= MINIMUM_UPDATE_DELAY, \"New update delay is too low\");\n\n        storage.updated_class_ids.at(address).schedule_delay_change(new_update_delay);\n    }\n\n    #[public]\n    #[view]\n    fn get_update_delay() -> u32 {\n        storage.updated_class_ids.at(context.msg_sender()).get_current_delay()\n    }\n}\n"
     },
     "52": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr",
-      "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector,\n    address::AztecAddress,\n    traits::{Deserialize, ToField},\n};\n\nuse crate::context::{gas::GasOpts, private_context::PrivateContext, public_context::PublicContext};\n\nuse crate::hash::{hash_args, hash_calldata};\nuse crate::oracle::execution_cache;\n\npub trait CallInterface<let N: u32> {\n    fn get_args(self) -> [Field];\n    fn get_selector(self) -> FunctionSelector;\n    fn get_name(self) -> str<N>;\n    fn get_contract_address(self) -> AztecAddress;\n    fn get_is_static(self) -> bool;\n}\n\n// PrivateCallInterface\n\npub struct PrivateCallInterface<let N: u32, T> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args_hash: Field,\n    args: [Field],\n    return_type: T,\n    is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateCallInterface<N, T> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n        is_static: bool,\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self {\n            target_contract,\n            selector,\n            name,\n            args_hash,\n            args,\n            return_type: std::mem::zeroed(),\n            is_static,\n        }\n    }\n\n    pub fn call<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        execution_cache::store(self.args, self.args_hash);\n        let returns_hash = context.call_private_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            false,\n        );\n        let returns: T = returns_hash.get_preimage();\n        returns\n    }\n\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        execution_cache::store(self.args, self.args_hash);\n        let returns_hash = context.call_private_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns_hash.get_preimage()\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PrivateCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PrivateVoidCallInterface\n\npub struct PrivateVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args_hash: Field,\n    args: [Field],\n    return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n    is_static: bool,\n}\n\nimpl<let N: u32> PrivateVoidCallInterface<N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n        is_static: bool,\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self { target_contract, selector, name, args_hash, args, return_type: (), is_static }\n    }\n\n    pub fn call(self, context: &mut PrivateContext) {\n        execution_cache::store(self.args, self.args_hash);\n        context\n            .call_private_function_with_args_hash(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                false,\n            )\n            .assert_empty();\n    }\n\n    pub fn view(self, context: &mut PrivateContext) {\n        execution_cache::store(self.args, self.args_hash);\n        context\n            .call_private_function_with_args_hash(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PrivateStaticCallInterface\n\npub struct PrivateStaticCallInterface<let N: u32, T> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args_hash: Field,\n    args: [Field],\n    return_type: T,\n    is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateStaticCallInterface<N, T> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self {\n            target_contract,\n            selector,\n            name,\n            args_hash,\n            args,\n            return_type: std::mem::zeroed(),\n            is_static: true,\n        }\n    }\n\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        execution_cache::store(self.args, self.args_hash);\n        let returns = context.call_private_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.get_preimage()\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PrivateStaticCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PrivateStaticVoidCallInterface\n\npub struct PrivateStaticVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args_hash: Field,\n    args: [Field],\n    return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n    is_static: bool,\n}\n\nimpl<let N: u32> PrivateStaticVoidCallInterface<N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self { target_contract, selector, name, args_hash, args, return_type: (), is_static: true }\n    }\n\n    pub fn view(self, context: &mut PrivateContext) {\n        execution_cache::store(self.args, self.args_hash);\n        context\n            .call_private_function_with_args_hash(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateStaticVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PublicCallInterface\n\npub struct PublicCallInterface<let N: u32, T> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    gas_opts: GasOpts,\n    return_type: T,\n    is_static: bool,\n}\n\nimpl<let N: u32, T> PublicCallInterface<N, T> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n        is_static: bool,\n    ) -> Self {\n        Self {\n            target_contract,\n            selector,\n            name,\n            args,\n            gas_opts: GasOpts::default(),\n            return_type: std::mem::zeroed(),\n            is_static,\n        }\n    }\n\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PublicVoidCallInterface\n\npub struct PublicVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicVoidCallInterface<N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n        is_static: bool,\n    ) -> Self {\n        Self {\n            target_contract,\n            selector,\n            name,\n            args,\n            return_type: (),\n            is_static,\n            gas_opts: GasOpts::default(),\n        }\n    }\n\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call(self, context: &mut PublicContext) {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            true,\n        )\n    }\n\n    pub fn set_as_teardown(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.set_public_teardown_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            false,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PublicStaticCallInterface\n\npub struct PublicStaticCallInterface<let N: u32, T> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    return_type: T,\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let N: u32, T> PublicStaticCallInterface<N, T> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n    ) -> Self {\n        Self {\n            target_contract,\n            selector,\n            name,\n            args,\n            return_type: std::mem::zeroed(),\n            is_static: true,\n            gas_opts: GasOpts::default(),\n        }\n    }\n\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicStaticCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PublicStaticVoidCallInterface\n\npub struct PublicStaticVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicStaticVoidCallInterface<N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n    ) -> Self {\n        Self {\n            target_contract,\n            selector,\n            name,\n            args,\n            return_type: (),\n            is_static: true,\n            gas_opts: GasOpts::default(),\n        }\n    }\n\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicStaticVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n"
+      "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector,\n    address::AztecAddress,\n    traits::{Deserialize, ToField},\n};\n\nuse crate::context::{gas::GasOpts, private_context::PrivateContext, public_context::PublicContext};\n\nuse crate::hash::{hash_args, hash_calldata};\nuse crate::oracle::execution_cache;\n\npub trait CallInterface<let N: u32> {\n    fn get_args(self) -> [Field];\n    fn get_selector(self) -> FunctionSelector;\n    fn get_name(self) -> str<N>;\n    fn get_contract_address(self) -> AztecAddress;\n    fn get_is_static(self) -> bool;\n}\n\n// PrivateCallInterface\n\npub struct PrivateCallInterface<let N: u32, T> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args_hash: Field,\n    args: [Field],\n    return_type: T,\n    is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateCallInterface<N, T> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n        is_static: bool,\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self {\n            target_contract,\n            selector,\n            name,\n            args_hash,\n            args,\n            return_type: std::mem::zeroed(),\n            is_static,\n        }\n    }\n\n    pub fn call<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        execution_cache::store(self.args, self.args_hash);\n        let returns_hash = context.call_private_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            false,\n        );\n        let returns: T = returns_hash.get_preimage();\n        returns\n    }\n\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        execution_cache::store(self.args, self.args_hash);\n        let returns_hash = context.call_private_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns_hash.get_preimage()\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PrivateCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PrivateVoidCallInterface\n\npub struct PrivateVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args_hash: Field,\n    args: [Field],\n    return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n    is_static: bool,\n}\n\nimpl<let N: u32> PrivateVoidCallInterface<N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n        is_static: bool,\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self { target_contract, selector, name, args_hash, args, return_type: (), is_static }\n    }\n\n    pub fn call(self, context: &mut PrivateContext) {\n        execution_cache::store(self.args, self.args_hash);\n        context\n            .call_private_function_with_args_hash(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                false,\n            )\n            .assert_empty();\n    }\n\n    pub fn view(self, context: &mut PrivateContext) {\n        execution_cache::store(self.args, self.args_hash);\n        context\n            .call_private_function_with_args_hash(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PrivateStaticCallInterface\n\npub struct PrivateStaticCallInterface<let N: u32, T> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args_hash: Field,\n    args: [Field],\n    return_type: T,\n    is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateStaticCallInterface<N, T> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self {\n            target_contract,\n            selector,\n            name,\n            args_hash,\n            args,\n            return_type: std::mem::zeroed(),\n            is_static: true,\n        }\n    }\n\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        execution_cache::store(self.args, self.args_hash);\n        let returns = context.call_private_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.get_preimage()\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PrivateStaticCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PrivateStaticVoidCallInterface\n\npub struct PrivateStaticVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args_hash: Field,\n    args: [Field],\n    return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n    is_static: bool,\n}\n\nimpl<let N: u32> PrivateStaticVoidCallInterface<N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self { target_contract, selector, name, args_hash, args, return_type: (), is_static: true }\n    }\n\n    pub fn view(self, context: &mut PrivateContext) {\n        execution_cache::store(self.args, self.args_hash);\n        context\n            .call_private_function_with_args_hash(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateStaticVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PublicCallInterface\n\npub struct PublicCallInterface<let N: u32, T> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    gas_opts: GasOpts,\n    return_type: T,\n    is_static: bool,\n}\n\nimpl<let N: u32, T> PublicCallInterface<N, T> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n        is_static: bool,\n    ) -> Self {\n        Self {\n            target_contract,\n            selector,\n            name,\n            args,\n            gas_opts: GasOpts::default(),\n            return_type: std::mem::zeroed(),\n            is_static,\n        }\n    }\n\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PublicVoidCallInterface\n\npub struct PublicVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicVoidCallInterface<N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n        is_static: bool,\n    ) -> Self {\n        Self {\n            target_contract,\n            selector,\n            name,\n            args,\n            return_type: (),\n            is_static,\n            gas_opts: GasOpts::default(),\n        }\n    }\n\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call(self, context: &mut PublicContext) {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            true,\n        )\n    }\n\n    pub fn set_as_teardown(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.set_public_teardown_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            false,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PublicStaticCallInterface\n\npub struct PublicStaticCallInterface<let N: u32, T> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    return_type: T,\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let N: u32, T> PublicStaticCallInterface<N, T> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n    ) -> Self {\n        Self {\n            target_contract,\n            selector,\n            name,\n            args,\n            return_type: std::mem::zeroed(),\n            is_static: true,\n            gas_opts: GasOpts::default(),\n        }\n    }\n\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicStaticCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PublicStaticVoidCallInterface\n\npub struct PublicStaticVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicStaticVoidCallInterface<N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n    ) -> Self {\n        Self {\n            target_contract,\n            selector,\n            name,\n            args,\n            return_type: (),\n            is_static: true,\n            gas_opts: GasOpts::default(),\n        }\n    }\n\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicStaticVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// UtilityCallInterface\n\npub struct UtilityCallInterface<let N: u32, T> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args_hash: Field,\n    args: [Field],\n    return_type: T,\n}\n\nimpl<let N: u32, T> UtilityCallInterface<N, T> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self { target_contract, selector, name, args_hash, args, return_type: std::mem::zeroed() }\n    }\n\n    pub fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    pub fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    pub fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    pub fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n}\n\n// UtilityVoidCallInterface\n\npub struct UtilityVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args_hash: Field,\n    args: [Field],\n    return_type: (),\n}\n\nimpl<let N: u32> UtilityVoidCallInterface<N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self { target_contract, selector, name, args_hash, args, return_type: () }\n    }\n\n    pub fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    pub fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    pub fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    pub fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n}\n"
     },
     "59": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
-      "source": "use crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n    hash::{ArgsHasher, hash_args_array, hash_calldata_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            notify_enqueued_public_function_call, notify_set_min_revertible_side_effect_counter,\n            notify_set_public_teardown_function_call,\n        },\n        execution_cache,\n        key_validation_request::get_key_validation_request,\n        notes::{notify_created_nullifier, notify_nullified_note},\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        gas_settings::GasSettings,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::{Empty, Hash, ToField},\n    utils::arrays::array_concat,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn gas_settings(self) -> GasSettings {\n        self.inputs.tx_context.gas_settings\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        let nullifier_counter = self.next_counter();\n        notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: nullifier_counter,\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        self.return_hash = returns_hasher.hash();\n        execution_cache::store(returns_hasher.fields, self.return_hash);\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request = self.last_key_validation_requests[key_index as u32].unwrap_or(\n            KeyValidationRequest::empty(),\n        );\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n\n            // Safety: Kernels verify that the key validation request is valid and below we verify that a request\n            // for the correct public key has been received.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index as u32],\n                },\n            );\n            self.last_key_validation_requests[key_index as u32] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args, args_hash);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args, args_hash);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n        // execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n        // the number of side effects that took place), along with the hash of the return values. We validate these\n        // by requesting a private kernel iteration in which the return values are constrained to hash\n        // to `returns_hash` and the side effects counter to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n    }\n\n    pub fn call_public_function_with_calldata_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        calldata_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n        notify_enqueued_public_function_call(\n            contract_address,\n            calldata_hash,\n            counter,\n            is_static_call,\n        );\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            is_static_call,\n            calldata_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.set_public_teardown_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn set_public_teardown_function_with_calldata_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        calldata_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n        notify_set_public_teardown_function_call(\n            contract_address,\n            calldata_hash,\n            counter,\n            is_static_call,\n        );\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            is_static_call,\n            calldata_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
+      "source": "use crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n    hash::{ArgsHasher, hash_args_array, hash_calldata_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            notify_enqueued_public_function_call, notify_set_min_revertible_side_effect_counter,\n            notify_set_public_teardown_function_call,\n        },\n        execution_cache,\n        key_validation_request::get_key_validation_request,\n        notes::{notify_created_nullifier, notify_nullified_note},\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        gas_settings::GasSettings,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::{PrivateLog, PrivateLogData},\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::{Empty, Hash, ToField},\n    utils::arrays::array_concat,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<Counted<LogHash>, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn gas_settings(self) -> GasSettings {\n        self.inputs.tx_context.gas_settings\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        let nullifier_counter = self.next_counter();\n        notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: nullifier_counter,\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        self.return_hash = returns_hasher.hash();\n        execution_cache::store(returns_hasher.fields, self.return_hash);\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request = self.last_key_validation_requests[key_index as u32].unwrap_or(\n            KeyValidationRequest::empty(),\n        );\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n\n            // Safety: Kernels verify that the key validation request is valid and below we verify that a request\n            // for the correct public key has been received.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index as u32],\n                },\n            );\n            self.last_key_validation_requests[key_index as u32] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS], length: u32) {\n        let counter = self.next_counter();\n        let private_log =\n            PrivateLogData { log: PrivateLog::new(log, length), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        length: u32,\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log =\n            PrivateLogData { log: PrivateLog::new(log, length), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args, args_hash);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args, args_hash);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n        // execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n        // the number of side effects that took place), along with the hash of the return values. We validate these\n        // by requesting a private kernel iteration in which the return values are constrained to hash\n        // to `returns_hash` and the side effects counter to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n    }\n\n    pub fn call_public_function_with_calldata_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        calldata_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n        notify_enqueued_public_function_call(\n            contract_address,\n            calldata_hash,\n            counter,\n            is_static_call,\n        );\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            is_static_call,\n            calldata_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.set_public_teardown_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn set_public_teardown_function_with_calldata_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        calldata_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n        notify_set_public_teardown_function_call(\n            contract_address,\n            calldata_hash,\n            counter,\n            is_static_call,\n        );\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            is_static_call,\n            calldata_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
     },
     "60": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/public_context.nr",
@@ -2829,15 +2860,15 @@
     },
     "91": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/functions/call_interface_stubs.nr",
-      "source": "use crate::macros::utils::{\n    add_to_field_slice, AsStrQuote, compute_fn_selector, is_fn_private, is_fn_view,\n};\nuse std::meta::{type_of, unquote};\n\ncomptime global FROM_FIELD: TypedExpr = {\n    let from_field_trait = quote { protocol_types::traits::FromField }.as_trait_constraint();\n    let function_selector_typ =\n        quote { protocol_types::abis::function_selector::FunctionSelector }.as_type();\n    function_selector_typ.get_trait_impl(from_field_trait).unwrap().methods().filter(|m| {\n        m.name() == quote { from_field }\n    })[0]\n        .as_typed_expr()\n};\n\ncomptime global SERIALIZED_ARGS_SLICE_NAME: Quoted = quote { serialized_args };\n\npub comptime fn stub_fn(f: FunctionDefinition) -> Quoted {\n    let is_static_call = is_fn_view(f);\n    let is_void = f.return_type() == type_of(());\n\n    if is_fn_private(f) {\n        if is_static_call {\n            if is_void {\n                create_private_static_void_stub(f)\n            } else {\n                create_private_static_stub(f)\n            }\n        } else {\n            if is_void {\n                create_private_void_stub(f)\n            } else {\n                create_private_stub(f)\n            }\n        }\n    } else {\n        if is_static_call {\n            if is_void {\n                create_public_static_void_stub(f)\n            } else {\n                create_public_static_stub(f)\n            }\n        } else {\n            if is_void {\n                create_public_void_stub(f)\n            } else {\n                create_public_stub(f)\n            }\n        }\n    }\n}\n\n/// Utility function creating stubs used by all the stub functions in this file.\ncomptime fn create_stub_base(\n    f: FunctionDefinition,\n) -> (Quoted, Quoted, Quoted, Quoted, u32, Field) {\n    let fn_name = f.name();\n    let fn_parameters = f.parameters();\n    let fn_parameters_list =\n        fn_parameters.map(|(name, typ): (Quoted, Type)| quote { $name: $typ }).join(quote {,});\n\n    // Example of what the fold(...) below will generate for `target_address` and `fee_juice_limit_per_tx` function\n    // parameters:\n    // ```\n    // let mut serialized_args =  &[];\n    // serialized_args = serialized_args.append(aztec::protocol_types::traits::Serialize::serialize(target_address));\n    // serialized_args = serialized_args.push_back(fee_juice_limit_per_tx as Field);\n    // ```\n    let serialized_args_slice_construction = fn_parameters.fold(\n        quote {\n            let mut $SERIALIZED_ARGS_SLICE_NAME = &[];\n        },\n        |args, param: (Quoted, Type)| {\n            let (name, typ) = param;\n            let arg_to_append = add_to_field_slice(SERIALIZED_ARGS_SLICE_NAME, name, typ);\n            quote {\n                $args\n                $arg_to_append\n            }\n        },\n    );\n\n    let (fn_name_str, _) = fn_name.as_str_quote();\n    let fn_name_len: u32 = unquote!(quote { $fn_name_str.as_bytes().len()});\n    let fn_selector: Field = compute_fn_selector(f);\n\n    (\n        fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len,\n        fn_selector,\n    )\n}\n\ncomptime fn create_private_stub(f: FunctionDefinition) -> Quoted {\n    let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n        create_stub_base(f);\n    let fn_return_type = f.return_type();\n\n    quote {\n        pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PrivateCallInterface<$fn_name_len, $fn_return_type> {\n            $serialized_args_slice_construction\n            let selector = $FROM_FIELD($fn_selector);\n            dep::aztec::context::call_interfaces::PrivateCallInterface::new(\n                self.target_contract,\n                selector,\n                $fn_name_str,\n                $SERIALIZED_ARGS_SLICE_NAME,\n                false\n            )\n        }\n    }\n}\n\ncomptime fn create_private_static_stub(f: FunctionDefinition) -> Quoted {\n    let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n        create_stub_base(f);\n    let fn_return_type = f.return_type();\n\n    quote {\n        pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PrivateStaticCallInterface<$fn_name_len, $fn_return_type> {\n            $serialized_args_slice_construction\n            let selector = $FROM_FIELD($fn_selector);\n            dep::aztec::context::call_interfaces::PrivateStaticCallInterface::new(\n                self.target_contract,\n                selector,\n                $fn_name_str,\n                $SERIALIZED_ARGS_SLICE_NAME,\n            )\n        }\n    }\n}\n\ncomptime fn create_private_void_stub(f: FunctionDefinition) -> Quoted {\n    let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n        create_stub_base(f);\n\n    quote {\n        pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PrivateVoidCallInterface<$fn_name_len> {\n            $serialized_args_slice_construction\n            let selector = $FROM_FIELD($fn_selector);\n            dep::aztec::context::call_interfaces::PrivateVoidCallInterface::new(\n                self.target_contract,\n                selector,\n                $fn_name_str,\n                $SERIALIZED_ARGS_SLICE_NAME,\n                false\n            )\n        }\n    }\n}\n\ncomptime fn create_private_static_void_stub(f: FunctionDefinition) -> Quoted {\n    let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n        create_stub_base(f);\n\n    quote {\n        pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PrivateStaticVoidCallInterface<$fn_name_len> {\n            $serialized_args_slice_construction\n            let selector = $FROM_FIELD($fn_selector);\n            dep::aztec::context::call_interfaces::PrivateStaticVoidCallInterface::new(\n                self.target_contract,\n                selector,\n                $fn_name_str,\n                serialized_args\n            )\n        }\n    }\n}\n\ncomptime fn create_public_stub(f: FunctionDefinition) -> Quoted {\n    let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n        create_stub_base(f);\n    let fn_return_type = f.return_type();\n\n    quote {\n        pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PublicCallInterface<$fn_name_len, $fn_return_type> {\n            $serialized_args_slice_construction\n            let selector = $FROM_FIELD($fn_selector);\n            dep::aztec::context::call_interfaces::PublicCallInterface::new(\n                self.target_contract,\n                selector,\n                $fn_name_str,\n                $SERIALIZED_ARGS_SLICE_NAME,\n                false\n            )\n        }\n    }\n}\n\ncomptime fn create_public_static_stub(f: FunctionDefinition) -> Quoted {\n    let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n        create_stub_base(f);\n    let fn_return_type = f.return_type();\n\n    quote {\n        pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PublicStaticCallInterface<$fn_name_len, $fn_return_type> {\n            $serialized_args_slice_construction\n            let selector = $FROM_FIELD($fn_selector);\n            dep::aztec::context::call_interfaces::PublicStaticCallInterface::new(\n                self.target_contract,\n                selector,\n                $fn_name_str,\n                $SERIALIZED_ARGS_SLICE_NAME,\n            )\n        }\n    }\n}\n\ncomptime fn create_public_void_stub(f: FunctionDefinition) -> Quoted {\n    let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n        create_stub_base(f);\n\n    quote {\n        pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PublicVoidCallInterface<$fn_name_len> {\n            $serialized_args_slice_construction\n            let selector = $FROM_FIELD($fn_selector);\n            dep::aztec::context::call_interfaces::PublicVoidCallInterface::new(\n                self.target_contract,\n                selector,\n                $fn_name_str,\n                $SERIALIZED_ARGS_SLICE_NAME,\n                false\n            )\n        }\n    }\n}\n\ncomptime fn create_public_static_void_stub(f: FunctionDefinition) -> Quoted {\n    let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n        create_stub_base(f);\n\n    quote {\n        pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PublicStaticVoidCallInterface<$fn_name_len> {\n            $serialized_args_slice_construction\n            let selector = $FROM_FIELD($fn_selector);\n            dep::aztec::context::call_interfaces::PublicStaticVoidCallInterface::new(\n                self.target_contract,\n                selector,\n                $fn_name_str,\n                serialized_args\n            )\n        }\n    }\n}\n"
+      "source": "use crate::macros::utils::{\n    add_to_field_slice, AsStrQuote, compute_fn_selector, is_fn_private, is_fn_public, is_fn_view,\n};\nuse std::meta::{type_of, unquote};\n\ncomptime global FROM_FIELD: TypedExpr = {\n    let from_field_trait = quote { protocol_types::traits::FromField }.as_trait_constraint();\n    let function_selector_typ =\n        quote { protocol_types::abis::function_selector::FunctionSelector }.as_type();\n    function_selector_typ.get_trait_impl(from_field_trait).unwrap().methods().filter(|m| {\n        m.name() == quote { from_field }\n    })[0]\n        .as_typed_expr()\n};\n\ncomptime global SERIALIZED_ARGS_SLICE_NAME: Quoted = quote { serialized_args };\n\npub comptime fn stub_fn(f: FunctionDefinition) -> Quoted {\n    let is_static_call = is_fn_view(f);\n    let is_void = f.return_type() == type_of(());\n\n    if is_fn_private(f) {\n        if is_static_call {\n            if is_void {\n                create_private_static_void_stub(f)\n            } else {\n                create_private_static_stub(f)\n            }\n        } else {\n            if is_void {\n                create_private_void_stub(f)\n            } else {\n                create_private_stub(f)\n            }\n        }\n    } else if is_fn_public(f) {\n        if is_static_call {\n            if is_void {\n                create_public_static_void_stub(f)\n            } else {\n                create_public_static_stub(f)\n            }\n        } else {\n            if is_void {\n                create_public_void_stub(f)\n            } else {\n                create_public_stub(f)\n            }\n        }\n    } else {\n        if is_void {\n            create_utility_void_stub(f)\n        } else {\n            create_utility_stub(f)\n        }\n    }\n}\n\n/// Utility function creating stubs used by all the stub functions in this file.\ncomptime fn create_stub_base(\n    f: FunctionDefinition,\n) -> (Quoted, Quoted, Quoted, Quoted, u32, Field) {\n    let fn_name = f.name();\n    let fn_parameters = f.parameters();\n    let fn_parameters_list =\n        fn_parameters.map(|(name, typ): (Quoted, Type)| quote { $name: $typ }).join(quote {,});\n\n    // Example of what the fold(...) below will generate for `target_address` and `fee_juice_limit_per_tx` function\n    // parameters:\n    // ```\n    // let mut serialized_args =  &[];\n    // serialized_args = serialized_args.append(aztec::protocol_types::traits::Serialize::serialize(target_address));\n    // serialized_args = serialized_args.push_back(fee_juice_limit_per_tx as Field);\n    // ```\n    let serialized_args_slice_construction = fn_parameters.fold(\n        quote {\n            let mut $SERIALIZED_ARGS_SLICE_NAME = &[];\n        },\n        |args, param: (Quoted, Type)| {\n            let (name, typ) = param;\n            let arg_to_append = add_to_field_slice(SERIALIZED_ARGS_SLICE_NAME, name, typ);\n            quote {\n                $args\n                $arg_to_append\n            }\n        },\n    );\n\n    let (fn_name_str, _) = fn_name.as_str_quote();\n    let fn_name_len: u32 = unquote!(quote { $fn_name_str.as_bytes().len()});\n    let fn_selector: Field = compute_fn_selector(f);\n\n    (\n        fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len,\n        fn_selector,\n    )\n}\n\ncomptime fn create_private_stub(f: FunctionDefinition) -> Quoted {\n    let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n        create_stub_base(f);\n    let fn_return_type = f.return_type();\n\n    quote {\n        pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PrivateCallInterface<$fn_name_len, $fn_return_type> {\n            $serialized_args_slice_construction\n            let selector = $FROM_FIELD($fn_selector);\n            dep::aztec::context::call_interfaces::PrivateCallInterface::new(\n                self.target_contract,\n                selector,\n                $fn_name_str,\n                $SERIALIZED_ARGS_SLICE_NAME,\n                false\n            )\n        }\n    }\n}\n\ncomptime fn create_private_static_stub(f: FunctionDefinition) -> Quoted {\n    let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n        create_stub_base(f);\n    let fn_return_type = f.return_type();\n\n    quote {\n        pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PrivateStaticCallInterface<$fn_name_len, $fn_return_type> {\n            $serialized_args_slice_construction\n            let selector = $FROM_FIELD($fn_selector);\n            dep::aztec::context::call_interfaces::PrivateStaticCallInterface::new(\n                self.target_contract,\n                selector,\n                $fn_name_str,\n                $SERIALIZED_ARGS_SLICE_NAME,\n            )\n        }\n    }\n}\n\ncomptime fn create_private_void_stub(f: FunctionDefinition) -> Quoted {\n    let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n        create_stub_base(f);\n\n    quote {\n        pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PrivateVoidCallInterface<$fn_name_len> {\n            $serialized_args_slice_construction\n            let selector = $FROM_FIELD($fn_selector);\n            dep::aztec::context::call_interfaces::PrivateVoidCallInterface::new(\n                self.target_contract,\n                selector,\n                $fn_name_str,\n                $SERIALIZED_ARGS_SLICE_NAME,\n                false\n            )\n        }\n    }\n}\n\ncomptime fn create_private_static_void_stub(f: FunctionDefinition) -> Quoted {\n    let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n        create_stub_base(f);\n\n    quote {\n        pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PrivateStaticVoidCallInterface<$fn_name_len> {\n            $serialized_args_slice_construction\n            let selector = $FROM_FIELD($fn_selector);\n            dep::aztec::context::call_interfaces::PrivateStaticVoidCallInterface::new(\n                self.target_contract,\n                selector,\n                $fn_name_str,\n                serialized_args\n            )\n        }\n    }\n}\n\ncomptime fn create_public_stub(f: FunctionDefinition) -> Quoted {\n    let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n        create_stub_base(f);\n    let fn_return_type = f.return_type();\n\n    quote {\n        pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PublicCallInterface<$fn_name_len, $fn_return_type> {\n            $serialized_args_slice_construction\n            let selector = $FROM_FIELD($fn_selector);\n            dep::aztec::context::call_interfaces::PublicCallInterface::new(\n                self.target_contract,\n                selector,\n                $fn_name_str,\n                $SERIALIZED_ARGS_SLICE_NAME,\n                false\n            )\n        }\n    }\n}\n\ncomptime fn create_public_static_stub(f: FunctionDefinition) -> Quoted {\n    let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n        create_stub_base(f);\n    let fn_return_type = f.return_type();\n\n    quote {\n        pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PublicStaticCallInterface<$fn_name_len, $fn_return_type> {\n            $serialized_args_slice_construction\n            let selector = $FROM_FIELD($fn_selector);\n            dep::aztec::context::call_interfaces::PublicStaticCallInterface::new(\n                self.target_contract,\n                selector,\n                $fn_name_str,\n                $SERIALIZED_ARGS_SLICE_NAME,\n            )\n        }\n    }\n}\n\ncomptime fn create_public_void_stub(f: FunctionDefinition) -> Quoted {\n    let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n        create_stub_base(f);\n\n    quote {\n        pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PublicVoidCallInterface<$fn_name_len> {\n            $serialized_args_slice_construction\n            let selector = $FROM_FIELD($fn_selector);\n            dep::aztec::context::call_interfaces::PublicVoidCallInterface::new(\n                self.target_contract,\n                selector,\n                $fn_name_str,\n                $SERIALIZED_ARGS_SLICE_NAME,\n                false\n            )\n        }\n    }\n}\n\ncomptime fn create_public_static_void_stub(f: FunctionDefinition) -> Quoted {\n    let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n        create_stub_base(f);\n\n    quote {\n        pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PublicStaticVoidCallInterface<$fn_name_len> {\n            $serialized_args_slice_construction\n            let selector = $FROM_FIELD($fn_selector);\n            dep::aztec::context::call_interfaces::PublicStaticVoidCallInterface::new(\n                self.target_contract,\n                selector,\n                $fn_name_str,\n                serialized_args\n            )\n        }\n    }\n}\n\ncomptime fn create_utility_stub(f: FunctionDefinition) -> Quoted {\n    let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n        create_stub_base(f);\n    let fn_return_type = f.return_type();\n\n    // This is here because utility function call interfaces can only be used within TXe tests.\n    let modified_fn_name = f\"_experimental_{fn_name}\".quoted_contents();\n\n    quote {\n        pub fn $modified_fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::UtilityCallInterface<$fn_name_len, $fn_return_type> {\n            $serialized_args_slice_construction\n            let selector = $FROM_FIELD($fn_selector);\n            dep::aztec::context::call_interfaces::UtilityCallInterface::new(\n                self.target_contract,\n                selector,\n                $fn_name_str,\n                $SERIALIZED_ARGS_SLICE_NAME,\n            )\n        }\n    }\n}\n\ncomptime fn create_utility_void_stub(f: FunctionDefinition) -> Quoted {\n    let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n        create_stub_base(f);\n\n    // This is here because utility function call interfaces can only be used within TXe tests.\n    let modified_fn_name = f\"_experimental_{fn_name}\".quoted_contents();\n\n    quote {\n        pub fn $modified_fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::UtilityVoidCallInterface<$fn_name_len> {\n            $serialized_args_slice_construction\n            let selector = $FROM_FIELD($fn_selector);\n            dep::aztec::context::call_interfaces::UtilityVoidCallInterface::new(\n                self.target_contract,\n                selector,\n                $fn_name_str,\n                $SERIALIZED_ARGS_SLICE_NAME,\n            )\n        }\n    }\n}\n"
     },
     "95": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr",
-      "source": "use crate::macros::{\n    functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n    notes::NOTES,\n    utils::{\n        add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_contract_library_method,\n        is_fn_initializer, is_fn_internal, is_fn_private, is_fn_public, is_fn_test, is_fn_utility,\n        is_fn_view, modify_fn_body, module_has_initializer, module_has_storage,\n    },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n    // Private Kernel Circuit.\n    // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n    // about the execution context (e.g. the caller).\n    let original_params = f.parameters();\n    f.set_parameters(&[(\n        quote { inputs },\n        quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n    )]\n        .append(original_params));\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    // TODO: Optimize args_hasher for small number of arguments\n    let args_hasher_name = quote { args_hasher };\n    let args_hasher = original_params.fold(\n        quote {\n            let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n        },\n        |args_hasher, param: (Quoted, Type)| {\n            let (name, typ) = param;\n            let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n            quote {\n                $args_hasher\n                $appended_arg\n            }\n        },\n    );\n\n    let context_creation = quote {\n        let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    // All private functions perform message discovery, since they may need to access notes. This is slightly\n    // inefficient and could be improved by only doing it once we actually attempt to read any.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n    // circuit expects.\n    let return_value_var_name = quote { macro__returned__values };\n\n    let return_value_type = f.return_type();\n    let return_value = if body.len() == 0 {\n        quote {}\n    } else if return_value_type != type_of(()) {\n        // The original return value is passed to a second args hasher which the context receives.\n        let (body_without_return, last_body_expr) = body.pop_back();\n        let return_value = last_body_expr.quoted();\n        let return_value_assignment =\n            quote { let $return_value_var_name: $return_value_type = $return_value; };\n        let return_hasher_name = quote { return_hasher };\n        let return_value_into_hasher =\n            add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n        body = body_without_return;\n\n        quote {\n            let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n            $return_value_assignment\n            $return_value_into_hasher\n            context.set_return_hash($return_hasher_name);\n        }\n    } else {\n        let (body_without_return, last_body_expr) = body.pop_back();\n        if !last_body_expr.has_semicolon()\n            & last_body_expr.as_for().is_none()\n            & last_body_expr.as_assert().is_none()\n            & last_body_expr.as_for_range().is_none()\n            & last_body_expr.as_assert_eq().is_none()\n            & last_body_expr.as_let().is_none() {\n            let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n            body = body_without_return.push_back(\n                quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n            );\n        }\n        quote {}\n    };\n\n    let context_finish = quote { context.finish() };\n\n    let to_prepend = quote {\n        $args_hasher\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n        $message_discovery_call\n    };\n\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $context_finish\n    };\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n    f.set_return_type(\n        quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n            .as_type(),\n    );\n    f.set_return_data();\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Public functions undergo a lot of transformations from their Aztec.nr form.\n    let original_params = f.parameters();\n    let args_len = original_params\n        .map(|(name, typ): (Quoted, Type)| {\n            generate_serialize_to_fields(name, typ, false).0.len()\n        })\n        .fold(0, |acc: u32, val: u32| acc + val);\n\n    // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n    let context_creation = quote {\n        let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n        // We start from 1 because we skip the selector for the dispatch function.\n        let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n        dep::aztec::hash::hash_args_array(serialized_args)\n        });\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n        // referenced. We instead ignore 'unused variable' warnings for it.\n        quote {\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n    };\n\n    let to_append = quote {\n        $mark_as_initialized\n    };\n\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n\n    // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n    // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n    // bytecode.\n    f.set_unconstrained(true);\n    f.set_return_public(true);\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_utility(f: FunctionDefinition) {\n    // Check if function is marked as unconstrained\n    if !f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[utility] but not marked as unconstrained, add unconstrained keyword\",\n        );\n    }\n\n    // Create utility context\n    let context_creation =\n        quote { let mut context = dep::aztec::context::utility_context::UtilityContext::new(); };\n    let module_has_storage = module_has_storage(f.module());\n\n    // Initialize Storage if module has storage\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(context);\n        }\n    } else {\n        quote {}\n    };\n\n    // All utility functions perform message discovery, since they may need to access private notes that would be\n    // found during this process. This is slightly inefficient and could be improved by only doing it once we actually\n    // attempt to read any.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Inject context creation, storage initialization, and message discovery call at the beginning of the function\n    // body.\n    let to_prepend = quote {\n        $context_creation\n        $storage_init\n        $message_discovery_call\n    };\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, quote {});\n    f.set_body(modified_body);\n\n    f.set_return_public(true);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called internally\";\n    quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called statically\";\n    if is_fn_private(f) {\n        // Here `context` is of type context::PrivateContext\n        quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n    } else {\n        // Here `context` is of type context::PublicContext\n        quote { assert(context.is_static_call(), $assertion_message); }\n    }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\n/// Injects a call to `aztec::messages::discovery::discover_new_messages`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_message_discovery_call() -> Quoted {\n    quote {\n        /// Safety: message discovery returns nothing and is performed solely for its side-effects. It is therefore\n        /// always safe to call.\n        unsafe {\n            dep::aztec::messages::discovery::discover_new_messages(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\n            );\n        };\n    }\n}\n\n/// Checks if each function in the module is marked with either #[private], #[public], #[utility],\n/// #[contract_library_method], or #[test]. Non-macroified functions are not allowed in contracts.\npub(crate) comptime fn check_each_fn_macroified(m: Module) {\n    for f in m.functions() {\n        let name = f.name();\n        if !is_fn_private(f)\n            & !is_fn_public(f)\n            & !is_fn_utility(f)\n            & !is_fn_contract_library_method(f)\n            & !is_fn_test(f) {\n            panic(\n                f\"Function {name} must be marked as either #[private], #[public], #[utility], #[contract_library_method], or #[test]\",\n            );\n        }\n    }\n}\n"
+      "source": "use crate::macros::{\n    functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n    notes::NOTES,\n    utils::{\n        add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_contract_library_method,\n        is_fn_initializer, is_fn_internal, is_fn_private, is_fn_public, is_fn_test, is_fn_utility,\n        is_fn_view, modify_fn_body, module_has_initializer, module_has_storage,\n    },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n    // Private Kernel Circuit.\n    // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n    // about the execution context (e.g. the caller).\n    let original_params = f.parameters();\n    f.set_parameters(&[(\n        quote { inputs },\n        quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n    )]\n        .append(original_params));\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    // TODO: Optimize args_hasher for small number of arguments\n    let args_hasher_name = quote { args_hasher };\n    let args_hasher = original_params.fold(\n        quote {\n            let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n        },\n        |args_hasher, param: (Quoted, Type)| {\n            let (name, typ) = param;\n            let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n            quote {\n                $args_hasher\n                $appended_arg\n            }\n        },\n    );\n\n    let context_creation = quote {\n        let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    // All private functions perform message discovery, since they may need to access notes. This is slightly\n    // inefficient and could be improved by only doing it once we actually attempt to read any.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n    // circuit expects.\n    let return_value_var_name = quote { macro__returned__values };\n\n    let return_value_type = f.return_type();\n    let return_value = if body.len() == 0 {\n        quote {}\n    } else if return_value_type != type_of(()) {\n        // The original return value is passed to a second args hasher which the context receives.\n        let (body_without_return, last_body_expr) = body.pop_back();\n        let return_value = last_body_expr.quoted();\n        let return_value_assignment =\n            quote { let $return_value_var_name: $return_value_type = $return_value; };\n        let return_hasher_name = quote { return_hasher };\n        let return_value_into_hasher =\n            add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n        body = body_without_return;\n\n        quote {\n            let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n            $return_value_assignment\n            $return_value_into_hasher\n            context.set_return_hash($return_hasher_name);\n        }\n    } else {\n        let (body_without_return, last_body_expr) = body.pop_back();\n        if !last_body_expr.has_semicolon()\n            & last_body_expr.as_for().is_none()\n            & last_body_expr.as_assert().is_none()\n            & last_body_expr.as_for_range().is_none()\n            & last_body_expr.as_assert_eq().is_none()\n            & last_body_expr.as_let().is_none() {\n            let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n            body = body_without_return.push_back(\n                quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n            );\n        }\n        quote {}\n    };\n\n    let context_finish = quote { context.finish() };\n\n    let to_prepend = quote {\n        $args_hasher\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n        $message_discovery_call\n    };\n\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $context_finish\n    };\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n    f.set_return_type(\n        quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n            .as_type(),\n    );\n    f.set_return_data();\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Public functions undergo a lot of transformations from their Aztec.nr form.\n    let original_params = f.parameters();\n    let args_len = original_params\n        .map(|(name, typ): (Quoted, Type)| {\n            generate_serialize_to_fields(name, typ, false).0.len()\n        })\n        .fold(0, |acc: u32, val: u32| acc + val);\n\n    // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n    let context_creation = quote {\n        let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n        // We start from 1 because we skip the selector for the dispatch function.\n        let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n        dep::aztec::hash::hash_args_array(serialized_args)\n        });\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n        // referenced. We instead ignore 'unused variable' warnings for it.\n        quote {\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n    };\n\n    let to_append = quote {\n        $mark_as_initialized\n    };\n\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n\n    // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n    // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n    // bytecode.\n    f.set_unconstrained(true);\n    f.set_return_public(true);\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_utility(f: FunctionDefinition) -> 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    // 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    fn_abi\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called internally\";\n    quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called statically\";\n    if is_fn_private(f) {\n        // Here `context` is of type context::PrivateContext\n        quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n    } else {\n        // Here `context` is of type context::PublicContext\n        quote { assert(context.is_static_call(), $assertion_message); }\n    }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\n/// Injects a call to `aztec::messages::discovery::discover_new_messages`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_message_discovery_call() -> Quoted {\n    quote {\n        /// Safety: message discovery returns nothing and is performed solely for its side-effects. It is therefore\n        /// always safe to call.\n        unsafe {\n            dep::aztec::messages::discovery::discover_new_messages(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\n            );\n        };\n    }\n}\n\n/// Checks if each function in the module is marked with either #[private], #[public], #[utility],\n/// #[contract_library_method], or #[test]. Non-macroified functions are not allowed in contracts.\npub(crate) comptime fn check_each_fn_macroified(m: Module) {\n    for f in m.functions() {\n        let name = f.name();\n        if !is_fn_private(f)\n            & !is_fn_public(f)\n            & !is_fn_utility(f)\n            & !is_fn_contract_library_method(f)\n            & !is_fn_test(f) {\n            panic(\n                f\"Function {name} must be marked as either #[private], #[public], #[utility], #[contract_library_method], or #[test]\",\n            );\n        }\n    }\n}\n"
     },
     "98": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/storage.nr",
-      "source": "use poseidon::poseidon2::Poseidon2Hasher;\nuse std::{collections::umap::UHashMap, hash::BuildHasherDefault};\n\nuse super::utils::AsStrQuote;\nuse super::utils::get_storage_size;\nuse super::utils::is_note;\n\n/// Stores a map from a module to the name of the struct that describes its storage layout.\n/// This is then used when generating a `storage_layout()` getter on the contract struct.\npub comptime mut global STORAGE_LAYOUT_NAME: UHashMap<Module, Quoted, BuildHasherDefault<Poseidon2Hasher>> =\n    UHashMap::default();\n\n/// Marks a struct as the one describing the storage layout of a contract. Only a single struct in the entire contract\n/// should have this macro (or `storage_no_init`) applied to it.\n/// The contract's storage is accessed via the `storage` variable, which will will automatically be made available in\n/// all functions as an instance of the struct this macro was applied to.\npub comptime fn storage(s: TypeDefinition) -> Quoted {\n    // This macro performs three things:\n    //  - it marks the contract as having storage, so that `macros::utils::module_has_storage` will return true and\n    //    functions will have the storage variable injected and initialized via the `init` function.\n    //  - it implements said `init` function by allocating appropriate storage slots to each state variable.\n    //  - it exposes the storage layout by creating a `StorageLayout` struct that is exposed via the `abi(storage)`\n    //    macro.\n    let mut slot: u32 = 1;\n    let mut storage_vars_constructors = &[];\n    let mut storage_layout_fields = &[];\n    let mut storage_layout_constructors = &[];\n\n    // TODO(#8658): uncomment the code below to inject the Context type parameter.\n    //let mut new_storage_fields = &[];\n    //let context_generic = s.add_generic(\"Context\");\n    for field in s.fields_as_written() {\n        // FIXME: This doesn't handle field types with generics\n        let (name, typ) = field;\n        let (storage_field_constructor, storage_size) =\n            generate_storage_field_constructor(typ, quote { $slot }, false);\n        storage_vars_constructors =\n            storage_vars_constructors.push_back(quote { $name: $storage_field_constructor });\n        // We have `Storable` in a separate `.nr` file instead of defining it in the last quote of this function\n        // because that way a dev gets a more reasonable error if he defines a struct with the same name in\n        // a contract.\n        storage_layout_fields =\n            storage_layout_fields.push_back(quote { pub $name: dep::aztec::prelude::Storable });\n        storage_layout_constructors = storage_layout_constructors.push_back(\n            quote { $name: dep::aztec::prelude::Storable { slot: $slot } },\n        );\n        //let with_context_generic = add_context_generic(typ, context_generic);\n        //println(with_context_generic);\n        //new_storage_fields = new_storage_fields.push_back((name,  with_context_generic ));\n        slot += storage_size;\n    }\n\n    //s.set_fields(new_storage_fields);\n    let storage_vars_constructors = storage_vars_constructors.join(quote {,});\n    let storage_impl = quote {\n        impl<Context> Storage<Context> {\n            fn init(context: Context) -> Self {\n                Self {\n                    $storage_vars_constructors\n                }\n            }\n        }\n    };\n\n    let storage_layout_fields = storage_layout_fields.join(quote {,});\n    let storage_layout_constructors = storage_layout_constructors.join(quote {,});\n\n    let module = s.module();\n    let module_name = module.name();\n    let storage_layout_name = f\"STORAGE_LAYOUT_{module_name}\".quoted_contents();\n    let (module_name_str, module_name_len) = module_name.as_str_quote();\n    STORAGE_LAYOUT_NAME.insert(module, storage_layout_name);\n\n    quote {\n        $storage_impl\n\n        pub struct StorageLayoutFields {\n            $storage_layout_fields\n        }\n\n        pub struct StorageLayout<let N: u32> {\n            pub contract_name: str<N>,\n            pub fields: StorageLayoutFields\n        }\n\n        #[abi(storage)]\n        pub global $storage_layout_name: StorageLayout<$module_name_len> = StorageLayout {\n            contract_name: $module_name_str,\n            fields: StorageLayoutFields { $storage_layout_constructors }\n        };\n    }\n}\n\n/// Same as `storage`, except the user is in charge of providing an implementation of the `init` constructor function\n/// with signature `fn init<Context>(context: Context) -> Self`, which allows for manual control of storage slot\n/// allocation. Similarly, no `StorageLayout` struct will be created.\n/// Only a single struct in the entire contract should have this macro (or `storage`) applied to it.\npub comptime fn storage_no_init(_s: TypeDefinition) {\n    // All `storage` does is provide the `init` implementation, so we don't need to do anything here. Applying this\n    // macro however will cause for `macros::utils::module_has_storage` to return true, resulting in the injection of\n    // the `storage` variable.\n}\n\n/// Returns the expression required to initialize a state variable with a given slot, along with its serialization size,\n/// i.e. how many contiguous storage slots the variable requires.\ncomptime fn generate_storage_field_constructor(\n    typ: Type,\n    slot: Quoted,\n    parent_is_map: bool,\n) -> (Quoted, u32) {\n    assert(\n        typ.as_data_type().is_some(),\n        \"Storage containers must be generic structs of the form `Container<_, Context>`, or Map<Key, _, Context>\",\n    );\n    let (container_struct, generics) = typ.as_data_type().unwrap();\n    let struct_name = container_struct.name();\n\n    if is_storage_map(typ) {\n        // Map state variables recursively initialize their contents - this includes nested maps.\n        let (value_constructor, _) =\n            generate_storage_field_constructor(generics[1], quote { slot }, true);\n        (quote { $struct_name::new(context, $slot, | context, slot | { $value_constructor }) }, 1)\n    } else {\n        let storage_size = if parent_is_map {\n            // Variables inside a map do not require contiguous slots since the map slot derivation is assumed to result\n            // in slots very far away from one another.\n            1\n        } else {\n            let (_, container_struct_generics) = typ.as_data_type().unwrap();\n            let stored_struct = container_struct_generics[0];\n\n            if is_note(stored_struct) {\n                // Private notes always occupy a single slot, since the slot is only used as a state variable\n                // identifier.\n                1\n            } else {\n                get_storage_size(typ)\n            }\n        };\n\n        // We assume below that all state variables implement `fn new<Context>(context: Context, slot: Field) -> Self`.\n        (quote { $struct_name::new(context, $slot)}, storage_size)\n    }\n}\n\n/// Returns true if `typ` is `state_vars::map::Map`.\ncomptime fn is_storage_map(typ: Type) -> bool {\n    if typ.as_data_type().is_some() {\n        let (def, generics) = typ.as_data_type().unwrap();\n        let maybe_map = if (def.name() == quote { Map }) & (generics.len() == 3) {\n            let maybe_key = generics[0];\n            let maybe_value = generics[1];\n            let maybe_context = generics[2];\n            quote { crate::state_vars::map::Map<$maybe_key, $maybe_value, $maybe_context> }.as_type()\n        } else {\n            quote {()}.as_type()\n        };\n        typ == maybe_map\n    } else {\n        false\n    }\n}\n\ncomptime fn add_context_generic(typ: Type, context_generic: Type) -> Type {\n    let (def, mut generics) = typ.as_data_type().expect(\n        f\"Storage containers must be generic structs of the form `Container<..., Context>`\",\n    );\n    let name = def.name();\n\n    if is_storage_map(typ) {\n        generics[generics.len() - 2] = add_context_generic(generics[1], context_generic);\n        generics[generics.len() - 1] = context_generic;\n    } else {\n        generics[generics.len() - 1] = context_generic;\n    }\n\n    let generics = generics.map(|typ: Type| quote {$typ}).join(quote {,});\n    quote { $name<$generics> }.as_type()\n}\n"
+      "source": "use poseidon::poseidon2::Poseidon2Hasher;\nuse std::{collections::umap::UHashMap, hash::BuildHasherDefault};\n\nuse super::utils::AsStrQuote;\nuse super::utils::get_storage_size;\n\n/// Stores a map from a module to the name of the struct that describes its storage layout.\n/// This is then used when generating a `storage_layout()` getter on the contract struct.\npub comptime mut global STORAGE_LAYOUT_NAME: UHashMap<Module, Quoted, BuildHasherDefault<Poseidon2Hasher>> =\n    UHashMap::default();\n\n/// Marks a struct as the one describing the storage layout of a contract.\n///\n/// The contract's storage is accessed via the `storage` variable, which will will automatically be made available in\n/// all functions as an instance of the struct this macro was applied to.\n///\n/// Only a single struct in the entire contract should have this macro (or `storage_no_init`) applied to it, and the\n/// struct has to be called 'Storage'.\npub comptime fn storage(s: TypeDefinition) -> Quoted {\n    let struct_name = s.name();\n    if struct_name != quote { Storage } {\n        panic(\n            f\"The #[storage] macro can only be applied to a struct with name 'Storage', got '{struct_name}' instead.\",\n        )\n    }\n\n    assert(\n        !s.has_named_attribute(\"storage_no_init\"),\n        f\"Only one of #[storage] and #[storage_no_init] can be applied to the Storage struct.\",\n    );\n\n    // This macro performs three things:\n    //  - it marks the contract as having storage, so that `macros::utils::module_has_storage` will return true and\n    //    functions will have the storage variable injected and initialized via the `init` function.\n    //  - it implements said `init` function by allocating appropriate storage slots to each state variable.\n    //  - it exposes the storage layout by creating a `StorageLayout` struct that is exposed via the `abi(storage)`\n    //    macro.\n    let mut slot: u32 = 1;\n    let mut storage_vars_constructors = &[];\n    let mut storage_layout_fields = &[];\n    let mut storage_layout_constructors = &[];\n\n    // TODO(#8658): uncomment the code below to inject the Context type parameter.\n    //let mut new_storage_fields = &[];\n    //let context_generic = s.add_generic(\"Context\");\n    for field in s.fields_as_written() {\n        // FIXME: This doesn't handle field types with generics\n        let (name, typ) = field;\n        let (storage_field_constructor, storage_size) =\n            generate_storage_field_constructor(typ, quote { $slot });\n        storage_vars_constructors =\n            storage_vars_constructors.push_back(quote { $name: $storage_field_constructor });\n        // We have `Storable` in a separate `.nr` file instead of defining it in the last quote of this function\n        // because that way a dev gets a more reasonable error if he defines a struct with the same name in\n        // a contract.\n        storage_layout_fields =\n            storage_layout_fields.push_back(quote { pub $name: dep::aztec::prelude::Storable });\n        storage_layout_constructors = storage_layout_constructors.push_back(\n            quote { $name: dep::aztec::prelude::Storable { slot: $slot } },\n        );\n        //let with_context_generic = add_context_generic(typ, context_generic);\n        //println(with_context_generic);\n        //new_storage_fields = new_storage_fields.push_back((name,  with_context_generic ));\n        slot += storage_size;\n    }\n\n    //s.set_fields(new_storage_fields);\n    let storage_vars_constructors = storage_vars_constructors.join(quote {,});\n    let storage_impl = quote {\n        impl<Context> Storage<Context> {\n            fn init(context: Context) -> Self {\n                Self {\n                    $storage_vars_constructors\n                }\n            }\n        }\n    };\n\n    let storage_layout_fields = storage_layout_fields.join(quote {,});\n    let storage_layout_constructors = storage_layout_constructors.join(quote {,});\n\n    let module = s.module();\n    let module_name = module.name();\n    let storage_layout_name = f\"STORAGE_LAYOUT_{module_name}\".quoted_contents();\n    let (module_name_str, module_name_len) = module_name.as_str_quote();\n    STORAGE_LAYOUT_NAME.insert(module, storage_layout_name);\n\n    quote {\n        $storage_impl\n\n        pub struct StorageLayoutFields {\n            $storage_layout_fields\n        }\n\n        pub struct StorageLayout<let N: u32> {\n            pub contract_name: str<N>,\n            pub fields: StorageLayoutFields\n        }\n\n        #[abi(storage)]\n        pub global $storage_layout_name: StorageLayout<$module_name_len> = StorageLayout {\n            contract_name: $module_name_str,\n            fields: StorageLayoutFields { $storage_layout_constructors }\n        };\n    }\n}\n\n/// Same as `storage`, except the user is in charge of providing an implementation of the `init` constructor function\n/// with signature `fn init<Context>(context: Context) -> Self`, which allows for manual control of storage slot\n/// allocation. Similarly, no `StorageLayout` struct will be created.\n///\n/// The contract's storage is accessed via the `storage` variable, which will will automatically be made available in\n/// all functions as an instance of the struct this macro was applied to.\n///\n/// Only a single struct in the entire contract can have this macro (or storage_no_init) applied to it, and the struct\n/// has to be called 'Storage'.\npub comptime fn storage_no_init(s: TypeDefinition) {\n    // All `storage` does is provide the `init` implementation, so we don't need to do anything here. Applying this\n    // macro however will cause for `macros::utils::module_has_storage` to return true, resulting in the injection of\n    // the `storage` variable.\n\n    // We do need to make sure that the type is called Storage, since we'll do `Storage::init` later on.\n\n    if s.name() != quote { Storage } {\n        let name = s.name();\n        panic(\n            f\"The #[storage_no_init] macro can only be applied to a struct with name 'Storage', got '{name}' instead.\",\n        )\n    }\n\n    assert(\n        !s.has_named_attribute(\"storage\"),\n        f\"Only one of #[storage] and #[storage_no_init] can be applied to the Storage struct.\",\n    );\n}\n\n/// Returns the expression required to initialize a state variable with a given slot, along with its serialization size,\n/// i.e. how many contiguous storage slots the variable requires.\ncomptime fn generate_storage_field_constructor(typ: Type, slot: Quoted) -> (Quoted, u32) {\n    assert(\n        typ.as_data_type().is_some(),\n        \"Storage containers must be generic structs of the form `Container<_, Context>`, or Map<Key, _, Context>\",\n    );\n    let (container_struct, generics) = typ.as_data_type().unwrap();\n    let struct_name = container_struct.name();\n\n    let constructor = if is_storage_map(typ) {\n        // Map state variables recursively initialize their contents - this includes nested maps.\n        let (value_constructor, _) =\n            generate_storage_field_constructor(generics[1], quote { slot });\n\n        quote { $struct_name::new(context, $slot, | context, slot | { $value_constructor }) }\n    } else {\n        // We assume below that all state variables implement `fn new<Context>(context: Context, slot: Field) -> Self`.\n        quote { $struct_name::new(context, $slot)}\n    };\n\n    (constructor, get_storage_size(typ))\n}\n\n/// Returns true if `typ` is `state_vars::map::Map`.\ncomptime fn is_storage_map(typ: Type) -> bool {\n    if typ.as_data_type().is_some() {\n        let (def, generics) = typ.as_data_type().unwrap();\n        let maybe_map = if (def.name() == quote { Map }) & (generics.len() == 3) {\n            let maybe_key = generics[0];\n            let maybe_value = generics[1];\n            let maybe_context = generics[2];\n            quote { crate::state_vars::map::Map<$maybe_key, $maybe_value, $maybe_context> }.as_type()\n        } else {\n            quote {()}.as_type()\n        };\n        typ == maybe_map\n    } else {\n        false\n    }\n}\n\ncomptime fn add_context_generic(typ: Type, context_generic: Type) -> Type {\n    let (def, mut generics) = typ.as_data_type().expect(\n        f\"Storage containers must be generic structs of the form `Container<..., Context>`\",\n    );\n    let name = def.name();\n\n    if is_storage_map(typ) {\n        generics[generics.len() - 2] = add_context_generic(generics[1], context_generic);\n        generics[generics.len() - 1] = context_generic;\n    } else {\n        generics[generics.len() - 1] = context_generic;\n    }\n\n    let generics = generics.map(|typ: Type| quote {$typ}).join(quote {,});\n    quote { $name<$generics> }.as_type()\n}\n"
     }
   }
 }