@aztec/protocol-contracts 0.77.0 → 0.77.1

package/artifacts/FeeJuice.json

@@ -4,66 +4,23 @@
   "name": "FeeJuice",
   "functions": [
     {
-      "name": "balance_of_public",
+      "name": "sync_notes",
       "is_unconstrained": true,
-      "custom_attributes": [
-        "public",
-        "view"
-      ],
+      "custom_attributes": [],
       "abi": {
         "error_types": {
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
-          },
-          "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"
-          },
-          "6067862452620309358": {
-            "error_kind": "string",
-            "string": "Function balance_of_public can only be called statically"
           }
         },
-        "parameters": [
-          {
-            "name": "owner",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": {
-          "abi_type": {
-            "kind": "integer",
-            "sign": "unsigned",
-            "width": 128
-          },
-          "visibility": "public"
-        }
+        "parameters": [],
+        "return_type": null
       },
-      "bytecode": "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",
-      "debug_symbols": "7Z3dbts8DIbvJcc9EEX97laGD0V/siJAkBRp+wFDsXufk9V2GgnxLApFMr0nQZyIJvVYNimJkt8Xj8v7t6fb1ebH9mXx7fv7Yr19uHtdbTfd0fuvm8X9brVer55uj39eqP0HKX0QeHm+2+yPX17vdq+Lb0TBuJvFcvN4+O5Cd5Ifq/WyO9Ld96S8V54/insV4lA6UKZw1Lo/d9TmU+H/bjqL/F9Y5NUni/ZypAvlCvVpWybHKifHZPWHGJOnQcrpDEFSjgcdxKMKl7s43fXrC8fxQjJ9mGMuy5x4UeaYy6JjLouOvSw6NlyUOU5fljn+oszx9NXm2N4crfQnczL+LBrb+7MYxzPrrEPj4cxGj897bTNFNUXTW6FJny9sBz9ptT8ueuDnwE/CLyjwE/Gz4CfhF9H+ZPzQ/iT8tEL7k/Ez4CfiF8BPwo8Y/ET8PPhJ+GkNfiJ+6L9N8nOq5+folB8jfpHxQ/ws4xfBb4rfUNZ9Lrrn53D/yvgZ8BPxw/0r4ufR/mT80P5E/ALan4wfxl9E/CL6vzJ+GH+R8GOF+XMZP4y/iPgR+m8yfhh/kfFD/JxC0ZgUykBBpJtCYYSvGSiICVIoBoFmBgq8dwYKXHIK5etz5K8BClxyCsXBJWegYJgohYK1EzkocMkpFKxyyEFBmJ9CwXqEHBQ8UxIoBisHMlB0m1A0j1CMPYXCbYb5nmJvhWcuLrwnaNrsE8whSG6snwuUEGyzA1GRoG3TCVYk2Giua02CBgSnCHo/7LfgY+KLG813rUjQtzm5WpMgfLGQYGhz5K8mQUQzUoLwJEKC0YCgkCDaoIygVYhmpAQRzQgJEqIZKUFEM1KC8CRCgo0mHdckCE8iJNhoOnNNgm0mRcwiGKmHQVEnBL9+r+h/jmCF+WIKoddwPCOdJ2jtsFm7837co4k4R8U73yMMZizr3cF4y9ds/DWTd+6Kjf+LXM7AU8ZzHJ4a7rOKjDndbdbbY93Euxo8m8F4Du584c4OowZD2PNx8UNd/ZfXlce6HsHPm++orys5Hgsz/7lSQV+19dfM3jW6WpvVYAWTOXGXrtHhkwkoaCkpFG0AJYXS5sjPeSiMlpKBgpaSQjFtDvvpqAcoyk50d9XQN+6qGhKCbQ77VSRo24yAZhEkHutnKSHYZrhUkWCjqak1CbbpXisSbDQ1dR5BZ4f6hcSTNJqSNYugUcPonlFJG4xtLvaqR9CrNicxaxJENCMk2Oi2jrMIWj3Uz1qVEGwzJasiwVbXUlckCF8sJMiIqKUE0asTEjSIZoQEMT4oJogxaiHBRrf1q0kQbVBIsNENA+cR9ENqqo06IYhoRkiw0Rc2VSTY6CuHahKEJ5ERDI2+dqgmQYwPSgnCFwsJEsYHJwnyuFSJ+XSeJDS66LUmQfhiIUGGL5YShC+WEoQvFhJEHrWYIKIZIUGLNigliGhGSNAhmpESRDQjJYhoZprgsCMAsTudaQqNvoWpIsGAUX4pQfhiIcGIeFBKEH0SGcGIXH4pQeTyC1dDRDIgKCSI56CQYKN7t1QkiFz+E4IdFFI621PzwxZf3nAik89Ij6ZXFG2qx6oCGVMgE+bL5HNzz2860f3kS6TyOZiTUq5EKhTpCkW6YpGuWKKLFBVJlVwvoiJdVFSv/Iq3SSlTJBVKpFgXSfnZzxgyWe5R9S8ajTojM/+5RPm7+LweX2BbfkRsQibOlwk8n0GY/8ykOF+Pzt+3EzLzr6mmAj1UoCd/v0bbt+vodSpj58twgZ78S3fPy+TnoCdkCvTYAj35mbWj65ORyfv189fU+fkyvkBPUAUydr5MLLgX4vznASsukInzZcgUyBTo0QX10fPbDjMVyMxsB7+6o//vdqu7+/XypZPY//m2eXhdbTcfh68/n/t/7ner9Xr1dPu82z4sH992y9v19mH/30J9fHzvGvyNjnyI4LrD/abZ9OdwXxkdTfev67R2mn8D",
+      "bytecode": "H4sIAAAAAAAA/7WTyw7CIBBFqcUo0sTEx39MU0y7dOHafyCtLHVRN+766dZkJkyI0QVwEzJMgMNcHoXwKjBKESGCHDEqjAs2Xs7tjDnEqVbBvin5HRijvvhLWH+jkFnk4QPxM50/rJBzmTyfe6F913PTrF8J/z5y+af7y+l//8OzRq9bzCvh/8P4uvfXx/M2ij/SbJGc0ptoOwAqvkT+EvmhJBvn8w+Yb4Svj6KMqNO1tnaNdfZkh8H0dhfwP+KH/QbzqHp4zgQAAA==",
+      "debug_symbols": "ZY5bCoMwEEX3Mt9+GG0F3YoUiTqRQEhCHoUSsvdORGioP8O9w+FyEuy4xmORWhgP05xAmY0HaTS1lBtYnVRKHkv9hrYc1p+8t1yX6gN3ASbWj93QAOr9zMNIG0IqpNZRvvGEX/SDsR879PmVqb65k3xVeNmIqLdKLnws/nlaZzbco8NiXMnSndmz6Vqapekv",
       "brillig_names": [
-        "balance_of_public"
+        "sync_notes"
       ]
     },
     {
@@ -114,66 +71,11 @@
         "return_type": null
       },
       "bytecode": "JwACBAEoAAABBIBHJwAABAMnAgIEAScCAwQAHxgAAwACgEYdAIBGgEYGLgiARgABJQAAAEwlAAAAYigCAAEEgEcnAgIEADsNAAEAAigAgEMEAAMoAIBEBAAAKACARQQAASYlAAAD0x4CAAMJJwIEAAEKOAMEBSQCAAUAAACDJQAAA/weAgADAS0IAQUnAgYEAwAQAQYBJwMFBAEAKAUCBi0MBgctDgQHACgHAgctDgMHJwIDAAAtCAEEJwIGBAQAEAEGAScDBAQBACgEAgYtDAYHLQ4DBwAoBwIHLQ4DBwAoBwIHLQ4DBy0NBAYAKAYCBi0OBgQrAgAGAAAAAAAAAAACAAAAAAAAAAAtCAEHJwIIBAUAEAEIAScDBwQBACgHAggtDAgJLQ4DCQAoCQIJLQ4DCQAoCQIJLQ4DCQAoCQIJLQ4GCS0NBAYAKAYCBi0OBgQtCAEGAAABAgEtDgQGLQ0HBAAoBAIELQ4EBy0IAQQAAAECAS0OBwQtCAEHAAABAgEuCoBEAActCAEIAAABAgEnAgkBAC0OCQgnAgoEAi4IgEQAAiMAAAGqDDgCCgskAgALAAACbiMAAAG8LQ0IAgo4AgkFJAIABQAAAdYnAgoEADwJAQonAgIECi0IAAotDAYLLQwEDC0MBw0tDAgOABAAAgAlAAAEDi0EAAAtDQYCLQ0EBS0NBwotDgIGLQ4FBC0OCgcnAgIBAS0OAggBKAAFgEUABC0NBAIKOAIDBAo4BAkDJAIAAwAAAkElAAAFZi8MAAIAAxwMAwQGHAwEAgAcDAIDBgw4AwECCjgCCQEkAgABAAACbSUAAAV4JiQCAAsAAAJ7IwAAA8InAgwEAgw4AgwNJAIADQAAApIlAAAFigAoBQIMADgMAg0tDQ0LLQ0HDC0NCA0KOA0JDiQCAA4AAAK+JwIPBAA8CQEPCygADIBDAA0kAgANAAADTyMAAALTLQ0GDC0NBA0tDQcOLQ0IDycCEQQDDDgOERIkAgASAAAC+iUAAAWKLgQADIADKACABAQABCUAAAWcLgiABQAQACgQAhEAOBEOEi0OCxIBKAAOgEUACw44DgsMJAIADAAAAzolAAAGKi0OEAYtDg0ELQ4LBy0ODwgjAAADwicCDAQNLQgADS0MBg4tDAQPLQwHEC0MCBEAEAAMACUAAAQOLQQAAC0NBgwtDQQNLQ0IDi4EAAyAAygAgAQEAAQlAAAFnC4IgAUADwAoDwIQASgAEIBEABEtDgsRLQ4PBi0ODQQuCoBFAActDg4IIwAAA8IBKAACgEUACy0MCwIjAAABqigAgAQEeAANAAAAgASAAyQAgAMAAAP7KgEAAQX3ofOvpa3UyjwBAQImKgEAAQUsry1Jt6zm8jwBAQImJQAAA9MuCIBEAAUjAAAEHg0oAAWAQwAGJAIABgAABI4jAAAEMy0NAQUtDQIGLQ0DBy0NBAgnAgkEBC0IAQonAgsEBQAQAQsBJwMKBAEAKAYCCycCDAQEACgKAg0/DwALAA0tDQoGACgGAgYtDgYKLQ4FAS0OCgItDgcDLQ4IBCYtDQMGDDgFBgcBKAAFgEUABiQCAAcAAASsIwAABV0tDQEHLQ0CCC0NAwktDQQKJwIMBAQMOAUMDSQCAA0AAATTJQAABYoAKAgCDAA4DAUNLQ0NCycCDQQDDDgFDQ4kAgAOAAAE+CUAAAWKACgHAg0AOA0FDi0NDgwAOAsMDScCDAQEDDgFDA4kAgAOAAAFIiUAAAWKLgQACIADKACABAQABSUAAAWcLgiABQALACgLAgwAOAwFDi0ODQ4tDgcBLQ4LAi0OCQMtDgoEIwAABV0tDAYFIwAABB4qAQABBQLcbieAdhKdPAEBAiYqAQABBdN7FJoYxQChPAEBAiYqAQABBeidCf6hES0OPAEBAiYuAYADgAYLAIAGAAKAByQAgAcAAAW3IwAABcIuAIADgAUjAAAGKS4AAAGABQEAAAGABAABAQCAA4AEgAkuAIADgAouAIAFgAsLAIAKgAmADCQAgAwAAAYVLgGACoAILgKACIALAQCACgACgAoBAIALAAKACyMAAAXkKAGABQQAAQMAgAYAAoAGIwAABikmKgEAAQVFp8pxGUHkFTwBAQImLgAYyhjK",
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "check_balance"
       ]
     },
-    {
-      "name": "set_portal",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public"
-      ],
-      "abi": {
-        "error_types": {
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          },
-          "2236649814169388962": {
-            "error_kind": "string",
-            "string": "PublicImmutable already initialized"
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "6485997221020871071": {
-            "error_kind": "string",
-            "string": "call to assert_max_bit_size"
-          }
-        },
-        "parameters": [
-          {
-            "name": "portal_address",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": null
-      },
-      "bytecode": "JwACBAEoAAABBIBHJwAABAMnAgIEAScCAwQAHxgAAwACgEYuCIBGAAElAAAARSUAAABbKAIAAQSARycCAgQAOw0AAQACKACAQwQAAygAgEQEAAAoAIBFBAABJiUAAANZJwICAAIvDAACAAMcDAMEACwCAAUAAAAAAAAAAAAAAAAA//////////////////////////8OOAQFBiQCAAYAAACnJQAAA4InAgQAAAo4AwQFJAIABQAAAMInAgYEADwJAQYpAgADADuaygIvDAADAAUKOAUEBiQCAAYAAADjJQAAA5QoAgAFAN6tMAwABQADLQgBAycCBQQEABABBQEnAwMEAQAoAwIFLQwFBi0OBAYAKAYCBi0OBAYAKAYCBi0OBAYtDQMFACgFAgUtDgUDKwIABQAAAAAAAAAAAQAAAAAAAAAALQgBBicCBwQFABABBwEnAwYEAQAoBgIHLQwHCC0OBAgAKAgCCC0OBAgAKAgCCC0OBAgAKAgCCC0OBQgtDQMEACgEAgQtDgQDLQgBBAAAAQIBLQ4DBC0NBgMAKAMCAy0OAwYtCAEDAAABAgEtDgYDLQgBBQAAAQIBLgqARAAFLQgBBgAAAQIBJwIHAQAtDgcGLQ0FCC0NBgkKOAkHCiQCAAoAAAHyJwILBAA8CQELCygACIBDAAkkAgAJAAACgyMAAAIHLQ0ECC0NAwktDQUKLQ0GCycCDQQDDDgKDQ4kAgAOAAACLiUAAAOmLgQACIADKACABAQABCUAAAO4LgiABQAMACgMAg0AOA0KDi0OAQ4BKAAKgEUACA44CggNJAIADQAAAm4lAAAERi0ODAQtDgkDLQ4IBS0OCwYjAAAC9icCCAQJLQgACS0MBAotDAMLLQwFDC0MBg0AEAAIACUAAARYLQQAAC0NBAgtDQMJLQ0GCi4EAAiAAygAgAQEAAQlAAADuC4IgAUACwAoCwIMASgADIBEAA0tDgENLQ4LBC0OCQMuCoBFAAUtDgoGIwAAAvYtDQYICjgIBwkkAgAJAAADECcCCgQAPAkBCicCBwQILQgACC0MBAktDAMKLQwFCy0MBgwAEAAHACUAAARYLQQAAC0NAwQBKAAEgEUABS0NBQMwDAABAAInAgEAAzAMAAMAASYoAIAEBHgADQAAAIAEgAMkAIADAAADgSoBAAEF96Hzr6Wt1Mo8AQECJioBAAEFWgLkG7UeqZ88AQECJioBAAEFHwotJ9yCh6I8AQECJioBAAEF6J0J/qERLQ48AQECJi4BgAOABgsAgAYAAoAHJACABwAAA9MjAAAD3i4AgAOABSMAAARFLgAAAYAFAQAAAYAEAAEBAIADgASACS4AgAOACi4AgAWACwsAgAqACYAMJACADAAABDEuAYAKgAguAoAIgAsBAIAKAAKACgEAgAsAAoALIwAABAAoAYAFBAABAwCABgACgAYjAAAERSYqAQABBUWnynEZQeQVPAEBAiYlAAADWS4IgEQABSMAAARoDSgABYBDAAYkAgAGAAAE2CMAAAR9LQ0BBS0NAgYtDQMHLQ0ECCcCCQQELQgBCicCCwQFABABCwEnAwoEAQAoBgILJwIMBAQAKAoCDT8PAAsADS0NCgYAKAYCBi0OBgotDgUBLQ4KAi0OBwMtDggEJi0NAwYMOAUGBwEoAAWARQAGJAIABwAABPYjAAAFpy0NAQctDQIILQ0DCS0NBAonAgwEBAw4BQwNJAIADQAABR0lAAADpgAoCAIMADgMBQ0tDQ0LJwINBAMMOAUNDiQCAA4AAAVCJQAAA6YAKAcCDQA4DQUOLQ0ODAA4CwwNJwIMBAQMOAUMDiQCAA4AAAVsJQAAA6YuBAAIgAMoAIAEBAAFJQAAA7guCIAFAAsAKAsCDAA4DAUOLQ4NDi0OBwEtDgsCLQ4JAy0OCgQjAAAFpy0MBgUjAAAEaC4AGMoYyg==",
-      "debug_symbols": "7Z3bbuM4DIbfJde9EKlzX2WwKHrIFAGCpEjbBRbFvPs6QexkEjaORU1nBvpvirghTesLJdKUJX/MnuYP7893i9X39evs9tvHbLl+vH9brFfd0cePm9nDZrFcLp7vjv89M9s/OezkX1/uV9vD17f7zdvslmL0N7P56qn7mAx3Z/i+WM5nt6H7eCZsveO9sA3GD8IUvSBNnIZT2yNpNtK5o3dpLx19yIN0IknYutgL2xQuCxNZZ/oLIRvtsfg/NzMyBDKfkIl/OBl7IJPc5cbmw0UbYw5nDk46M+f+xIFHZImcHSCGNCLtYy/s8+G3pLTjTQzeX8nbZfD+St7egfdX8g4YT76W93i8JHfMe6sUuUSpxFLyBUrZlCjJHT3xQcmny47HmftMhrPnEcf7fUkSG9tQW3OFtubehDUnA8rWBLlfboL515uIahO2G4x6E12HGnGK1A2Ke+luTOcRp0imH8Vi8m7MKZzLg1O4bE6dwrp22uqMvq0cexOWj2OIHFHNoUea41gmR9Ts+guJOR+6L4uttT7shR0fRVTpMrj7VfoRiokvC3vuz+s5HovuCDoQVBLMIKgj6OGDWoLwQSXBAB/UEkwgqCMYGQSVBCMI6ggmAkElwQCCOoIZd3VXEAz9JftAZwQdCCoJIqPWEbQVCrENEBxkw8+iW4KMXqwliHsSJUGLXqwlCB9UEnTwQS1B+KCSoEdtRksQ98VKggG1GS1BD4I6ghG1GS1BB4JKgqjNKAkmZNSnBHdYMH0kYcnIfUUsSGgFLM4gQxCxIPUUsSCWS1gIAVrEgjqWhIURoEUsCNASFosykogFAVrEggAtYcG6CRGLR/IvYoG3iFgwtkhYsBZBxtJq8s+5X/PPP63il6+Z8uGa0ynDZpcY1GTY6m3FJIZkD9s4+NOHQ12zywxqMmw1elZk2OyD8jUZIi5fwzAMOCidxhRP6MtXMHTDRhPdx1M/9Nxqzbwmw1ZnwCsybLa+WpNhq8XYSQy7Ia+/Zu/NKcNmN8epyRB+qGboEZf1DJFjqxk2W1atyDAit9EzRP1QzTChjq1niHs9NcNmH42uyRDj4TUMIw8M8+ncaDAODNUMUYNVMyTEFDXDZp/mrckQMUXN0KJ+qGeIuKxm2Oz2L5MYWhoYWktnDFE/VDNsdguYmgwRl9UMA+KyniHisp4hYoqaYURuo2cIP1QzxHxKBYbIbdQMm936vSZDB4ZXMBxexEg2nM5JxWY3sanJEHMBaoaEuKxniPxQzRBrK/QMsS6gAkM8j61dWxGb3dGlIkPMSVVgCD9UM2x2XUActmjgaG2x8JZhaDXHnsKQQhie4QzpzA9Dq/d6FRnGVnObigxTq3WbmgwdGI4zjLE/McXszxi2mttUZJhbzbFrMkRc1jJMptW6TU2GyG30DBFT1AzJgaGaIfxQzbDZ+ZSaDJHbXMEwH54VyXzGsNn5lJoMa4yHww6Llv0Yw2SGmnAyfGAoQulKIv2pY/LusjCRc8PWt+SyORbftrXKfkh/SVur7GX/d7SViMWJhG6usLfhTuvm2/NIOtn1nSV7f6YjbwY1ohOn68jvyh3RkZ374m7QRJ+8EXVMyxVp5RKtVGQrFdnKRbZyiS02JbaYTJFWma2idn2SHI5pxRKtTx5KGdMq6Sksb0h4cYxh+T0r2fQvCsgs6Ewfl1juxZftxIJrkxcrXNaRH84f0QnTGWQq0Jlux8r9dkRn+m9qqcAOFdiR+2v2vV/nyOc6abqOLbDjqEAnTNfxBXZ8gR158ePR7yPp+Om/aTQFOgV2ki3QSdN18vS+4AwV6EwfD5z8kPOIzvSc8JPXJI7oFLTHmgKdgt/HTvSDH93Rv/ebxf3Dcv7aaWy/fF89vi3Wq/3h238v/TcPm8VyuXi+e9msH+dP75v53XL9uP1uZvZ/vlFXnqEct9eyOwx0000t7xK63WHsDnNntbP8Pw==",
-      "brillig_names": [
-        "set_portal"
-      ]
-    },
     {
       "name": "initialize",
       "is_unconstrained": false,
@@ -1807,7 +1709,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "7VjZiuMwEPwXP/uhDx3d+ZVlGXJ4BkNIQo6FJeTfV/bGcg7Fg0J2ljB5MWq7SypVSyrb+2JWTXYfb/XifbkpRj/2xXw5HW/r5SJE+wJNe2+zGi+acLMdr7fFiIzVsqgWs6bp7aEs3ut5VYyQ5FBeZ5PzXTaJ9tkAqWw1csxmIPwkG61ac0wPbScxnwRTvSO5jguanjlpijmy465zg3CW/bMs0L7EuS2Oe4lzWxyfFIeVe3HkE3EMUieOQccxW6AdQf75CJoaAVGjquR6mRylVEILnaihTS6me37uAhM8Qhw+EcfpsDjsbKwV9dJYbungI+h4jXQc0TAdVBcJhbbQ6epJiM+AcWUyGLpYbETPPgH+6gkQcNxcBBbxklHS2sNJEMdg5GFGGigdk5UcDCsk0E1VWE/24l8ySStFplgCPpE0TcbGs02d12Ey6FwU3jOf7Bds6STNCw1EOsbKtz3b/Euc2+LIS5zb4ugjxHmYKzI8gs5/NBXGZ58AffUEhl0xBJN1PZ/XH29nn8HQXEzSMEMXx+6shcsVZmw+xOVDfD5EMiEhwiYz/SJmlY5Ab/XcTENETaZPAlW6YqhevRR4zoeYfIjNh7h8iM+HSD5EsyEC+RDMh+RXX/KrL/nVl/zqS371Jb/6kl99ya++pqvfvxwD0BUG78DQHRi+A2PuwNg7MC4XEyJu/6imv3TEULRV4Ksj1LwMKIS/xut6PJlXjSc3T3eLaWfRIdz+XnVPOhNfrZfTarZbV42d907eLCzG0mAggs0OsFBaGz2uvRW+PBmiezWI8OfSaYdQKRG4r2pzD31JFKt1a5BDmMsf",
+      "debug_symbols": "7VjbiiIxEP2Xfu6HuqSSqvmVZRmcGWcQRMXLwiL++6bFpL1EJeLOIuuLdHXXSU7OSVKJ6+Zj+Lb6eh1NPqeL5uXHuhlP3wfL0XQSo3WDbvtuMRtMunCxHMyXzQs5H9pmOPmIj8K0aZvP0XjYvCDppj3NJvApm7qMlA1QylbNbZuHK9koJm6XHp993zopllpHylzQSZ9tJebInlPjDuEg+2fboDzFOS+Of4pzXpxQFgewF4eviONQZJft0DBnK2x70L/eg5V6QMJkQmy0F9VTSSWUbHB8Jp/TAz+2wQT3EIf3xPF2WRz2vVd760p4SwfvQSdYpuOJLtNB85YFsrCnkBbXLoPLM5MhwNFkI3r0AfB3D4CAOc1/AmE7ZlQs7chIqQ9mf5mRoUsS2T79okIKiY3ucaEdGSmTcZrJeLlCxlMywAKEy2TQ+7w3hP2NUHBLp1i80FGm4xT/270tPMU5L44+xTkvjt1DnLtVRYZ70PmHRYXx0QdA3z2Ay1UxBm/z0Xg8+no9uAZD9+OKBVMwDVAEjmeYk3qIr4eEeohWQmKEXWb5ICaWDg1B7LCYxoi6zFAEmqbFbHZyKAhcD3H1EKmH+HpIqIdoPcSqIQr1EKyH1Luv9e5rvfta777Wu6/17mu9+1rvvpXd7w/HAHSCwRswdAOGb8C4GzByA8bXYmLE239UyzcddfnaZcAnW6h7FqAY/hrMR4O38bCryd3X1eQ9legYLn/P0pdUxGfz6fvwYzUfduW8r+TdxGJsHUYi2K0AgVYk17jtK5KWIVevDiHWeksI0xaBe1e7d/EuT5TdOtfJJo7lDw==",
       "brillig_names": [
         "store_in_execution_cache_oracle_wrapper",
         "enqueue_public_function_call_internal",
@@ -1817,6 +1719,118 @@
       ],
       "verification_key": "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"
     },
+    {
+      "name": "process_log",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "16775516380094354375": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 40
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [
+          {
+            "name": "_log_plaintext",
+            "type": {
+              "fields": [
+                {
+                  "name": "storage",
+                  "type": {
+                    "kind": "array",
+                    "length": 18,
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                },
+                {
+                  "name": "len",
+                  "type": {
+                    "kind": "integer",
+                    "sign": "unsigned",
+                    "width": 32
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "std::collections::bounded_vec::BoundedVec"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "_tx_hash",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "_unique_note_hashes_in_tx",
+            "type": {
+              "fields": [
+                {
+                  "name": "storage",
+                  "type": {
+                    "kind": "array",
+                    "length": 64,
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                },
+                {
+                  "name": "len",
+                  "type": {
+                    "kind": "integer",
+                    "sign": "unsigned",
+                    "width": 32
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "std::collections::bounded_vec::BoundedVec"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "_first_nullifier_in_tx",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "_recipient",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": null
+      },
+      "bytecode": "H4sIAAAAAAAA/+Wc6XLbNhDHKZu0TcmyZPmK3Svp3bRpKYnU0dNt0/u+lM+KYz8HHyPta7Rf2qer/jFXWsHojDteTPxPMMOhpYV2f1wuARBYuBadl8nsqFV/x9V5vTrj+060XKTucXXOrla6hrqyUIw1AsYVAsZVAsaYgDEhYFwjYFwnYNwgYEwJGOsEjA0Cxk0CxiYB4xYBY4uAsU3AuB2AMQRnh4Rzx5BTj+1D8e5G1z9G9wgY9wkYDwgYbxAwHhIwHhEwPkPA+CwB43MEjM8TML5AwHiTgPEWAeOLBIwvETC+TMD4CgHjqwSMrxEwvk7A+AYB420CxjcJGN8iYLxDwPg2AeM7BIwZAWOXgLFHwNgnYMwJGAsCxgEB45CAcUTAOCZgfJeA8T0CxvcJGD8gYPyQgPEjAsZjAsaPCRg/IWD8lIDxLgHjZwSMnxMwfkHA+CUB41cEjF8TMH5DwPgtAeN3BIzfEzD+QMD4IwHjTwSMPxMw/hKAMQTnryScv5FwTgJxRvcc6JXZgY1b2BiFjUfY2IONM9iYgo0f2FiBjQvYGIDEeyS2I3G8PTuQ+IykYiTsIgkWSaZI4kSSJJIQkeSHJDokqSEJDElWSGJCktDN2XFrdiCJBEkaSIJAkgEW8bFIjkVoLPJiERWLlFgExCIbFrGwSISrwiIHFhEwSY9JcEwyYxIXk6SYhMQkHybRMEmFSSBMsmASQyYJ8JKLl0i8pOElCC8ZGMRjkIxBKAZ5GERhkIJBADpZdGLoJNAIo5FDI4KHFA8AgmsS/XeRIPmnOqfVeUXJDTfRdVPHrqX+UTa+n3quz5C/n1Y6N4LoL4aiPw3Dn8lG27vlQr++FrG7Wp0n5cKXk3KZSeo8VHUeOnXkesLc7zwP669ur+n4KFLXIrbrYWz3a449fV+0TOzXo5Cxeb4pWdsTHtc/0nY0pU654Kk5sri8eB0iS5RM7i/s3Fb13NjacGTCgiLx21S+kXKvksk9jZVOu3gtRmHjNc8eX7zm3ScxXmNHFpcXr+P/xquOLTdek2hRpC0V2ZqS/e7I1pXsj3Jhu1Acg+rvsG3yeR+snz3rPmzHw69toayXC39IDK6q7xLlv0f+0fUdWapkcblsp159jpUdrUs4Eqd+Xn1uVec19Rv5fdtjf82xv8Tt+c71S+qpn3rqI9buVH83qgMx9Jf8Jrr47OI4rj5nVyrDwtdO2ukfdH1toaH+U9HfCKK/l4n+zTD8836qGeb+DkT/Vhj+efy0wvD3RH87DP+Z6N8Owz9/j+kE0V/Mx+U7Yfjn8b8bxv9z/r0w/HP9+2H45/f3IIz+sYw7bkSL4o4zD9X3dv1/b3zZcabYrzusocaZhw6P6x89zoTsyMPa9sjcZ/TIY+fIY8ena9NQ14Ghrm1DXQ1DXfuGutqGuuqGuvYMdbUMdaWGuizvo6W/LGN111CXZaxuGeq6ru2E5fNo6fvrGqsbhrosY8IyVi39tWOoy7KNthwDNA11WfYdls/QdY2vp6H9CtEPhV0PzDLfPFhkp987D2aoPxNfS6zquW9tU64vcer/6fh5M4ife1N5J5M2SPvCN1dlabvm2Isi//us2G96eIS77pFd5R/Mno5OTsf383wwzIuifzKsOfqF1f1OzzvrPkfX970b++bVDH098q3xtJRfUWIl23JkiZIJo17j8c07WvJfxv/aftsjc8del72XnWg51vTz2IgWz3Bc2l/7cHTeljxirPQn0fIabuTYT5z6f1ef3bbuqs/I2XDaPetPz6bF9MGD/GTacfRrH8JP/wJJ9PoyCV0AAA==",
+      "debug_symbols": "tZbRCsIgGIXfxWsvpkt/61Uiwm0uBHHDbUGMvXsaUaOuz83YkV8/L/zgrKxzzXK7+tgPEzudVxaG1s5+iDmtG2dN8iH423W/zKryEUq/NkyjjSVPs00zO4laGsOZi135r2uTD+l9cDnJ48b/5km+h4k+k0psF54BhAYYNOAIBugKDRBogEQDajTggAYoNABtskabrNEma7TJhDaZ0CYT2mRCm0xokwltMqFNJrTJBDV5y+luk7dNcO+G0y+x3RWe+TG6n+4zpqF13ZJcaUHfAlRe40FyJcu1i73CVFwYlSEZ9AQ=",
+      "brillig_names": [
+        "process_log"
+      ]
+    },
     {
       "name": "claim",
       "is_unconstrained": false,
@@ -3504,7 +3518,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "build_msg_block",
         "attach_len_to_msg_block",
@@ -3525,18 +3539,13 @@
       "verification_key": "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"
     },
     {
-      "name": "_increase_public_balance",
+      "name": "set_portal",
       "is_unconstrained": true,
       "custom_attributes": [
-        "public",
-        "internal"
+        "public"
       ],
       "abi": {
         "error_types": {
-          "10502589790419500451": {
-            "error_kind": "string",
-            "string": "Function _increase_public_balance can only be called internally"
-          },
           "16761564377371454734": {
             "error_kind": "string",
             "string": "Array index out of bounds"
@@ -3545,18 +3554,22 @@
             "error_kind": "string",
             "string": "Stack too deep"
           },
-          "206160798890201757": {
+          "2236649814169388962": {
             "error_kind": "string",
-            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+            "string": "PublicImmutable already initialized"
           },
           "5019202896831570965": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
+          },
+          "6485997221020871071": {
+            "error_kind": "string",
+            "string": "call to assert_max_bit_size"
           }
         },
         "parameters": [
           {
-            "name": "to",
+            "name": "portal_address",
             "type": {
               "fields": [
                 {
@@ -3567,142 +3580,21 @@
                 }
               ],
               "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "amount",
-            "type": {
-              "kind": "integer",
-              "sign": "unsigned",
-              "width": 128
+              "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
             },
             "visibility": "private"
           }
         ],
         "return_type": null
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "JwACBAEoAAABBIBHJwAABAMnAgIEAScCAwQAHxgAAwACgEYuCIBGAAElAAAARSUAAABbKAIAAQSARycCAgQAOw0AAQACKACAQwQAAygAgEQEAAAoAIBFBAABJiUAAANZJwICAAIvDAACAAMcDAMEACwCAAUAAAAAAAAAAAAAAAAA//////////////////////////8OOAQFBiQCAAYAAACnJQAAA4InAgQAAAo4AwQFJAIABQAAAMInAgYEADwJAQYpAgADADuaygIvDAADAAUKOAUEBiQCAAYAAADjJQAAA5QoAgAFAN6tMAwABQADLQgBAycCBQQEABABBQEnAwMEAQAoAwIFLQwFBi0OBAYAKAYCBi0OBAYAKAYCBi0OBAYtDQMFACgFAgUtDgUDKwIABQAAAAAAAAAAAQAAAAAAAAAALQgBBicCBwQFABABBwEnAwYEAQAoBgIHLQwHCC0OBAgAKAgCCC0OBAgAKAgCCC0OBAgAKAgCCC0OBQgtDQMEACgEAgQtDgQDLQgBBAAAAQIBLQ4DBC0NBgMAKAMCAy0OAwYtCAEDAAABAgEtDgYDLQgBBQAAAQIBLgqARAAFLQgBBgAAAQIBJwIHAQAtDgcGLQ0FCC0NBgkKOAkHCiQCAAoAAAHyJwILBAA8CQELCygACIBDAAkkAgAJAAACgyMAAAIHLQ0ECC0NAwktDQUKLQ0GCycCDQQDDDgKDQ4kAgAOAAACLiUAAAOmLgQACIADKACABAQABCUAAAO4LgiABQAMACgMAg0AOA0KDi0OAQ4BKAAKgEUACA44CggNJAIADQAAAm4lAAAERi0ODAQtDgkDLQ4IBS0OCwYjAAAC9icCCAQJLQgACS0MBAotDAMLLQwFDC0MBg0AEAAIACUAAARYLQQAAC0NBAgtDQMJLQ0GCi4EAAiAAygAgAQEAAQlAAADuC4IgAUACwAoCwIMASgADIBEAA0tDgENLQ4LBC0OCQMuCoBFAAUtDgoGIwAAAvYtDQYICjgIBwkkAgAJAAADECcCCgQAPAkBCicCBwQILQgACC0MBAktDAMKLQwFCy0MBgwAEAAHACUAAARYLQQAAC0NAwQBKAAEgEUABS0NBQMwDAABAAInAgEAAzAMAAMAASYoAIAEBHgADQAAAIAEgAMkAIADAAADgSoBAAEF96Hzr6Wt1Mo8AQECJioBAAEFWgLkG7UeqZ88AQECJioBAAEFHwotJ9yCh6I8AQECJioBAAEF6J0J/qERLQ48AQECJi4BgAOABgsAgAYAAoAHJACABwAAA9MjAAAD3i4AgAOABSMAAARFLgAAAYAFAQAAAYAEAAEBAIADgASACS4AgAOACi4AgAWACwsAgAqACYAMJACADAAABDEuAYAKgAguAoAIgAsBAIAKAAKACgEAgAsAAoALIwAABAAoAYAFBAABAwCABgACgAYjAAAERSYqAQABBUWnynEZQeQVPAEBAiYlAAADWS4IgEQABSMAAARoDSgABYBDAAYkAgAGAAAE2CMAAAR9LQ0BBS0NAgYtDQMHLQ0ECCcCCQQELQgBCicCCwQFABABCwEnAwoEAQAoBgILJwIMBAQAKAoCDT8PAAsADS0NCgYAKAYCBi0OBgotDgUBLQ4KAi0OBwMtDggEJi0NAwYMOAUGBwEoAAWARQAGJAIABwAABPYjAAAFpy0NAQctDQIILQ0DCS0NBAonAgwEBAw4BQwNJAIADQAABR0lAAADpgAoCAIMADgMBQ0tDQ0LJwINBAMMOAUNDiQCAA4AAAVCJQAAA6YAKAcCDQA4DQUOLQ0ODAA4CwwNJwIMBAQMOAUMDiQCAA4AAAVsJQAAA6YuBAAIgAMoAIAEBAAFJQAAA7guCIAFAAsAKAsCDAA4DAUOLQ4NDi0OBwEtDgsCLQ4JAy0OCgQjAAAFpy0MBgUjAAAEaC4AGMoYyg==",
+      "debug_symbols": "7Z3bbuM4DIbfJde9EKlzX2WwKHrIFAGCpEjbBRZF332doHYyCRPHoqa7A/03xXhCmtZnyqSpgz9mT/OH9+e7xern+nV2++Njtlw/3r8t1qvu6OPzZvawWSyXi+e7w/+eme2fHHbyry/3q+3h69v95m12SzGnm9l89dT9M7HvzvBzsZzPbgN/3pwIW+/4S9gGsxem6AVp4uT7U9sDaTbSuaMP/YVEn/IgnUgStiH2ws6Ey8JE3cX2F0I220Pxv25mZAhkzpCJ/3MyfiATjLvc2ByHMxtj9mcOTjoz5+HEPCJL5OwAMaQRaR97YZ/395LSjjcxeH8nb5fB+zt5ewfe38k74HnyvbzH46WNh7y3SpFLlEosJV+glE2JktzRk9srbW/yJcfjzH0mw9nziOP9d0kSG9tQW3OFtubehDVHD5StCXK/3QTz7zcR1SYsDbfZdh1qxCmS4f6CknE84hSJ+6dYTNGNOYULeXAKT+bYKaxrp63O6NvKsTdh+TCGyBHVuKFHmsNYJkfU7PooGfNB92WxtdaHL2HHBxFVugzu7kr/hGLiy8Ke+/N6joeiO4IOBJUEMwjqCHr4oJYgfFBJMMAHtQQTCOoIRgZBJcEIgjqCiUBQSTCAoI5gxlvdFQSH0pAPdELQgaCSIDJqHUFboRDbAMFBNvwquiXI6MVagngnURK06MVagvBBJUEHH9QShA8qCXrUZrQE8V6sJBhQm9ES9CCoIxhRm9ESdCCoJIjajJJgQkZ9THCHBcNHEpaM3FfEgoRWwOIMMgQRC1JPEQtiuYSFEKBFLKhjSVgYAVrEggAtYbEoI4lYEKBFLAjQEhasmxCxeCT/IhZ4i4gFzxYJC9YiyFhaTf4592v++ZdV/PI1U95fczpm2OwSg5oMW32tmMSQ7H4bB388OdQ1u8ygJsNWo2dFhs1OlK/JEHH5GoZh2DCn43HE0BP68hUMu7Gl/pqdOfZDz63WzGsybHUEvCLDZuurNRm2WoydxNAPe+mQ9+aYYbOb49RkCD9UM/SIy3qGyLHVDJstq1ZkGJHb6BmifqhmmFDH1jPEu56aYbNTo2syxPPwGoaRB4b5eGw0GAeGaoaowaoZEmKKmmGzs3lrMkRMUTO0qB/qGSIuqxk2u/3LJIaWBobW0glD1A/VDJvdAqYmQ8RlNcOAuKxniLisZ4iYomYYkdvoGcIP1QwxnlKBIXIbNcNmt36vydCB4RUMXRwYhuMxqdjsJjY1GWIsQM2QEJf1DJEfqhlibYWeIdYFVGCI+djatRWx2R1dKjLEmFQFhvBDNcNm1wXEYYsGjtYWC28ZhlZz7CkMKYRhDmdIJ34YWn3Xq8gwtprbVGSYWq3b1GTowHCcYYz9iSlmf8Kw1dymIsPcao5dkyHispZhMq3WbWoyRG6jZ4iYomZIDgzVDOGHaobNjqfUZIjc5gqGeT9XJPMJw2bHU2oyrPE8HHZYtOzHGCbDPcNk3J6hCCWmYfF1TNFdFiZyYdj6ljyZQ/FtW6vsh/SHtLXKXvZ/RluJWBxI6MYKexvuuG7enVN0/Oz6zpK9P9GRN4Ma0YnTdeRv5Y7oyM59cTdoojNfRB3TckVauUQrFdlKRbZyka1cYotNiS0mU6RVZquoXWeSwzGtWKJ1ZlLKmFZJT2F5Q8KLzxiWv7OSTf+hgMyCzvTnEsu9+LKdWHBt8mKFyzry5PwRnTCdQaYCnel2rNxvR3Sm31NLBXaowI7cX7Pv/TpHPtVJ03VsgR1HBTphuo4vsOML7MiLHw/uj6Tjp9/TaAp0CuwkW6CTpuvk6X3BGSrQmf48cPIk5xGd6Tnhmc8kjugUtMeaAp2C+2Mn+sFnd/T3/WZx/7Ccv3Ya2x/fV49vi/Xq6/Dtn5f+l4fNYrlcPN+9bNaP86f3zfxuuX7c/jYzX39+UFeeoRy317I7DHTTDS3vErrdYewOc2e1s/wv",
       "brillig_names": [
-        "_increase_public_balance"
+        "set_portal"
       ]
     },
     {
-      "name": "process_log",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "16775516380094354375": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 40
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [
-          {
-            "name": "_log_plaintext",
-            "type": {
-              "fields": [
-                {
-                  "name": "storage",
-                  "type": {
-                    "kind": "array",
-                    "length": 18,
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                },
-                {
-                  "name": "len",
-                  "type": {
-                    "kind": "integer",
-                    "sign": "unsigned",
-                    "width": 32
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "std::collections::bounded_vec::BoundedVec"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "_tx_hash",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "_unique_note_hashes_in_tx",
-            "type": {
-              "fields": [
-                {
-                  "name": "storage",
-                  "type": {
-                    "kind": "array",
-                    "length": 64,
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                },
-                {
-                  "name": "len",
-                  "type": {
-                    "kind": "integer",
-                    "sign": "unsigned",
-                    "width": 32
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "std::collections::bounded_vec::BoundedVec"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "_first_nullifier_in_tx",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "_recipient",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": null
-      },
-      "bytecode": "H4sIAAAAAAAA/+Wc6XLbNhDHKZu0TcmyZPmK3Svp3bRpKYnU0dNt0/u+lM+KYz8HHyPta7Rf2qer/jFXWsHojDteTPxPMMOhpYV2f1wuARBYuBadl8nsqFV/x9V5vTrj+060XKTucXXOrla6hrqyUIw1AsYVAsZVAsaYgDEhYFwjYFwnYNwgYEwJGOsEjA0Cxk0CxiYB4xYBY4uAsU3AuB2AMQRnh4Rzx5BTj+1D8e5G1z9G9wgY9wkYDwgYbxAwHhIwHhEwPkPA+CwB43MEjM8TML5AwHiTgPEWAeOLBIwvETC+TMD4CgHjqwSMrxEwvk7A+AYB420CxjcJGN8iYLxDwPg2AeM7BIwZAWOXgLFHwNgnYMwJGAsCxgEB45CAcUTAOCZgfJeA8T0CxvcJGD8gYPyQgPEjAsZjAsaPCRg/IWD8lIDxLgHjZwSMnxMwfkHA+CUB41cEjF8TMH5DwPgtAeN3BIzfEzD+QMD4IwHjTwSMPxMw/hKAMQTnryScv5FwTgJxRvcc6JXZgY1b2BiFjUfY2IONM9iYgo0f2FiBjQvYGIDEeyS2I3G8PTuQ+IykYiTsIgkWSaZI4kSSJJIQkeSHJDokqSEJDElWSGJCktDN2XFrdiCJBEkaSIJAkgEW8bFIjkVoLPJiERWLlFgExCIbFrGwSISrwiIHFhEwSY9JcEwyYxIXk6SYhMQkHybRMEmFSSBMsmASQyYJ8JKLl0i8pOElCC8ZGMRjkIxBKAZ5GERhkIJBADpZdGLoJNAIo5FDI4KHFA8AgmsS/XeRIPmnOqfVeUXJDTfRdVPHrqX+UTa+n3quz5C/n1Y6N4LoL4aiPw3Dn8lG27vlQr++FrG7Wp0n5cKXk3KZSeo8VHUeOnXkesLc7zwP669ur+n4KFLXIrbrYWz3a449fV+0TOzXo5Cxeb4pWdsTHtc/0nY0pU654Kk5sri8eB0iS5RM7i/s3Fb13NjacGTCgiLx21S+kXKvksk9jZVOu3gtRmHjNc8eX7zm3ScxXmNHFpcXr+P/xquOLTdek2hRpC0V2ZqS/e7I1pXsj3Jhu1Acg+rvsG3yeR+snz3rPmzHw69toayXC39IDK6q7xLlv0f+0fUdWapkcblsp159jpUdrUs4Eqd+Xn1uVec19Rv5fdtjf82xv8Tt+c71S+qpn3rqI9buVH83qgMx9Jf8Jrr47OI4rj5nVyrDwtdO2ukfdH1toaH+U9HfCKK/l4n+zTD8836qGeb+DkT/Vhj+efy0wvD3RH87DP+Z6N8Owz9/j+kE0V/Mx+U7Yfjn8b8bxv9z/r0w/HP9+2H45/f3IIz+sYw7bkSL4o4zD9X3dv1/b3zZcabYrzusocaZhw6P6x89zoTsyMPa9sjcZ/TIY+fIY8ena9NQ14Ghrm1DXQ1DXfuGutqGuuqGuvYMdbUMdaWGuizvo6W/LGN111CXZaxuGeq6ru2E5fNo6fvrGqsbhrosY8IyVi39tWOoy7KNthwDNA11WfYdls/QdY2vp6H9CtEPhV0PzDLfPFhkp987D2aoPxNfS6zquW9tU64vcer/6fh5M4ife1N5J5M2SPvCN1dlabvm2Isi//us2G96eIS77pFd5R/Mno5OTsf383wwzIuifzKsOfqF1f1OzzvrPkfX970b++bVDH098q3xtJRfUWIl23JkiZIJo17j8c07WvJfxv/aftsjc8del72XnWg51vTz2IgWz3Bc2l/7cHTeljxirPQn0fIabuTYT5z6f1ef3bbuqs/I2XDaPetPz6bF9MGD/GTacfRrH8JP/wJJ9PoyCV0AAA==",
-      "debug_symbols": "tZbdCoMgGIbvxWMP0tKvditjDCsbglhYDUZ079OxP7bj9yR65dPHAx94N9bbdr2cXRjGmR2OG/NjZxY3hpS2nbM2Ou/d5fy9zIr8EUo/NsyTCTnPi4kLO4hSNpIzG/r8X1YyHTI4b1OSzc7/5uk1TPSeVGI/8QQgNKBGAxowQBdogEADJBpQogEVGqDQALTJGm2yRpus0SYT2mRCm0xokwltMqFNJrTJhDaZ0CYT1OQ9pauJzrTePhvOsIbuq/Ast8n+dJ8pjp3t12hzC/oUoPwaK8mVzNfO9oq64KJWCZJAdw==",
-      "brillig_names": [
-        "process_log"
-      ]
-    },
-    {
-      "name": "public_dispatch",
+      "name": "public_dispatch",
       "is_unconstrained": true,
       "custom_attributes": [
         "public"
@@ -3767,29 +3659,137 @@
         "return_type": null
       },
       "bytecode": "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",
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "public_dispatch"
       ]
     },
     {
-      "name": "sync_notes",
+      "name": "balance_of_public",
       "is_unconstrained": true,
-      "custom_attributes": [],
+      "custom_attributes": [
+        "public",
+        "view"
+      ],
       "abi": {
         "error_types": {
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
+          },
+          "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"
+          },
+          "6067862452620309358": {
+            "error_kind": "string",
+            "string": "Function balance_of_public can only be called statically"
           }
         },
-        "parameters": [],
+        "parameters": [
+          {
+            "name": "owner",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": {
+          "abi_type": {
+            "kind": "integer",
+            "sign": "unsigned",
+            "width": 128
+          },
+          "visibility": "public"
+        }
+      },
+      "bytecode": "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",
+      "debug_symbols": "7Z3dTus4EMffpddceDz+PK9ytELA4aBKVYsKrLRCvPumPSQttdWsPRZq1/8bRBpPZvyLkxnbY+d98evx/u3pdrn+vXlZ/Pj5vlhtHu5el5v1cPT+cbO43y5Xq+XT7fHPC7X7Q0rvBV6e79a745fXu+3r4gdRVPZm8bj+tf9f++Eiv5erx+FIh4+bpLxXkT+Le1JxKh0oUzhq4z4LR+2+FP7rZrDI/xeL4heLdnKkK+Uq9WlbJ8cqJ8fkRzGmaCYppzMESTmedBAfVLjczaEw4qYYprJMn+aYyzInXpQ55rLomMuiYy+Ljg0XZY7Tl2WOvyhzPH23OXY0Ryv9xZyMP4tmNMPHeLiyzjo0nq5stDqUtZmieqjUaIUmfb6w1eN17ZEHHoru+Tnwk/ALCvxE/Cz4SfhFtD8ZP7Q/CT+t0P5k/Az4ifgF8JPwIwY/ET8PfhJ+WoOfiB/6b7P8nBr5OTrlx4hfZPwQP8v4RfCb4zeVdV+L7vg5PL8yfgb8RPzw/Ir4ebQ/GT+0PxG/gPYn44fxFxG/iP6vjB/GXyT8WGH+XMYP4y8ifoT+m4wfxl9k/BA/p1A0JoUyUBDpplAY4WsGCmKCFIpBoJmBAu+dgQKXnEL5/hz5a4ACl5xCcXDJGSgYJkqhYO1EDgpccgoFqxxyUBDmp1CwHiEHBe+UBIrByoEMFN0nFM0HKMaeQuE+w3xPcbTCM1cX3hE0ffYJSgiSO9TPBUoI9tmBaEjQ9ukEGxLsNNe1JUEDgnMEvZ/2W/Ax8cWd5rs2JOj7nFxtSRC+WEgw9Dny15IgohkpQXgSIcFoQFBIEG1QRtAqRDNSgohmhAQJ0YyUIKIZKUF4EiHBTpOOWxKEJxES7DSduSXBPpMiighG0mP9ok4Ifv9e0f87gg3miymEUcPxjHSeoLXTM+GCOtrlnnNUvPMjwnAwg7zbG2/5mo2/ZvLOXbHx87mcWrk54zlObw33VUXGHOvGqnobZr7V4PlgvDmyI1t4sGPaMWlnEx8X39fVf3td7VRXp8yM+Y7GupLjQ2HmP3cq6Ku2/prZu05Xa7OarGAyJ+7SdTp8MgMFLSWFog2gpFD6HPk5D4XRUjJQ0FJSKKbPYT8d9QRF2Znurpr6xkNVQ0Kwz2G/hgRtnxFQEUHiQ/0sJQT7DJcaEuw0NbUlwT7da0OCnaamlhF0dqpfSDxJpylZRQSNmkb3jEraYOxzsVc7gl71OYnZkiCiGSHBTrd1LCJo9VQ/a1VCsM+UrIYEe11L3ZAgfLGQICOilhJEr05I0CCaERLE+KCYIMaohQQ73davJUG0QSHBTjcMLCPop9RUG3VCENGMkGCnH2xqSLDTTw61JAhPIiMYOv3sUEuCGB+UEoQvFhIkjA/OEuTDUiXm03mS0Omi15YE4YuFBBm+WEoQvlhKEL5YSBB51GKCiGaEBC3aoJQgohkhQYdoRkoQ0YyUIKKZeYJmWqnN7nSmKXT6FaaGBANG+aUE4YuFBCPiQSlB9ElkBCNy+aUEkcsvXA0RyYCgkCDeg0KCne7d0pAgcvlPCA5QSOlsT81PW3x5w4lMPiM9mlFRtKkeqypkTIVMKJfJ5+ae33Ri+MnXSOVzMGelXI1UqNIVqnTFKl2xRhcpqpKquV9EVbqoql75FW+zUqZKKtRIsa6S8sXvGDJZ7lGNHxqNOiNT/l6i/FN8Xo+vsC0/IjYjE8tlApczCOXvTIrlenT+uZ2RKb+nmir0UIWe/PMa7diuo9epjC2X4Qo9+Y/unpfJz0HPyFTosRV68jNrR/cnI5P36+fvqfPlMr5CT1AVMrZcJlY8C7H8fcCKK2RiuQyZCpkKPbqiPrq87TBThUxhO/gYjv6+2y7v7lePL4PE7uTb+uF1uVl/Hr7+8zyeud8uV6vl0+3zdvPw+Ott+3i72jzszi3U55+fQ4O/0ZH3EdxwuNs0m/4c7iqjoxnOukHroPlf",
+      "brillig_names": [
+        "balance_of_public"
+      ]
+    },
+    {
+      "name": "_increase_public_balance",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public",
+        "internal"
+      ],
+      "abi": {
+        "error_types": {
+          "10502589790419500451": {
+            "error_kind": "string",
+            "string": "Function _increase_public_balance can only be called internally"
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          },
+          "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"
+          }
+        },
+        "parameters": [
+          {
+            "name": "to",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "amount",
+            "type": {
+              "kind": "integer",
+              "sign": "unsigned",
+              "width": 128
+            },
+            "visibility": "private"
+          }
+        ],
         "return_type": null
       },
-      "bytecode": "H4sIAAAAAAAA/7WTyw7CIBBFqcUo0sTEx39MU0y7dOHafyCtLHVRN+766dZkJkyI0QVwEzJMgMNcHoXwKjBKESGCHDEqjAs2Xs7tjDnEqVbBvin5HRijvvhLWH+jkFnk4QPxM50/rJBzmTyfe6F913PTrF8J/z5y+af7y+l//8OzRq9bzCvh/8P4uvfXx/M2ij/SbJGc0ptoOwAqvkT+EvmhJBvn8w+Yb4Svj6KMqNO1tnaNdfZkh8H0dhfwP+KH/QbzqHp4zgQAAA==",
-      "debug_symbols": "ZY5bCoMwEEX3Mt/5MKYPdCtSJOoogZBIHoUSsvdORGioP5e5w+FyEiw4xW1UZrUe+iGBtrMMyhpqKTOYnNJabWP9hqYEFwfvd2lK9UG6AD0XnWgYoFmO+yloY1UaqbVdZhdedO1J3zj/sQ+RX5nqWzolJ42nzRrNXMmFz45/nruzMy7RYTGuZCkHfmdtQ7M0/QU=",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "sync_notes"
+        "_increase_public_balance"
       ]
     }
   ],
@@ -3895,7 +3895,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "to",
+                    "name": "portal_address",
                     "type": {
                       "fields": [
                         {
@@ -3906,37 +3906,17 @@
                         }
                       ],
                       "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-                    }
-                  },
-                  {
-                    "name": "amount",
-                    "type": {
-                      "kind": "integer",
-                      "sign": "unsigned",
-                      "width": 128
-                    }
-                  },
-                  {
-                    "name": "secret",
-                    "type": {
-                      "kind": "field"
-                    }
-                  },
-                  {
-                    "name": "message_leaf_index",
-                    "type": {
-                      "kind": "field"
+                      "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::claim_parameters"
+                "path": "FeeJuice::set_portal_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::claim_abi"
+          "path": "FeeJuice::set_portal_abi"
         },
         {
           "fields": [
@@ -3945,7 +3925,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "portal_address",
+                    "name": "owner",
                     "type": {
                       "fields": [
                         {
@@ -3956,17 +3936,25 @@
                         }
                       ],
                       "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
+                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::set_portal_parameters"
+                "path": "FeeJuice::balance_of_public_parameters"
+              }
+            },
+            {
+              "name": "return_type",
+              "type": {
+                "kind": "integer",
+                "sign": "unsigned",
+                "width": 128
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::set_portal_abi"
+          "path": "FeeJuice::balance_of_public_abi"
         },
         {
           "fields": [
@@ -4013,21 +4001,48 @@
               "type": {
                 "fields": [
                   {
-                    "name": "fee_limit",
+                    "name": "to",
+                    "type": {
+                      "fields": [
+                        {
+                          "name": "inner",
+                          "type": {
+                            "kind": "field"
+                          }
+                        }
+                      ],
+                      "kind": "struct",
+                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                    }
+                  },
+                  {
+                    "name": "amount",
                     "type": {
                       "kind": "integer",
                       "sign": "unsigned",
                       "width": 128
                     }
+                  },
+                  {
+                    "name": "secret",
+                    "type": {
+                      "kind": "field"
+                    }
+                  },
+                  {
+                    "name": "message_leaf_index",
+                    "type": {
+                      "kind": "field"
+                    }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::check_balance_parameters"
+                "path": "FeeJuice::claim_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::check_balance_abi"
+          "path": "FeeJuice::claim_abi"
         },
         {
           "fields": [
@@ -4074,36 +4089,21 @@
               "type": {
                 "fields": [
                   {
-                    "name": "owner",
+                    "name": "fee_limit",
                     "type": {
-                      "fields": [
-                        {
-                          "name": "inner",
-                          "type": {
-                            "kind": "field"
-                          }
-                        }
-                      ],
-                      "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                      "kind": "integer",
+                      "sign": "unsigned",
+                      "width": 128
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::balance_of_public_parameters"
-              }
-            },
-            {
-              "name": "return_type",
-              "type": {
-                "kind": "integer",
-                "sign": "unsigned",
-                "width": 128
+                "path": "FeeJuice::check_balance_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::balance_of_public_abi"
+          "path": "FeeJuice::check_balance_abi"
         }
       ]
     }
@@ -4111,11 +4111,11 @@
   "file_map": {
     "100": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/hash.nr",
-      "source": "use crate::utils::to_bytes::{arr_to_be_bytes_arr, str_to_be_bytes_arr};\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::Hash,\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n"
+      "source": "use dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::{Hash, ToField},\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n"
     },
     "112": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/history/public_storage.nr",
-      "source": "use dep::protocol_types::{\n    address::AztecAddress, block_header::BlockHeader, constants::GENERATOR_INDEX__PUBLIC_LEAF_INDEX,\n    hash::poseidon2_hash_with_separator, utils::field::full_field_less_than,\n};\nuse dep::protocol_types::merkle_tree::root::root_from_sibling_path;\n\nuse crate::oracle::get_public_data_witness::get_public_data_witness;\n\nmod test;\n\ntrait PublicStorageHistoricalRead {\n    fn public_storage_historical_read(\n        header: BlockHeader,\n        storage_slot: Field,\n        contract_address: AztecAddress,\n    ) -> Field;\n}\n\nimpl PublicStorageHistoricalRead for BlockHeader {\n    fn public_storage_historical_read(\n        self,\n        storage_slot: Field,\n        contract_address: AztecAddress,\n    ) -> Field {\n        // 1) Compute the leaf index by siloing the storage slot with the contract address\n        let public_data_tree_index = poseidon2_hash_with_separator(\n            [contract_address.to_field(), storage_slot],\n            GENERATOR_INDEX__PUBLIC_LEAF_INDEX,\n        );\n\n        // 2) Get the membership witness for the tree index.\n        // Safety: The witness is only used as a \"magical value\" that makes the proof below pass. Hence it's safe.\n        let witness = unsafe {\n            get_public_data_witness(\n                self.global_variables.block_number as u32,\n                public_data_tree_index,\n            )\n        };\n\n        // 3) The witness is made up of two parts: the preimage of the leaf and the proof that it exists in the tree.\n        // We first prove that the witness is indeed valid for the public data tree, i.e. that the preimage is of a\n        // value present in the tree. Note that `hash` returns not just the hash of the value but also the metadata\n        // (slot, next index and next slot).\n        assert_eq(\n            self.state.partial.public_data_tree.root,\n            root_from_sibling_path(witness.leaf_preimage.hash(), witness.index, witness.path),\n            \"Proving public value inclusion failed\",\n        );\n\n        // 4) Now that we know the preimage is valid, we determine the value that's represented by this tree entry. Here\n        // we have two scenarios:\n        // 1. The tree entry is initialized, and the value is the same as the one in the witness\n        // 2. The entry was never initialized, and the value is default zero (the default)\n        // The code below is based on the same checks in `validate_public_data_reads` in `base_rollup_inputs`.\n        let preimage = witness.leaf_preimage;\n\n        let is_less_than_slot = full_field_less_than(preimage.slot, public_data_tree_index);\n        let is_next_greater_than = full_field_less_than(public_data_tree_index, preimage.next_slot);\n        let is_max = ((preimage.next_index == 0) & (preimage.next_slot == 0));\n        let is_in_range = is_less_than_slot & (is_next_greater_than | is_max);\n\n        let value = if is_in_range {\n            0\n        } else {\n            assert_eq(\n                preimage.slot,\n                public_data_tree_index,\n                \"Public data tree index doesn't match witness\",\n            );\n            preimage.value\n        };\n\n        value\n    }\n}\n"
+      "source": "use dep::protocol_types::{\n    address::AztecAddress, block_header::BlockHeader, constants::GENERATOR_INDEX__PUBLIC_LEAF_INDEX,\n    hash::poseidon2_hash_with_separator, utils::field::full_field_less_than,\n};\nuse dep::protocol_types::merkle_tree::root::root_from_sibling_path;\n\nuse crate::oracle::get_public_data_witness::get_public_data_witness;\nuse protocol_types::traits::{Hash, ToField};\n\nmod test;\n\ntrait PublicStorageHistoricalRead {\n    fn public_storage_historical_read(\n        header: BlockHeader,\n        storage_slot: Field,\n        contract_address: AztecAddress,\n    ) -> Field;\n}\n\nimpl PublicStorageHistoricalRead for BlockHeader {\n    fn public_storage_historical_read(\n        self,\n        storage_slot: Field,\n        contract_address: AztecAddress,\n    ) -> Field {\n        // 1) Compute the leaf index by siloing the storage slot with the contract address\n        let public_data_tree_index = poseidon2_hash_with_separator(\n            [contract_address.to_field(), storage_slot],\n            GENERATOR_INDEX__PUBLIC_LEAF_INDEX,\n        );\n\n        // 2) Get the membership witness for the tree index.\n        // Safety: The witness is only used as a \"magical value\" that makes the proof below pass. Hence it's safe.\n        let witness = unsafe {\n            get_public_data_witness(\n                self.global_variables.block_number as u32,\n                public_data_tree_index,\n            )\n        };\n\n        // 3) The witness is made up of two parts: the preimage of the leaf and the proof that it exists in the tree.\n        // We first prove that the witness is indeed valid for the public data tree, i.e. that the preimage is of a\n        // value present in the tree. Note that `hash` returns not just the hash of the value but also the metadata\n        // (slot, next index and next slot).\n        assert_eq(\n            self.state.partial.public_data_tree.root,\n            root_from_sibling_path(witness.leaf_preimage.hash(), witness.index, witness.path),\n            \"Proving public value inclusion failed\",\n        );\n\n        // 4) Now that we know the preimage is valid, we determine the value that's represented by this tree entry. Here\n        // we have two scenarios:\n        // 1. The tree entry is initialized, and the value is the same as the one in the witness\n        // 2. The entry was never initialized, and the value is default zero (the default)\n        // The code below is based on the same checks in `validate_public_data_reads` in `base_rollup_inputs`.\n        let preimage = witness.leaf_preimage;\n\n        let is_less_than_slot = full_field_less_than(preimage.slot, public_data_tree_index);\n        let is_next_greater_than = full_field_less_than(public_data_tree_index, preimage.next_slot);\n        let is_max = ((preimage.next_index == 0) & (preimage.next_slot == 0));\n        let is_in_range = is_less_than_slot & (is_next_greater_than | is_max);\n\n        let value = if is_in_range {\n            0\n        } else {\n            assert_eq(\n                preimage.slot,\n                public_data_tree_index,\n                \"Public data tree index doesn't match witness\",\n            );\n            preimage.value\n        };\n\n        value\n    }\n}\n"
     },
     "121": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/dispatch/mod.nr",
@@ -4123,15 +4123,15 @@
     },
     "128": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr",
-      "source": "use crate::macros::{\n    functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n    notes::NOTES,\n    utils::{\n        add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_initializer, is_fn_internal,\n        is_fn_private, is_fn_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 { let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, args_hasher.hash()); };\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 note discovery, since they may need to access notes. This is slightly inefficient\n    // and could be improved by only doing it once we actually attempt to read any.\n    let note_discovery_call = if NOTES.len() > 0 {\n        create_note_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        $note_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_unconstrained(f: FunctionDefinition) {\n    let context_creation = quote { let mut context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new(); };\n    let module_has_storage = module_has_storage(f.module());\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(context);\n        }\n    } else {\n        quote {}\n    };\n\n    // All unconstrained functions perform note 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 note_discovery_call = if NOTES.len() > 0 {\n        create_note_discovery_call()\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $storage_init\n        $note_discovery_call\n    };\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, quote {});\n    f.set_return_public(true);\n    f.set_body(modified_body);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called internally\";\n    quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called statically\";\n    if is_fn_private(f) {\n        // Here `context` is of type context::PrivateContext\n        quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n    } else {\n        // Here `context` is of type context::PublicContext\n        quote { assert(context.is_static_call(), $assertion_message); }\n    }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\n/// Injects a call to `aztec::discovery::discover_new_notes`, causing for new notes to be added to PXE and made\n/// available for the current execution.\ncomptime fn create_note_discovery_call() -> Quoted {\n    quote {\n        /// Safety: note discovery returns nothing and is performed solely for its side-effects. It is therefore always\n        /// safe to call.\n        unsafe {\n            dep::aztec::discovery::discover_new_notes(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\n            )\n        };\n    }\n}\n"
+      "source": "use crate::macros::{\n    functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n    notes::NOTES,\n    utils::{\n        add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_initializer, is_fn_internal,\n        is_fn_private, 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 note discovery, since they may need to access notes. This is slightly inefficient\n    // and could be improved by only doing it once we actually attempt to read any.\n    let note_discovery_call = if NOTES.len() > 0 {\n        create_note_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        $note_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_unconstrained(f: FunctionDefinition) {\n    let context_creation = quote { let mut context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new(); };\n    let module_has_storage = module_has_storage(f.module());\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(context);\n        }\n    } else {\n        quote {}\n    };\n\n    // All unconstrained functions perform note 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 note_discovery_call = if NOTES.len() > 0 {\n        create_note_discovery_call()\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $storage_init\n        $note_discovery_call\n    };\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, quote {});\n    f.set_return_public(true);\n    f.set_body(modified_body);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called internally\";\n    quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called statically\";\n    if is_fn_private(f) {\n        // Here `context` is of type context::PrivateContext\n        quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n    } else {\n        // Here `context` is of type context::PublicContext\n        quote { assert(context.is_static_call(), $assertion_message); }\n    }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\n/// Injects a call to `aztec::discovery::discover_new_notes`, causing for new notes to be added to PXE and made\n/// available for the current execution.\ncomptime fn create_note_discovery_call() -> Quoted {\n    quote {\n        /// Safety: note discovery returns nothing and is performed solely for its side-effects. It is therefore always\n        /// safe to call.\n        unsafe {\n            dep::aztec::discovery::discover_new_notes(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\n            )\n        };\n    }\n}\n"
     },
     "129": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/mod.nr",
-      "source": "pub mod dispatch;\npub mod functions;\npub mod utils;\npub mod notes;\npub mod storage;\npub mod events;\n\nuse functions::{stub_registry, utils::transform_unconstrained};\nuse notes::{generate_note_export, NOTES};\nuse storage::STORAGE_LAYOUT_NAME;\n\nuse dispatch::generate_public_dispatch;\nuse utils::{get_trait_impl_method, module_has_storage};\n\nuse crate::discovery::MAX_NOTE_PACKED_LEN;\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `process_log` and `sync_notes` functions PXE requires in order to discover notes.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n    let interface = generate_contract_interface(m);\n    let unconstrained_functions = m.functions().filter(|f: FunctionDefinition| {\n        f.is_unconstrained() & !f.has_named_attribute(\"test\") & !f.has_named_attribute(\"public\")\n    });\n    for f in unconstrained_functions {\n        transform_unconstrained(f);\n    }\n\n    let contract_library_method_compute_note_hash_and_nullifier =\n        generate_contract_library_method_compute_note_hash_and_nullifier();\n    let process_log = generate_process_log();\n    let note_exports = generate_note_exports();\n    let public_dispatch = generate_public_dispatch(m);\n    let sync_notes = generate_sync_notes();\n\n    quote {\n        $note_exports\n        $interface\n        $contract_library_method_compute_note_hash_and_nullifier\n        $process_log\n        $public_dispatch\n        $sync_notes\n    }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n    let module_name = m.name();\n    let contract_stubs = stub_registry::get(m);\n    let fn_stubs_quote = if contract_stubs.is_some() {\n        contract_stubs.unwrap().join(quote {})\n    } else {\n        quote {}\n    };\n\n    let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n    let storage_layout_getter = if has_storage_layout {\n        let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n        quote {\n            pub fn storage_layout() -> StorageLayoutFields {\n                $storage_layout_name.fields\n            }\n        }\n    } else {\n        quote {}\n    };\n\n    let library_storage_layout_getter = if has_storage_layout {\n        quote {\n            #[contract_library_method]\n            $storage_layout_getter\n        }\n    } else {\n        quote {}\n    };\n\n    quote {\n        pub struct $module_name {\n            pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n        }\n\n        impl $module_name {\n            $fn_stubs_quote\n\n            pub fn at(\n                addr: aztec::protocol_types::address::AztecAddress\n            ) -> Self {\n                Self { target_contract: addr }\n            }\n\n            pub fn interface() -> Self {\n                Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n            }\n\n            $storage_layout_getter\n        }\n\n        #[contract_library_method]\n        pub fn at(\n            addr: aztec::protocol_types::address::AztecAddress\n        ) -> $module_name {\n            $module_name { target_contract: addr }\n        }\n\n        #[contract_library_method]\n        pub fn interface() -> $module_name {\n            $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n        }\n\n        $library_storage_layout_getter\n\n    }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n    let notes = NOTES.entries();\n\n    let mut max_note_packed_len: u32 = 0;\n    if notes.len() > 0 {\n        max_note_packed_len = notes.fold(\n            0,\n            |acc, (_, (_, len, _, _)): (Type, (StructDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n                if len > acc {\n                    len\n                } else {\n                    acc\n                }\n            },\n        );\n\n        if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n            panic(\n                f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n            );\n        }\n\n        // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n        // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n        // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n        // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n        let mut if_note_type_id_match_statements_list = &[];\n        for i in 0..notes.len() {\n            let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n            let get_note_type_id = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteType },\n                quote { get_id },\n            );\n            let unpack = get_trait_impl_method(\n                typ,\n                quote { crate::protocol_types::traits::Packable<_> },\n                quote { unpack },\n            );\n\n            let compute_note_hash = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_note_hash },\n            );\n\n            let compute_nullifier_unconstrained = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_nullifier_unconstrained },\n            );\n\n            let if_or_else_if = if i == 0 {\n                quote { if }\n            } else {\n                quote { else if }\n            };\n\n            if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n                quote {\n                    $if_or_else_if note_type_id == $get_note_type_id() {\n                        // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n                        // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n                        // unpack function on it.\n                        let expected_len = $packed_note_length;\n                        let actual_len = packed_note.len();\n                        assert(\n                            actual_len == expected_len,\n                            f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n                        );\n\n                        let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n                        let note_hash = $compute_note_hash(note, storage_slot);\n    \n                        // The note discovery process finds settled notes, that is, notes that were created in prior\n                        // transactions and are therefore already part of the note hash tree. We therefore compute the\n                        // nullification note hash by treating the note as a settled note with the provided nonce.\n                        let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n                            aztec::note::retrieved_note::RetrievedNote{ \n                                note, \n                                contract_address, \n                                metadata: aztec::note::note_metadata::SettledNoteMetadata::new(nonce).into() \n                            }, \n                            storage_slot,\n                        );\n\n                        let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullify);\n\n                        Option::some(\n                            aztec::discovery::NoteHashAndNullifier {\n                                note_hash, inner_nullifier\n                            }\n                        )\n                    }\n                },\n            );\n        }\n\n        let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n        quote {\n            /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n            /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n            /// tree with `nonce`.\n            ///\n            /// The signature of this function notably matches the `aztec::discovery::ComputeNoteHashAndNullifier` type,\n            /// and so it can be used to call functions from that module such as `discover_new_notes`, `do_process_log`\n            /// and `process_private_note_log`.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                packed_note: BoundedVec<Field, aztec::discovery::MAX_NOTE_PACKED_LEN>,\n                storage_slot: Field,\n                note_type_id: Field,\n                contract_address: aztec::protocol_types::address::AztecAddress,\n                nonce: Field,\n            ) -> pub Option<aztec::discovery::NoteHashAndNullifier> {\n                $if_note_type_id_match_statements\n                else {\n                    Option::none()\n                }\n            }\n        }\n    } else {\n        // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n        // simply throws immediately.\n        quote {\n            /// This contract does not use private notes, so this function should never be called as it will\n            /// unconditionally fail.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                _packed_note: BoundedVec<Field, aztec::discovery::MAX_NOTE_PACKED_LEN>,\n                _storage_slot: Field,\n                _note_type_id: Field,\n                _contract_address: aztec::protocol_types::address::AztecAddress,\n            ) -> pub Option<aztec::discovery::NoteHashAndNullifier> {\n                panic(f\"This contract does not use private notes\")\n            }\n        }\n    }\n}\n\ncomptime fn generate_process_log() -> Quoted {\n    // This mandatory function processes a log emitted by the contract. This is currently used to process private logs\n    // and perform note discovery of either private notes or partial notes.\n    // The bulk of the work of this function is done by aztec::discovery::do_process_log, so all we need to do is call\n    // that function.\n\n    // We'll produce the entire body of the function in one go and then insert it into the function.\n    let notes = NOTES.entries();\n\n    if notes.len() > 0 {\n        quote {\n            unconstrained fn process_log(\n                log_plaintext: BoundedVec<Field, dep::aztec::protocol_types::constants::PRIVATE_LOG_SIZE_IN_FIELDS>,\n                tx_hash: Field,\n                unique_note_hashes_in_tx: BoundedVec<Field, dep::aztec::protocol_types::constants::MAX_NOTE_HASHES_PER_TX>,\n                first_nullifier_in_tx: Field,\n                recipient: aztec::protocol_types::address::AztecAddress,\n            ) {\n                // Because this unconstrained function is injected after the contract is processed by the macros, it'll not\n                // be modified by the macros that alter unconstrained functions. As such, we need to manually inject the\n                // unconstrained execution context since it will not be available otherwise.\n                let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n                // TODO(#10727): allow other contracts to process logs and deliver notes\n                let contract_address = context.this_address();\n\n                aztec::discovery::private_logs::do_process_log(\n                    contract_address,\n                    log_plaintext,\n                    tx_hash,\n                    unique_note_hashes_in_tx,\n                    first_nullifier_in_tx,\n                    recipient,\n                    _compute_note_hash_and_nullifier,\n                );\n            }\n        }\n    } else {\n        // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n        // simply throws immediately.\n        quote {\n            unconstrained fn process_log(\n                _log_plaintext: BoundedVec<Field, dep::aztec::protocol_types::constants::PRIVATE_LOG_SIZE_IN_FIELDS>,\n                _tx_hash: Field,\n                _unique_note_hashes_in_tx: BoundedVec<Field, dep::aztec::protocol_types::constants::MAX_NOTE_HASHES_PER_TX>,\n                _first_nullifier_in_tx: Field,\n                _recipient: aztec::protocol_types::address::AztecAddress,\n            ) {\n                panic(f\"This contract does not use private notes\")\n            }\n        }\n    }\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n    let notes = NOTES.values();\n    // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n    // generating partial note helper functions.\n    notes\n        .map(|(s, _, note_type_id, fields): (StructDefinition, u32, Field, [(Quoted, u32, bool)])| {\n            generate_note_export(s, note_type_id, fields)\n        })\n        .join(quote {})\n}\n\ncomptime fn generate_sync_notes() -> Quoted {\n    quote {\n        unconstrained fn sync_notes() {\n            aztec::oracle::note_discovery::sync_notes();\n        }\n    }\n}\n"
+      "source": "pub mod dispatch;\npub mod functions;\npub mod utils;\npub mod notes;\npub mod storage;\npub mod events;\n\nuse functions::{stub_registry, utils::transform_unconstrained};\nuse notes::{generate_note_export, NOTES};\nuse storage::STORAGE_LAYOUT_NAME;\n\nuse dispatch::generate_public_dispatch;\nuse utils::{get_trait_impl_method, module_has_storage};\n\nuse crate::discovery::MAX_NOTE_PACKED_LEN;\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `process_log` and `sync_notes` functions PXE requires in order to discover notes.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n    let interface = generate_contract_interface(m);\n    let unconstrained_functions = m.functions().filter(|f: FunctionDefinition| {\n        f.is_unconstrained() & !f.has_named_attribute(\"test\") & !f.has_named_attribute(\"public\")\n    });\n    for f in unconstrained_functions {\n        transform_unconstrained(f);\n    }\n\n    let contract_library_method_compute_note_hash_and_nullifier =\n        generate_contract_library_method_compute_note_hash_and_nullifier();\n    let process_log = generate_process_log();\n    let note_exports = generate_note_exports();\n    let public_dispatch = generate_public_dispatch(m);\n    let sync_notes = generate_sync_notes();\n\n    quote {\n        $note_exports\n        $interface\n        $contract_library_method_compute_note_hash_and_nullifier\n        $process_log\n        $public_dispatch\n        $sync_notes\n    }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n    let module_name = m.name();\n    let contract_stubs = stub_registry::get(m);\n    let fn_stubs_quote = if contract_stubs.is_some() {\n        contract_stubs.unwrap().join(quote {})\n    } else {\n        quote {}\n    };\n\n    let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n    let storage_layout_getter = if has_storage_layout {\n        let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n        quote {\n            pub fn storage_layout() -> StorageLayoutFields {\n                $storage_layout_name.fields\n            }\n        }\n    } else {\n        quote {}\n    };\n\n    let library_storage_layout_getter = if has_storage_layout {\n        quote {\n            #[contract_library_method]\n            $storage_layout_getter\n        }\n    } else {\n        quote {}\n    };\n\n    quote {\n        pub struct $module_name {\n            pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n        }\n\n        impl $module_name {\n            $fn_stubs_quote\n\n            pub fn at(\n                addr: aztec::protocol_types::address::AztecAddress\n            ) -> Self {\n                Self { target_contract: addr }\n            }\n\n            pub fn interface() -> Self {\n                Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n            }\n\n            $storage_layout_getter\n        }\n\n        #[contract_library_method]\n        pub fn at(\n            addr: aztec::protocol_types::address::AztecAddress\n        ) -> $module_name {\n            $module_name { target_contract: addr }\n        }\n\n        #[contract_library_method]\n        pub fn interface() -> $module_name {\n            $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n        }\n\n        $library_storage_layout_getter\n\n    }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n    let notes = NOTES.entries();\n\n    let mut max_note_packed_len: u32 = 0;\n    if notes.len() > 0 {\n        max_note_packed_len = notes.fold(\n            0,\n            |acc, (_, (_, len, _, _)): (Type, (StructDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n                if len > acc {\n                    len\n                } else {\n                    acc\n                }\n            },\n        );\n\n        if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n            panic(\n                f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n            );\n        }\n\n        // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n        // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n        // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n        // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n        let mut if_note_type_id_match_statements_list = &[];\n        for i in 0..notes.len() {\n            let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n            let get_note_type_id = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteType },\n                quote { get_id },\n            );\n            let unpack = get_trait_impl_method(\n                typ,\n                quote { crate::protocol_types::traits::Packable<_> },\n                quote { unpack },\n            );\n\n            let compute_note_hash = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_note_hash },\n            );\n\n            let compute_nullifier_unconstrained = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_nullifier_unconstrained },\n            );\n\n            let if_or_else_if = if i == 0 {\n                quote { if }\n            } else {\n                quote { else if }\n            };\n\n            if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n                quote {\n                    $if_or_else_if note_type_id == $get_note_type_id() {\n                        // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n                        // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n                        // unpack function on it.\n                        let expected_len = $packed_note_length;\n                        let actual_len = packed_note.len();\n                        assert(\n                            actual_len == expected_len,\n                            f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n                        );\n\n                        let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n                        let note_hash = $compute_note_hash(note, storage_slot);\n    \n                        // The note discovery process finds settled notes, that is, notes that were created in prior\n                        // transactions and are therefore already part of the note hash tree. We therefore compute the\n                        // nullification note hash by treating the note as a settled note with the provided nonce.\n                        let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n                            aztec::note::retrieved_note::RetrievedNote{ \n                                note, \n                                contract_address, \n                                metadata: aztec::note::note_metadata::SettledNoteMetadata::new(nonce).into() \n                            }, \n                            storage_slot,\n                        );\n\n                        let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullify);\n\n                        Option::some(\n                            aztec::discovery::NoteHashAndNullifier {\n                                note_hash, inner_nullifier\n                            }\n                        )\n                    }\n                },\n            );\n        }\n\n        let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n        quote {\n            /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n            /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n            /// tree with `nonce`.\n            ///\n            /// The signature of this function notably matches the `aztec::discovery::ComputeNoteHashAndNullifier` type,\n            /// and so it can be used to call functions from that module such as `discover_new_notes`, `do_process_log`\n            /// and `process_private_note_log`.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                packed_note: BoundedVec<Field, aztec::discovery::MAX_NOTE_PACKED_LEN>,\n                storage_slot: Field,\n                note_type_id: Field,\n                contract_address: aztec::protocol_types::address::AztecAddress,\n                nonce: Field,\n            ) -> Option<aztec::discovery::NoteHashAndNullifier> {\n                $if_note_type_id_match_statements\n                else {\n                    Option::none()\n                }\n            }\n        }\n    } else {\n        // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n        // simply throws immediately.\n        quote {\n            /// This contract does not use private notes, so this function should never be called as it will\n            /// unconditionally fail.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                _packed_note: BoundedVec<Field, aztec::discovery::MAX_NOTE_PACKED_LEN>,\n                _storage_slot: Field,\n                _note_type_id: Field,\n                _contract_address: aztec::protocol_types::address::AztecAddress,\n            ) -> pub Option<aztec::discovery::NoteHashAndNullifier> {\n                panic(f\"This contract does not use private notes\")\n            }\n        }\n    }\n}\n\ncomptime fn generate_process_log() -> Quoted {\n    // This mandatory function processes a log emitted by the contract. This is currently used to process private logs\n    // and perform note discovery of either private notes or partial notes.\n    // The bulk of the work of this function is done by aztec::discovery::do_process_log, so all we need to do is call\n    // that function.\n\n    // We'll produce the entire body of the function in one go and then insert it into the function.\n    let notes = NOTES.entries();\n\n    if notes.len() > 0 {\n        quote {\n            unconstrained fn process_log(\n                log_plaintext: BoundedVec<Field, dep::aztec::protocol_types::constants::PRIVATE_LOG_SIZE_IN_FIELDS>,\n                tx_hash: Field,\n                unique_note_hashes_in_tx: BoundedVec<Field, dep::aztec::protocol_types::constants::MAX_NOTE_HASHES_PER_TX>,\n                first_nullifier_in_tx: Field,\n                recipient: aztec::protocol_types::address::AztecAddress,\n            ) {\n                // Because this unconstrained function is injected after the contract is processed by the macros, it'll not\n                // be modified by the macros that alter unconstrained functions. As such, we need to manually inject the\n                // unconstrained execution context since it will not be available otherwise.\n                let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n                // TODO(#10727): allow other contracts to process logs and deliver notes\n                let contract_address = context.this_address();\n\n                aztec::discovery::private_logs::do_process_log(\n                    contract_address,\n                    log_plaintext,\n                    tx_hash,\n                    unique_note_hashes_in_tx,\n                    first_nullifier_in_tx,\n                    recipient,\n                    _compute_note_hash_and_nullifier,\n                );\n            }\n        }\n    } else {\n        // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n        // simply throws immediately.\n        quote {\n            unconstrained fn process_log(\n                _log_plaintext: BoundedVec<Field, dep::aztec::protocol_types::constants::PRIVATE_LOG_SIZE_IN_FIELDS>,\n                _tx_hash: Field,\n                _unique_note_hashes_in_tx: BoundedVec<Field, dep::aztec::protocol_types::constants::MAX_NOTE_HASHES_PER_TX>,\n                _first_nullifier_in_tx: Field,\n                _recipient: aztec::protocol_types::address::AztecAddress,\n            ) {\n                panic(f\"This contract does not use private notes\")\n            }\n        }\n    }\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n    let notes = NOTES.values();\n    // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n    // generating partial note helper functions.\n    notes\n        .map(|(s, _, note_type_id, fields): (StructDefinition, u32, Field, [(Quoted, u32, bool)])| {\n            generate_note_export(s, note_type_id, fields)\n        })\n        .join(quote {})\n}\n\ncomptime fn generate_sync_notes() -> Quoted {\n    quote {\n        unconstrained fn sync_notes() {\n            aztec::oracle::note_discovery::sync_notes();\n        }\n    }\n}\n"
     },
     "131": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/storage/mod.nr",
-      "source": "use std::{collections::umap::UHashMap, hash::{BuildHasherDefault, poseidon2::Poseidon2Hasher}};\n\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: StructDefinition) -> 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: StructDefinition) {\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_struct().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_struct().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_struct().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_struct().is_some() {\n        let (def, generics) = typ.as_struct().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_struct().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 std::{collections::umap::UHashMap, hash::{BuildHasherDefault, poseidon2::Poseidon2Hasher}};\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: StructDefinition) -> 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: StructDefinition) {\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_struct().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_struct().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_struct().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_struct().is_some() {\n        let (def, generics) = typ.as_struct().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_struct().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"
     },
     "133": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messaging.nr",
@@ -4163,7 +4163,7 @@
     },
     "166": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/storage.nr",
-      "source": "use dep::protocol_types::{address::AztecAddress, traits::Packable};\n\n#[oracle(storageRead)]\nunconstrained fn storage_read_oracle<let N: u32>(\n    address: Field,\n    storage_slot: Field,\n    block_number: Field,\n    length: Field,\n) -> [Field; N] {}\n\npub unconstrained fn raw_storage_read<let N: u32>(\n    address: AztecAddress,\n    storage_slot: Field,\n    block_number: u32,\n) -> [Field; N] {\n    storage_read_oracle(\n        address.to_field(),\n        storage_slot,\n        block_number as Field,\n        N as Field,\n    )\n}\n\npub unconstrained fn storage_read<T, let N: u32>(\n    address: AztecAddress,\n    storage_slot: Field,\n    block_number: u32,\n) -> T\nwhere\n    T: Packable<N>,\n{\n    T::unpack(raw_storage_read(address, storage_slot, block_number))\n}\n\nmod tests {\n    use crate::oracle::storage::{raw_storage_read, storage_read};\n    use dep::protocol_types::{address::AztecAddress, traits::{FromField, Packable}};\n\n    use crate::test::mocks::mock_struct::MockStruct;\n    use std::test::OracleMock;\n\n    global address: AztecAddress = AztecAddress::from_field(29);\n    global slot: Field = 7;\n    global block_number: u32 = 17;\n\n    #[test]\n    unconstrained fn test_raw_storage_read() {\n        let written = MockStruct { a: 13, b: 42 };\n\n        let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n        let read: [Field; 2] = raw_storage_read(address, slot, block_number);\n        assert_eq(read[0], 13);\n        assert_eq(read[1], 42);\n    }\n\n    #[test]\n    unconstrained fn test_storage_read() {\n        let written = MockStruct { a: 13, b: 42 };\n\n        let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n        let read: MockStruct = storage_read(address, slot, block_number);\n        assert_eq(read.a, 13);\n        assert_eq(read.b, 42);\n    }\n}\n"
+      "source": "use dep::protocol_types::{address::AztecAddress, traits::{Packable, ToField}};\n\n#[oracle(storageRead)]\nunconstrained fn storage_read_oracle<let N: u32>(\n    address: Field,\n    storage_slot: Field,\n    block_number: Field,\n    length: Field,\n) -> [Field; N] {}\n\npub unconstrained fn raw_storage_read<let N: u32>(\n    address: AztecAddress,\n    storage_slot: Field,\n    block_number: u32,\n) -> [Field; N] {\n    storage_read_oracle(\n        address.to_field(),\n        storage_slot,\n        block_number as Field,\n        N as Field,\n    )\n}\n\npub unconstrained fn storage_read<T, let N: u32>(\n    address: AztecAddress,\n    storage_slot: Field,\n    block_number: u32,\n) -> T\nwhere\n    T: Packable<N>,\n{\n    T::unpack(raw_storage_read(address, storage_slot, block_number))\n}\n\nmod tests {\n    use crate::oracle::storage::{raw_storage_read, storage_read};\n    use dep::protocol_types::{address::AztecAddress, traits::{FromField, Packable}};\n\n    use crate::test::mocks::mock_struct::MockStruct;\n    use std::test::OracleMock;\n\n    global address: AztecAddress = AztecAddress::from_field(29);\n    global slot: Field = 7;\n    global block_number: u32 = 17;\n\n    #[test]\n    unconstrained fn test_raw_storage_read() {\n        let written = MockStruct { a: 13, b: 42 };\n\n        let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n        let read: [Field; 2] = raw_storage_read(address, slot, block_number);\n        assert_eq(read[0], 13);\n        assert_eq(read[1], 42);\n    }\n\n    #[test]\n    unconstrained fn test_storage_read() {\n        let written = MockStruct { a: 13, b: 42 };\n\n        let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n        let read: MockStruct = storage_read(address, slot, block_number);\n        assert_eq(read.a, 13);\n        assert_eq(read.b, 42);\n    }\n}\n"
     },
     "168": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/state_vars/map.nr",
@@ -4191,7 +4191,7 @@
     },
     "202": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/with_hash.nr",
-      "source": "use crate::{\n    context::{PublicContext, UnconstrainedContext},\n    history::public_storage::PublicStorageHistoricalRead,\n    oracle,\n};\nuse dep::protocol_types::{\n    address::AztecAddress, block_header::BlockHeader, hash::poseidon2_hash, traits::Packable,\n};\n\n/// A struct that allows for efficient reading of value `T` from public storage in private.\n///\n/// The efficient reads are achieved by verifying large values through a single hash check\n/// and then proving inclusion only of the hash in public storage. This reduces the number\n/// of required tree inclusion proofs from `N` to 1.\n///\n/// # Type Parameters\n/// - `T`: The underlying type being wrapped, must implement `Packable<N>`\n/// - `N`: The number of field elements required to pack values of type `T`\npub struct WithHash<T, let N: u32> {\n    value: T,\n    packed: [Field; N],\n    hash: Field,\n}\n\nimpl<T, let N: u32> WithHash<T, N>\nwhere\n    T: Packable<N> + Eq,\n{\n    pub fn new(value: T) -> Self {\n        let packed = value.pack();\n        Self { value, packed, hash: poseidon2_hash(packed) }\n    }\n\n    pub fn get_value(self) -> T {\n        self.value\n    }\n\n    pub fn get_hash(self) -> Field {\n        self.hash\n    }\n\n    pub fn public_storage_read(context: PublicContext, storage_slot: Field) -> T {\n        context.storage_read(storage_slot)\n    }\n\n    pub unconstrained fn unconstrained_public_storage_read(\n        context: UnconstrainedContext,\n        storage_slot: Field,\n    ) -> T {\n        context.storage_read(storage_slot)\n    }\n\n    pub fn historical_public_storage_read(\n        header: BlockHeader,\n        address: AztecAddress,\n        storage_slot: Field,\n    ) -> T {\n        let historical_block_number = header.global_variables.block_number as u32;\n\n        // We could simply produce historical inclusion proofs for each field in `packed`, but that would require one\n        // full sibling path per storage slot (since due to kernel siloing the storage is not contiguous). Instead, we\n        // get an oracle to provide us the values, and instead we prove inclusion of their hash, which is both a much\n        // smaller proof (a single slot), and also independent of the size of T (except in that we need to pack and hash T).\n        let hint = WithHash::new(\n            // Safety: We verify that a hash of the hint/packed data matches the stored hash.\n            unsafe {\n                oracle::storage::storage_read(address, storage_slot, historical_block_number)\n            },\n        );\n\n        let hash = header.public_storage_historical_read(storage_slot + N as Field, address);\n\n        if hash != 0 {\n            assert_eq(hash, hint.get_hash(), \"Hint values do not match hash\");\n        } else {\n            // The hash slot can only hold a zero if it is uninitialized. Therefore, the hints must then be zero\n            // (i.e. the default value for public storage) as well.\n            assert_eq(\n                hint.get_value(),\n                T::unpack(std::mem::zeroed()),\n                \"Non-zero hint for zero hash\",\n            );\n        };\n\n        hint.get_value()\n    }\n}\n\nimpl<T, let N: u32> Packable<N + 1> for WithHash<T, N>\nwhere\n    T: Packable<N>,\n{\n    fn pack(self) -> [Field; N + 1] {\n        let mut result: [Field; N + 1] = std::mem::zeroed();\n        for i in 0..N {\n            result[i] = self.packed[i];\n        }\n        result[N] = self.hash;\n\n        result\n    }\n\n    fn unpack(packed: [Field; N + 1]) -> Self {\n        let mut value_packed: [Field; N] = std::mem::zeroed();\n        for i in 0..N {\n            value_packed[i] = packed[i];\n        }\n        let hash = packed[N];\n\n        Self { value: T::unpack(value_packed), packed: value_packed, hash }\n    }\n}\n\nmod test {\n    use crate::{\n        oracle::random::random,\n        test::{\n            helpers::{cheatcodes, test_environment::TestEnvironment},\n            mocks::mock_struct::MockStruct,\n        },\n        utils::with_hash::WithHash,\n    };\n    use dep::protocol_types::hash::poseidon2_hash;\n    use dep::std::{mem, test::OracleMock};\n\n    global storage_slot: Field = 47;\n\n    #[test]\n    unconstrained fn create_and_recover() {\n        let value = MockStruct { a: 5, b: 3 };\n        let value_with_hash = WithHash::new(value);\n        let recovered = WithHash::unpack(value_with_hash.pack());\n\n        assert_eq(recovered.value, value);\n        assert_eq(recovered.packed, value.pack());\n        assert_eq(recovered.hash, poseidon2_hash(value.pack()));\n    }\n\n    #[test]\n    unconstrained fn read_uninitialized_value() {\n        let mut env = TestEnvironment::new();\n\n        let block_header = env.private().historical_header;\n        let address = env.contract_address();\n\n        let result = WithHash::<MockStruct, _>::historical_public_storage_read(\n            block_header,\n            address,\n            storage_slot,\n        );\n\n        // We should get zeroed value\n        let expected: MockStruct = mem::zeroed();\n        assert_eq(result, expected);\n    }\n\n    #[test]\n    unconstrained fn read_initialized_value() {\n        let mut env = TestEnvironment::new();\n\n        let value = MockStruct { a: 5, b: 3 };\n        let value_with_hash = WithHash::new(value);\n\n        // We write the value with hash to storage\n        cheatcodes::direct_storage_write(\n            env.contract_address(),\n            storage_slot,\n            value_with_hash.pack(),\n        );\n\n        // We advance block by 1 because env.private() currently returns context at latest_block - 1\n        env.advance_block_by(1);\n\n        let result = WithHash::<MockStruct, _>::historical_public_storage_read(\n            env.private().historical_header,\n            env.contract_address(),\n            storage_slot,\n        );\n\n        assert_eq(result, value);\n    }\n\n    #[test(should_fail_with = \"Non-zero hint for zero hash\")]\n    unconstrained fn test_bad_hint_uninitialized_value() {\n        let mut env = TestEnvironment::new();\n\n        env.advance_block_to(6);\n\n        let value_packed = MockStruct { a: 1, b: 1 }.pack();\n\n        let block_header = env.private().historical_header;\n        let address = env.contract_address();\n\n        // Mock the oracle to return a non-zero hint/packed value\n        let _ = OracleMock::mock(\"storageRead\")\n            .with_params((\n                address.to_field(), storage_slot, block_header.global_variables.block_number as u32,\n                value_packed.len(),\n            ))\n            .returns(value_packed)\n            .times(1);\n\n        // This should revert because the hint value is non-zero and the hash is zero (default value of storage)\n        let _ = WithHash::<MockStruct, _>::historical_public_storage_read(\n            block_header,\n            address,\n            storage_slot,\n        );\n    }\n\n    #[test(should_fail_with = \"Hint values do not match hash\")]\n    unconstrained fn test_bad_hint_initialized_value() {\n        let mut env = TestEnvironment::new();\n\n        let value_packed = MockStruct { a: 5, b: 3 }.pack();\n\n        // We write the value to storage\n        cheatcodes::direct_storage_write(env.contract_address(), storage_slot, value_packed);\n\n        // Now we write incorrect hash to the hash storage slot\n        let incorrect_hash = random();\n        let hash_storage_slot = storage_slot + (value_packed.len() as Field);\n        cheatcodes::direct_storage_write(\n            env.contract_address(),\n            hash_storage_slot,\n            [incorrect_hash],\n        );\n\n        // We advance block by 1 because env.private() currently returns context at latest_block - 1\n        env.advance_block_by(1);\n\n        let _ = WithHash::<MockStruct, _>::historical_public_storage_read(\n            env.private().historical_header,\n            env.contract_address(),\n            storage_slot,\n        );\n    }\n}\n"
+      "source": "use crate::{\n    context::{PublicContext, UnconstrainedContext},\n    history::public_storage::PublicStorageHistoricalRead,\n    oracle,\n};\nuse dep::protocol_types::{\n    address::AztecAddress, block_header::BlockHeader, hash::poseidon2_hash, traits::Packable,\n};\n\n/// A struct that allows for efficient reading of value `T` from public storage in private.\n///\n/// The efficient reads are achieved by verifying large values through a single hash check\n/// and then proving inclusion only of the hash in public storage. This reduces the number\n/// of required tree inclusion proofs from `N` to 1.\n///\n/// # Type Parameters\n/// - `T`: The underlying type being wrapped, must implement `Packable<N>`\n/// - `N`: The number of field elements required to pack values of type `T`\npub struct WithHash<T, let N: u32> {\n    value: T,\n    packed: [Field; N],\n    hash: Field,\n}\n\nimpl<T, let N: u32> WithHash<T, N>\nwhere\n    T: Packable<N> + Eq,\n{\n    pub fn new(value: T) -> Self {\n        let packed = value.pack();\n        Self { value, packed, hash: poseidon2_hash(packed) }\n    }\n\n    pub fn get_value(self) -> T {\n        self.value\n    }\n\n    pub fn get_hash(self) -> Field {\n        self.hash\n    }\n\n    pub fn public_storage_read(context: PublicContext, storage_slot: Field) -> T {\n        context.storage_read(storage_slot)\n    }\n\n    pub unconstrained fn unconstrained_public_storage_read(\n        context: UnconstrainedContext,\n        storage_slot: Field,\n    ) -> T {\n        context.storage_read(storage_slot)\n    }\n\n    pub fn historical_public_storage_read(\n        header: BlockHeader,\n        address: AztecAddress,\n        storage_slot: Field,\n    ) -> T {\n        let historical_block_number = header.global_variables.block_number as u32;\n\n        // We could simply produce historical inclusion proofs for each field in `packed`, but that would require one\n        // full sibling path per storage slot (since due to kernel siloing the storage is not contiguous). Instead, we\n        // get an oracle to provide us the values, and instead we prove inclusion of their hash, which is both a much\n        // smaller proof (a single slot), and also independent of the size of T (except in that we need to pack and hash T).\n        let hint = WithHash::new(\n            // Safety: We verify that a hash of the hint/packed data matches the stored hash.\n            unsafe {\n                oracle::storage::storage_read(address, storage_slot, historical_block_number)\n            },\n        );\n\n        let hash = header.public_storage_historical_read(storage_slot + N as Field, address);\n\n        if hash != 0 {\n            assert_eq(hash, hint.get_hash(), \"Hint values do not match hash\");\n        } else {\n            // The hash slot can only hold a zero if it is uninitialized. Therefore, the hints must then be zero\n            // (i.e. the default value for public storage) as well.\n            assert_eq(\n                hint.get_value(),\n                T::unpack(std::mem::zeroed()),\n                \"Non-zero hint for zero hash\",\n            );\n        };\n\n        hint.get_value()\n    }\n}\n\nimpl<T, let N: u32> Packable<N + 1> for WithHash<T, N>\nwhere\n    T: Packable<N>,\n{\n    fn pack(self) -> [Field; N + 1] {\n        let mut result: [Field; N + 1] = std::mem::zeroed();\n        for i in 0..N {\n            result[i] = self.packed[i];\n        }\n        result[N] = self.hash;\n\n        result\n    }\n\n    fn unpack(packed: [Field; N + 1]) -> Self {\n        let mut value_packed: [Field; N] = std::mem::zeroed();\n        for i in 0..N {\n            value_packed[i] = packed[i];\n        }\n        let hash = packed[N];\n\n        Self { value: T::unpack(value_packed), packed: value_packed, hash }\n    }\n}\n\nmod test {\n    use crate::{\n        oracle::random::random,\n        test::{\n            helpers::{cheatcodes, test_environment::TestEnvironment},\n            mocks::mock_struct::MockStruct,\n        },\n        utils::with_hash::WithHash,\n    };\n    use dep::protocol_types::hash::poseidon2_hash;\n    use dep::protocol_types::traits::{Packable, ToField};\n    use dep::std::{mem, test::OracleMock};\n\n    global storage_slot: Field = 47;\n\n    #[test]\n    unconstrained fn create_and_recover() {\n        let value = MockStruct { a: 5, b: 3 };\n        let value_with_hash = WithHash::new(value);\n        let recovered = WithHash::unpack(value_with_hash.pack());\n\n        assert_eq(recovered.value, value);\n        assert_eq(recovered.packed, value.pack());\n        assert_eq(recovered.hash, poseidon2_hash(value.pack()));\n    }\n\n    #[test]\n    unconstrained fn read_uninitialized_value() {\n        let mut env = TestEnvironment::new();\n\n        let block_header = env.private().historical_header;\n        let address = env.contract_address();\n\n        let result = WithHash::<MockStruct, _>::historical_public_storage_read(\n            block_header,\n            address,\n            storage_slot,\n        );\n\n        // We should get zeroed value\n        let expected: MockStruct = mem::zeroed();\n        assert_eq(result, expected);\n    }\n\n    #[test]\n    unconstrained fn read_initialized_value() {\n        let mut env = TestEnvironment::new();\n\n        let value = MockStruct { a: 5, b: 3 };\n        let value_with_hash = WithHash::new(value);\n\n        // We write the value with hash to storage\n        cheatcodes::direct_storage_write(\n            env.contract_address(),\n            storage_slot,\n            value_with_hash.pack(),\n        );\n\n        // We advance block by 1 because env.private() currently returns context at latest_block - 1\n        env.advance_block_by(1);\n\n        let result = WithHash::<MockStruct, _>::historical_public_storage_read(\n            env.private().historical_header,\n            env.contract_address(),\n            storage_slot,\n        );\n\n        assert_eq(result, value);\n    }\n\n    #[test(should_fail_with = \"Non-zero hint for zero hash\")]\n    unconstrained fn test_bad_hint_uninitialized_value() {\n        let mut env = TestEnvironment::new();\n\n        env.advance_block_to(6);\n\n        let value_packed = MockStruct { a: 1, b: 1 }.pack();\n\n        let block_header = env.private().historical_header;\n        let address = env.contract_address();\n\n        // Mock the oracle to return a non-zero hint/packed value\n        let _ = OracleMock::mock(\"storageRead\")\n            .with_params((\n                address.to_field(), storage_slot, block_header.global_variables.block_number as u32,\n                value_packed.len(),\n            ))\n            .returns(value_packed)\n            .times(1);\n\n        // This should revert because the hint value is non-zero and the hash is zero (default value of storage)\n        let _ = WithHash::<MockStruct, _>::historical_public_storage_read(\n            block_header,\n            address,\n            storage_slot,\n        );\n    }\n\n    #[test(should_fail_with = \"Hint values do not match hash\")]\n    unconstrained fn test_bad_hint_initialized_value() {\n        let mut env = TestEnvironment::new();\n\n        let value_packed = MockStruct { a: 5, b: 3 }.pack();\n\n        // We write the value to storage\n        cheatcodes::direct_storage_write(env.contract_address(), storage_slot, value_packed);\n\n        // Now we write incorrect hash to the hash storage slot\n        let incorrect_hash = random();\n        let hash_storage_slot = storage_slot + (value_packed.len() as Field);\n        cheatcodes::direct_storage_write(\n            env.contract_address(),\n            hash_storage_slot,\n            [incorrect_hash],\n        );\n\n        // We advance block by 1 because env.private() currently returns context at latest_block - 1\n        env.advance_block_by(1);\n\n        let _ = WithHash::<MockStruct, _>::historical_public_storage_read(\n            env.private().historical_header,\n            env.contract_address(),\n            storage_slot,\n        );\n    }\n}\n"
     },
     "25": {
       "path": "std/hash/poseidon2.nr",
@@ -4259,11 +4259,11 @@
     },
     "61": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/fee_juice_contract/src/lib.nr",
-      "source": "use dep::aztec::context::PublicContext;\nuse dep::aztec::prelude::AztecAddress;\nuse dep::aztec::protocol_types::hash::sha256_to_field;\n\npub fn calculate_fee<TPublicContext>(context: PublicContext) -> Field {\n    context.transaction_fee()\n}\n\npub fn get_bridge_gas_msg_hash(owner: AztecAddress, amount: u128) -> Field {\n    let mut hash_bytes = [0; 68];\n    let recipient_bytes: [u8; 32] = owner.to_field().to_be_bytes();\n    let amount_bytes: [u8; 32] = (amount as Field).to_be_bytes();\n\n    // The purpose of including the following selector is to make the message unique to that specific call. Note that\n    // it has nothing to do with calling the function.\n    let selector = comptime { keccak256::keccak256(\"claim(bytes32,uint256)\".as_bytes(), 22) };\n\n    for i in 0..4 {\n        hash_bytes[i] = selector[i];\n    }\n\n    for i in 0..32 {\n        hash_bytes[i + 4] = recipient_bytes[i];\n        hash_bytes[i + 36] = amount_bytes[i];\n    }\n\n    let content_hash = sha256_to_field(hash_bytes);\n    content_hash\n}\n"
+      "source": "use dep::aztec::context::PublicContext;\nuse dep::aztec::prelude::AztecAddress;\nuse dep::aztec::protocol_types::hash::sha256_to_field;\nuse dep::aztec::protocol_types::traits::ToField;\n\npub fn calculate_fee<TPublicContext>(context: PublicContext) -> Field {\n    context.transaction_fee()\n}\n\npub fn get_bridge_gas_msg_hash(owner: AztecAddress, amount: u128) -> Field {\n    let mut hash_bytes = [0; 68];\n    let recipient_bytes: [u8; 32] = owner.to_field().to_be_bytes();\n    let amount_bytes: [u8; 32] = (amount as Field).to_be_bytes();\n\n    // The purpose of including the following selector is to make the message unique to that specific call. Note that\n    // it has nothing to do with calling the function.\n    let selector = comptime { keccak256::keccak256(\"claim(bytes32,uint256)\".as_bytes(), 22) };\n\n    for i in 0..4 {\n        hash_bytes[i] = selector[i];\n    }\n\n    for i in 0..32 {\n        hash_bytes[i + 4] = recipient_bytes[i];\n        hash_bytes[i + 36] = amount_bytes[i];\n    }\n\n    let content_hash = sha256_to_field(hash_bytes);\n    content_hash\n}\n"
     },
     "62": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/fee_juice_contract/src/main.nr",
-      "source": "mod lib;\n\nuse dep::aztec::macros::aztec;\n\n#[aztec]\npub contract FeeJuice {\n    use dep::aztec::{\n        macros::{functions::{internal, private, public, view}, storage::storage},\n        protocol_types::address::{AztecAddress, EthAddress},\n        state_vars::{Map, PublicImmutable, PublicMutable},\n    };\n\n    use crate::lib::get_bridge_gas_msg_hash;\n\n    #[storage]\n    struct Storage<Context> {\n        // This map is accessed directly by protocol circuits to check balances for fee payment.\n        // Do not change this storage layout unless you also update the base rollup circuits.\n        balances: Map<AztecAddress, PublicMutable<u128, Context>, Context>,\n        portal_address: PublicImmutable<EthAddress, Context>,\n    }\n\n    // Not flagged as initializer to reduce cost of checking init nullifier in all functions.\n    // This function should be called as entrypoint to initialize the contract by minting itself funds.\n    #[private]\n    fn initialize(portal_address: EthAddress, initial_mint: u128) {\n        // Validate contract class parameters are correct\n        let self = context.this_address();\n\n        // Increase self balance and set as fee payer, and end setup\n        FeeJuice::at(self)._increase_public_balance(self, initial_mint).enqueue(&mut context);\n        context.set_as_fee_payer();\n        context.end_setup();\n\n        // Enqueue call to set the portal address\n        FeeJuice::at(self).set_portal(portal_address).enqueue(&mut context);\n    }\n\n    // We purposefully not set this function as an initializer so we do not bind\n    // the contract to a specific L1 portal address, since the Fee Juice address\n    // is a hardcoded constant in the rollup circuits.\n    #[public]\n    fn set_portal(portal_address: EthAddress) {\n        assert(storage.portal_address.read().is_zero());\n        storage.portal_address.initialize(portal_address);\n    }\n\n    #[private]\n    fn claim(to: AztecAddress, amount: u128, secret: Field, message_leaf_index: Field) {\n        let content_hash = get_bridge_gas_msg_hash(to, amount);\n        let portal_address = storage.portal_address.read();\n        assert(!portal_address.is_zero());\n\n        // Consume message and emit nullifier\n        context.consume_l1_to_l2_message(content_hash, secret, portal_address, message_leaf_index);\n\n        // TODO(palla/gas) Emit an unencrypted log to announce which L1 to L2 message has been claimed\n        // Otherwise, we cannot trace L1 deposits to their corresponding claims on L2\n        FeeJuice::at(context.this_address())._increase_public_balance(to, amount).enqueue(\n            &mut context,\n        );\n    }\n\n    #[public]\n    #[internal]\n    fn _increase_public_balance(to: AztecAddress, amount: u128) {\n        let new_balance = storage.balances.at(to).read().add(amount);\n        storage.balances.at(to).write(new_balance);\n    }\n\n    #[public]\n    #[view]\n    fn check_balance(fee_limit: u128) {\n        assert(storage.balances.at(context.msg_sender()).read() >= fee_limit, \"Balance too low\");\n    }\n\n    // utility function for testing\n    #[public]\n    #[view]\n    fn balance_of_public(owner: AztecAddress) -> pub u128 {\n        storage.balances.at(owner).read()\n    }\n}\n"
+      "source": "mod lib;\n\nuse dep::aztec::macros::aztec;\n\n#[aztec]\npub contract FeeJuice {\n    use dep::aztec::{\n        macros::{functions::{internal, private, public, view}, storage::storage},\n        protocol_types::address::{AztecAddress, EthAddress},\n        state_vars::{Map, PublicImmutable, PublicMutable},\n    };\n\n    use crate::lib::get_bridge_gas_msg_hash;\n    use std::ops::Add;\n\n    #[storage]\n    struct Storage<Context> {\n        // This map is accessed directly by protocol circuits to check balances for fee payment.\n        // Do not change this storage layout unless you also update the base rollup circuits.\n        balances: Map<AztecAddress, PublicMutable<u128, Context>, Context>,\n        portal_address: PublicImmutable<EthAddress, Context>,\n    }\n\n    // Not flagged as initializer to reduce cost of checking init nullifier in all functions.\n    // This function should be called as entrypoint to initialize the contract by minting itself funds.\n    #[private]\n    fn initialize(portal_address: EthAddress, initial_mint: u128) {\n        // Validate contract class parameters are correct\n        let self = context.this_address();\n\n        // Increase self balance and set as fee payer, and end setup\n        FeeJuice::at(self)._increase_public_balance(self, initial_mint).enqueue(&mut context);\n        context.set_as_fee_payer();\n        context.end_setup();\n\n        // Enqueue call to set the portal address\n        FeeJuice::at(self).set_portal(portal_address).enqueue(&mut context);\n    }\n\n    // We purposefully not set this function as an initializer so we do not bind\n    // the contract to a specific L1 portal address, since the Fee Juice address\n    // is a hardcoded constant in the rollup circuits.\n    #[public]\n    fn set_portal(portal_address: EthAddress) {\n        assert(storage.portal_address.read().is_zero());\n        storage.portal_address.initialize(portal_address);\n    }\n\n    #[private]\n    fn claim(to: AztecAddress, amount: u128, secret: Field, message_leaf_index: Field) {\n        let content_hash = get_bridge_gas_msg_hash(to, amount);\n        let portal_address = storage.portal_address.read();\n        assert(!portal_address.is_zero());\n\n        // Consume message and emit nullifier\n        context.consume_l1_to_l2_message(content_hash, secret, portal_address, message_leaf_index);\n\n        // TODO(palla/gas) Emit an unencrypted log to announce which L1 to L2 message has been claimed\n        // Otherwise, we cannot trace L1 deposits to their corresponding claims on L2\n        FeeJuice::at(context.this_address())._increase_public_balance(to, amount).enqueue(\n            &mut context,\n        );\n    }\n\n    #[public]\n    #[internal]\n    fn _increase_public_balance(to: AztecAddress, amount: u128) {\n        let new_balance = storage.balances.at(to).read().add(amount);\n        storage.balances.at(to).write(new_balance);\n    }\n\n    #[public]\n    #[view]\n    fn check_balance(fee_limit: u128) {\n        assert(storage.balances.at(context.msg_sender()).read() >= fee_limit, \"Balance too low\");\n    }\n\n    // utility function for testing\n    #[public]\n    #[view]\n    fn balance_of_public(owner: AztecAddress) -> pub u128 {\n        storage.balances.at(owner).read()\n    }\n}\n"
     },
     "73": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr",
@@ -4271,11 +4271,11 @@
     },
     "80": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
-      "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        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, PUBLIC_DISPATCH_SELECTOR,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn 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        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        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        execution_cache::store(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n\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],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\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);\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 args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_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    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle hashes the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = unsafe {\n            enqueue_public_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.set_public_teardown_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_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    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle hashes the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = unsafe {\n            set_public_teardown_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
+      "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        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, PUBLIC_DISPATCH_SELECTOR,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::{Empty, FromField, Hash, ToField},\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        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        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        execution_cache::store(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n\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],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\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);\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 args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_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    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle hashes the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = unsafe {\n            enqueue_public_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.set_public_teardown_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_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    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle hashes the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = unsafe {\n            set_public_teardown_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
     },
     "81": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/public_context.nr",
-      "source": "use crate::context::gas::GasOpts;\nuse crate::hash::{\n    compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n};\nuse dep::protocol_types::abis::function_selector::FunctionSelector;\nuse dep::protocol_types::address::{AztecAddress, EthAddress};\nuse dep::protocol_types::constants::MAX_FIELD_VALUE;\nuse dep::protocol_types::traits::{Empty, Packable, Serialize};\n\npub struct PublicContext {\n    pub args_hash: Option<Field>,\n    pub compute_args_hash: fn() -> Field,\n}\n\nimpl PublicContext {\n    pub fn new(compute_args_hash: fn() -> Field) -> Self {\n        PublicContext { args_hash: Option::none(), compute_args_hash }\n    }\n\n    pub fn emit_public_log<T, let N: u32>(_self: &mut Self, log: T)\n    where\n        T: Serialize<N>,\n    {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_public_log(Serialize::serialize(log).as_slice()) };\n    }\n\n    pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { note_hash_exists(note_hash, leaf_index) } == 1\n    }\n\n    pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { l1_to_l2_msg_exists(msg_hash, msg_leaf_index) } == 1\n    }\n\n    pub fn nullifier_exists(_self: Self, unsiloed_nullifier: Field, address: AztecAddress) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { nullifier_exists(unsiloed_nullifier, address.to_field()) } == 1\n    }\n\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        let secret_hash = compute_secret_hash(secret);\n        let message_hash = compute_l1_to_l2_message_hash(\n            sender,\n            self.chain_id(),\n            /*recipient=*/\n            self.this_address(),\n            self.version(),\n            content,\n            secret_hash,\n            leaf_index,\n        );\n        let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n        assert(\n            !self.nullifier_exists(nullifier, self.this_address()),\n            \"L1-to-L2 message is already nullified\",\n        );\n        assert(\n            self.l1_to_l2_msg_exists(message_hash, leaf_index),\n            \"Tried to consume nonexistent L1-to-L2 message\",\n        );\n\n        self.push_nullifier(nullifier);\n    }\n\n    pub fn message_portal(_self: &mut Self, recipient: EthAddress, content: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { send_l2_to_l1_msg(recipient, content) };\n    }\n\n    pub unconstrained fn call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let args = args.push_front(function_selector.to_field());\n\n        call(gas_for_call(gas_opts), contract_address, args);\n        // Use success_copy to determine whether the call succeeded\n        let success = success_copy();\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub unconstrained fn static_call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let args = args.push_front(function_selector.to_field());\n\n        call_static(gas_for_call(gas_opts), contract_address, args);\n        // Use success_copy to determine whether the call succeeded\n        let success = success_copy();\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub fn push_note_hash(_self: &mut Self, note_hash: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_note_hash(note_hash) };\n    }\n    pub fn push_nullifier(_self: &mut Self, nullifier: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_nullifier(nullifier) };\n    }\n\n    pub fn this_address(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            address()\n        }\n    }\n    pub fn msg_sender(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            sender()\n        }\n    }\n    pub fn selector(_self: Self) -> FunctionSelector {\n        // The selector is the first element of the calldata when calling a public function through dispatch.\n        // Safety: AVM opcodes are constrained by the AVM itself\n        let raw_selector: [Field; 1] = unsafe { calldata_copy(0, 1) };\n        FunctionSelector::from_field(raw_selector[0])\n    }\n    pub fn get_args_hash(mut self) -> Field {\n        if !self.args_hash.is_some() {\n            self.args_hash = Option::some((self.compute_args_hash)());\n        }\n\n        self.args_hash.unwrap_unchecked()\n    }\n    pub fn transaction_fee(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            transaction_fee()\n        }\n    }\n\n    pub fn chain_id(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            chain_id()\n        }\n    }\n    pub fn version(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            version()\n        }\n    }\n    pub fn block_number(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            block_number()\n        }\n    }\n    pub fn timestamp(_self: Self) -> u64 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            timestamp()\n        }\n    }\n    pub fn fee_per_l2_gas(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_l2_gas()\n        }\n    }\n    pub fn fee_per_da_gas(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_da_gas()\n        }\n    }\n\n    pub fn l2_gas_left(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            l2_gas_left()\n        }\n    }\n    pub fn da_gas_left(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            da_gas_left()\n        }\n    }\n    pub fn is_static_call(_self: Self) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { is_static_call() } == 1\n    }\n\n    pub fn raw_storage_read<let N: u32>(_self: Self, storage_slot: Field) -> [Field; N] {\n        let mut out = [0; N];\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            out[i] = unsafe { storage_read(storage_slot + i as Field) };\n        }\n        out\n    }\n\n    pub fn storage_read<T, let N: u32>(self, storage_slot: Field) -> T\n    where\n        T: Packable<N>,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n\n    pub fn raw_storage_write<let N: u32>(_self: Self, storage_slot: Field, values: [Field; N]) {\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            unsafe { storage_write(storage_slot + i as Field, values[i]) };\n        }\n    }\n\n    pub fn storage_write<T, let N: u32>(self, storage_slot: Field, value: T)\n    where\n        T: Packable<N>,\n    {\n        self.raw_storage_write(storage_slot, value.pack());\n    }\n}\n\n// Helper functions\nfn gas_for_call(user_gas: GasOpts) -> [Field; 2] {\n    // It's ok to use the max possible gas here, because the gas will be\n    // capped by the gas left in the (STATIC)CALL instruction.\n    [user_gas.l2_gas.unwrap_or(MAX_FIELD_VALUE), user_gas.da_gas.unwrap_or(MAX_FIELD_VALUE)]\n}\n\n// Unconstrained opcode wrappers (do not use directly).\nunconstrained fn address() -> AztecAddress {\n    address_opcode()\n}\nunconstrained fn sender() -> AztecAddress {\n    sender_opcode()\n}\nunconstrained fn transaction_fee() -> Field {\n    transaction_fee_opcode()\n}\nunconstrained fn chain_id() -> Field {\n    chain_id_opcode()\n}\nunconstrained fn version() -> Field {\n    version_opcode()\n}\nunconstrained fn block_number() -> Field {\n    block_number_opcode()\n}\nunconstrained fn timestamp() -> u64 {\n    timestamp_opcode()\n}\nunconstrained fn fee_per_l2_gas() -> Field {\n    fee_per_l2_gas_opcode()\n}\nunconstrained fn fee_per_da_gas() -> Field {\n    fee_per_da_gas_opcode()\n}\nunconstrained fn l2_gas_left() -> Field {\n    l2_gas_left_opcode()\n}\nunconstrained fn da_gas_left() -> Field {\n    da_gas_left_opcode()\n}\nunconstrained fn is_static_call() -> Field {\n    is_static_call_opcode()\n}\nunconstrained fn note_hash_exists(note_hash: Field, leaf_index: Field) -> u1 {\n    note_hash_exists_opcode(note_hash, leaf_index)\n}\nunconstrained fn emit_note_hash(note_hash: Field) {\n    emit_note_hash_opcode(note_hash)\n}\nunconstrained fn nullifier_exists(nullifier: Field, address: Field) -> u1 {\n    nullifier_exists_opcode(nullifier, address)\n}\nunconstrained fn emit_nullifier(nullifier: Field) {\n    emit_nullifier_opcode(nullifier)\n}\nunconstrained fn emit_public_log(message: [Field]) {\n    emit_public_log_opcode(message)\n}\nunconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: Field) -> u1 {\n    l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\nunconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n    send_l2_to_l1_msg_opcode(recipient, content)\n}\nunconstrained fn call(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n    call_opcode(gas, address, args)\n}\n\nunconstrained fn call_static(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n    call_static_opcode(gas, address, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n    calldata_copy_opcode(cdoffset, copy_size)\n}\n\n// `success_copy` is placed immediately after the CALL opcode to get the success value\nunconstrained fn success_copy() -> bool {\n    success_copy_opcode()\n}\n\nunconstrained fn returndata_size() -> u32 {\n    returndata_size_opcode()\n}\n\nunconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n    returndata_copy_opcode(rdoffset, copy_size)\n}\n\npub unconstrained fn avm_return(returndata: [Field]) {\n    return_opcode(returndata)\n}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\nunconstrained fn avm_revert(revertdata: [Field]) {\n    revert_opcode(revertdata)\n}\n\nunconstrained fn storage_read(storage_slot: Field) -> Field {\n    storage_read_opcode(storage_slot)\n}\n\nunconstrained fn storage_write(storage_slot: Field, value: Field) {\n    storage_write_opcode(storage_slot, value);\n}\n\nimpl Empty for PublicContext {\n    fn empty() -> Self {\n        PublicContext::new(|| 0)\n    }\n}\n\n// AVM oracles (opcodes) follow, do not use directly.\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> Field {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeFeePerL2Gas)]\nunconstrained fn fee_per_l2_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeFeePerDaGas)]\nunconstrained fn fee_per_da_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> Field {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(nullifier: Field, address: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n// TODO(#11124): rename unencrypted to public in avm\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) {}\n\n#[oracle(avmOpcodeSuccessCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(avmOpcodeStorageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field) -> Field {}\n\n#[oracle(avmOpcodeStorageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
+      "source": "use crate::context::gas::GasOpts;\nuse crate::hash::{\n    compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n};\nuse dep::protocol_types::abis::function_selector::FunctionSelector;\nuse dep::protocol_types::address::{AztecAddress, EthAddress};\nuse dep::protocol_types::constants::MAX_FIELD_VALUE;\nuse dep::protocol_types::traits::{Empty, FromField, Packable, Serialize, ToField};\n\npub struct PublicContext {\n    pub args_hash: Option<Field>,\n    pub compute_args_hash: fn() -> Field,\n}\n\nimpl PublicContext {\n    pub fn new(compute_args_hash: fn() -> Field) -> Self {\n        PublicContext { args_hash: Option::none(), compute_args_hash }\n    }\n\n    pub fn emit_public_log<T, let N: u32>(_self: &mut Self, log: T)\n    where\n        T: Serialize<N>,\n    {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_public_log(Serialize::serialize(log).as_slice()) };\n    }\n\n    pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { note_hash_exists(note_hash, leaf_index) } == 1\n    }\n\n    pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { l1_to_l2_msg_exists(msg_hash, msg_leaf_index) } == 1\n    }\n\n    pub fn nullifier_exists(_self: Self, unsiloed_nullifier: Field, address: AztecAddress) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { nullifier_exists(unsiloed_nullifier, address.to_field()) } == 1\n    }\n\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        let secret_hash = compute_secret_hash(secret);\n        let message_hash = compute_l1_to_l2_message_hash(\n            sender,\n            self.chain_id(),\n            /*recipient=*/\n            self.this_address(),\n            self.version(),\n            content,\n            secret_hash,\n            leaf_index,\n        );\n        let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n        assert(\n            !self.nullifier_exists(nullifier, self.this_address()),\n            \"L1-to-L2 message is already nullified\",\n        );\n        assert(\n            self.l1_to_l2_msg_exists(message_hash, leaf_index),\n            \"Tried to consume nonexistent L1-to-L2 message\",\n        );\n\n        self.push_nullifier(nullifier);\n    }\n\n    pub fn message_portal(_self: &mut Self, recipient: EthAddress, content: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { send_l2_to_l1_msg(recipient, content) };\n    }\n\n    pub unconstrained fn call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let args = args.push_front(function_selector.to_field());\n\n        call(gas_for_call(gas_opts), contract_address, args);\n        // Use success_copy to determine whether the call succeeded\n        let success = success_copy();\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub unconstrained fn static_call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let args = args.push_front(function_selector.to_field());\n\n        call_static(gas_for_call(gas_opts), contract_address, args);\n        // Use success_copy to determine whether the call succeeded\n        let success = success_copy();\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub fn push_note_hash(_self: &mut Self, note_hash: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_note_hash(note_hash) };\n    }\n    pub fn push_nullifier(_self: &mut Self, nullifier: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_nullifier(nullifier) };\n    }\n\n    pub fn this_address(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            address()\n        }\n    }\n    pub fn msg_sender(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            sender()\n        }\n    }\n    pub fn selector(_self: Self) -> FunctionSelector {\n        // The selector is the first element of the calldata when calling a public function through dispatch.\n        // Safety: AVM opcodes are constrained by the AVM itself\n        let raw_selector: [Field; 1] = unsafe { calldata_copy(0, 1) };\n        FunctionSelector::from_field(raw_selector[0])\n    }\n    pub fn get_args_hash(mut self) -> Field {\n        if !self.args_hash.is_some() {\n            self.args_hash = Option::some((self.compute_args_hash)());\n        }\n\n        self.args_hash.unwrap_unchecked()\n    }\n    pub fn transaction_fee(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            transaction_fee()\n        }\n    }\n\n    pub fn chain_id(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            chain_id()\n        }\n    }\n    pub fn version(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            version()\n        }\n    }\n    pub fn block_number(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            block_number()\n        }\n    }\n    pub fn timestamp(_self: Self) -> u64 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            timestamp()\n        }\n    }\n    pub fn fee_per_l2_gas(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_l2_gas()\n        }\n    }\n    pub fn fee_per_da_gas(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_da_gas()\n        }\n    }\n\n    pub fn l2_gas_left(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            l2_gas_left()\n        }\n    }\n    pub fn da_gas_left(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            da_gas_left()\n        }\n    }\n    pub fn is_static_call(_self: Self) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { is_static_call() } == 1\n    }\n\n    pub fn raw_storage_read<let N: u32>(_self: Self, storage_slot: Field) -> [Field; N] {\n        let mut out = [0; N];\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            out[i] = unsafe { storage_read(storage_slot + i as Field) };\n        }\n        out\n    }\n\n    pub fn storage_read<T, let N: u32>(self, storage_slot: Field) -> T\n    where\n        T: Packable<N>,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n\n    pub fn raw_storage_write<let N: u32>(_self: Self, storage_slot: Field, values: [Field; N]) {\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            unsafe { storage_write(storage_slot + i as Field, values[i]) };\n        }\n    }\n\n    pub fn storage_write<T, let N: u32>(self, storage_slot: Field, value: T)\n    where\n        T: Packable<N>,\n    {\n        self.raw_storage_write(storage_slot, value.pack());\n    }\n}\n\n// Helper functions\nfn gas_for_call(user_gas: GasOpts) -> [Field; 2] {\n    // It's ok to use the max possible gas here, because the gas will be\n    // capped by the gas left in the (STATIC)CALL instruction.\n    [user_gas.l2_gas.unwrap_or(MAX_FIELD_VALUE), user_gas.da_gas.unwrap_or(MAX_FIELD_VALUE)]\n}\n\n// Unconstrained opcode wrappers (do not use directly).\nunconstrained fn address() -> AztecAddress {\n    address_opcode()\n}\nunconstrained fn sender() -> AztecAddress {\n    sender_opcode()\n}\nunconstrained fn transaction_fee() -> Field {\n    transaction_fee_opcode()\n}\nunconstrained fn chain_id() -> Field {\n    chain_id_opcode()\n}\nunconstrained fn version() -> Field {\n    version_opcode()\n}\nunconstrained fn block_number() -> Field {\n    block_number_opcode()\n}\nunconstrained fn timestamp() -> u64 {\n    timestamp_opcode()\n}\nunconstrained fn fee_per_l2_gas() -> Field {\n    fee_per_l2_gas_opcode()\n}\nunconstrained fn fee_per_da_gas() -> Field {\n    fee_per_da_gas_opcode()\n}\nunconstrained fn l2_gas_left() -> Field {\n    l2_gas_left_opcode()\n}\nunconstrained fn da_gas_left() -> Field {\n    da_gas_left_opcode()\n}\nunconstrained fn is_static_call() -> Field {\n    is_static_call_opcode()\n}\nunconstrained fn note_hash_exists(note_hash: Field, leaf_index: Field) -> u1 {\n    note_hash_exists_opcode(note_hash, leaf_index)\n}\nunconstrained fn emit_note_hash(note_hash: Field) {\n    emit_note_hash_opcode(note_hash)\n}\nunconstrained fn nullifier_exists(nullifier: Field, address: Field) -> u1 {\n    nullifier_exists_opcode(nullifier, address)\n}\nunconstrained fn emit_nullifier(nullifier: Field) {\n    emit_nullifier_opcode(nullifier)\n}\nunconstrained fn emit_public_log(message: [Field]) {\n    emit_public_log_opcode(message)\n}\nunconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: Field) -> u1 {\n    l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\nunconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n    send_l2_to_l1_msg_opcode(recipient, content)\n}\nunconstrained fn call(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n    call_opcode(gas, address, args)\n}\n\nunconstrained fn call_static(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n    call_static_opcode(gas, address, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n    calldata_copy_opcode(cdoffset, copy_size)\n}\n\n// `success_copy` is placed immediately after the CALL opcode to get the success value\nunconstrained fn success_copy() -> bool {\n    success_copy_opcode()\n}\n\nunconstrained fn returndata_size() -> u32 {\n    returndata_size_opcode()\n}\n\nunconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n    returndata_copy_opcode(rdoffset, copy_size)\n}\n\npub unconstrained fn avm_return(returndata: [Field]) {\n    return_opcode(returndata)\n}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\nunconstrained fn avm_revert(revertdata: [Field]) {\n    revert_opcode(revertdata)\n}\n\nunconstrained fn storage_read(storage_slot: Field) -> Field {\n    storage_read_opcode(storage_slot)\n}\n\nunconstrained fn storage_write(storage_slot: Field, value: Field) {\n    storage_write_opcode(storage_slot, value);\n}\n\nimpl Empty for PublicContext {\n    fn empty() -> Self {\n        PublicContext::new(|| 0)\n    }\n}\n\n// AVM oracles (opcodes) follow, do not use directly.\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> Field {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeFeePerL2Gas)]\nunconstrained fn fee_per_l2_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeFeePerDaGas)]\nunconstrained fn fee_per_da_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> Field {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(nullifier: Field, address: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n// TODO(#11124): rename unencrypted to public in avm\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) {}\n\n#[oracle(avmOpcodeSuccessCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(avmOpcodeStorageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field) -> Field {}\n\n#[oracle(avmOpcodeStorageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
     }
   }
 }