@aztec/protocol-contracts 1.0.0 → 1.1.2

package/artifacts/Router.json

@@ -58,7 +58,7 @@
         }
       },
       "bytecode": "JwACBAEoAAABBIBLJwAABAMnAgMEAicCBAQAHwoAAwAEgEkdAIBJgEkCHQCASoBKBC4IgEkAAS4IgEoAAiUAAABZJQAAAIQoAgABBIBLJwICBAA7DgACAAEoAIBDAgADKACARAIAAigAgEUCAAEoAIBGAgAEKACARwIABigAgEgCAAUmJQAAA1IeAgAEAR4CAAUACioEBQYkAgAGAAAApSUAAAN7HgIABAknAgUAAQoqBAUGJAIABgAAAMElAAADjR4CAAQFHAoEBQAcCgIEAAoqBQQCDCoFBAYLIgABgEUABCcCBQEBJAIABAAAAzsjAAAA9AsiAAGARAAHFgoCCCQCAAcAAAMpIwAAAQ0LIgABgEMACSQCAAkAAAMXIwAAASILIgABgEYACiQCAAoAAAMAIwAAATcLIgABgEgAChYKBgskAgAKAAAC6SMAAAFQCyIAAYBHAAgkAgAIAAAC1yMAAAFlJwIBAkknAggCbicCCgJ2JwILAmEnAgwCbCcCDQJpJwIOAmQnAg8CICcCEAJvJwIRAnAnAhICZScCEwJyJwIUAnQtCAEVJwIWBBIACAEWAScDFQQBACIVAhYtChYXLQ4BFwAiFwIXLQ4IFwAiFwIXLQ4KFwAiFwIXLQ4LFwAiFwIXLQ4MFwAiFwIXLQ4NFwAiFwIXLQ4OFwAiFwIXLQ4PFwAiFwIXLQ4QFwAiFwIXLQ4RFwAiFwIXLQ4SFwAiFwIXLQ4TFwAiFwIXLQ4LFwAiFwIXLQ4UFwAiFwIXLQ4NFwAiFwIXLQ4QFwAiFwIXLQ4IFycCAQEAJwIIAAAKKgEFCiQCAAoAAALOJwILBBMtCAEMJwINBBMACAENAS0KDA0qAwANBRPmMpnlFxQJACINAg0AIhUCDicCDwQRLgIADoADLgIADYAELgIAD4AFJQAAA58nAg4EEQAqDQ4NLQ4IDQAiDQINPA4LDC0KAQYjAAAC4C0KCwYjAAAC4C0KBgIjAAAC9wQqCwgBLQoBAiMAAAL3LQoCCSMAAAMOEioGAgEtCgEJIwAAAw4tCgkHIwAAAyAtCgYHIwAAAyAtCgcEIwAAAzItCggEIwAAAzItCgQDIwAAA0QtCgIDIwAAA0QkAgADAAADUSUAAAPlJigAgAQEeAANAAAAgASAAyQAgAMAAAN6KgEAAQX3ofOvpa3UyjwEAgEmKgEAAQVx7V8Tcb40BjwEAgEmKgEAAQWQokK5sxVPPjwEAgEmAQCAA4AFgAcuAIADgAguAIAEgAkLAIAIgAeACiQAgAoAAAPkLgGACIAGLgSABoAJAQCACAACgAgBAIAJAAKACSMAAAOzJioBAAEFHyCLhwGZz/08BAIBJg==",
-      "debug_symbols": "nZfRbuIwEEX/Jc88eDy2Z8yvrKqK0rRCQoBSWGlV8e87Bt8EKjnazQu5uU6OZ+yxTb679/7t8vm6O3wcv7r1r+/ubdjt97vP1/1xuznvjgdzvztXfoilW/Oqo+C7dSpXuxe7Rn+/JlevsVuTMyFmEBURq1A4qlVkNhGKKE5cdd4VJxVRHDVB5nguwhxvD/sQTJSHS9++PJyyCevdZ+vC21tMdG9iKk3ZBKcqolSRPAQcgSNwFI7CyXBydYLzEHAIDsHxcHwNIzBBwAlwApzoIAJETSckhtAqEHxA8EEBVAAzgDlCVGB0AaICIzFEBUZkEZFFRBaRKzAGBwFgQBcRwIguMAURUxAFQEEXCqCiCwUwo4tSP2wVlUr93AUcguMJIlXBDiJWEeCU4G+iVMtNlFDvAo7AEfSleCuDkytZnIMYnVwF1bcklCZvoswpW81rqQ2ywtYSD8n1uuqwNl/PQ9+XpfmwWG0JnzZDfzh368Nlv191vzf7y+2hr9PmcLueN4O12gLtD+92NeDHbt8XdV1Nb7v2q+SZfH3dNE+ILE8MajOiE0RgUkdC8k8E3yZoyFIJGsm3CPN5cJryiKmVR2gzgo5R2NJKrSjiXB6MkbA5TsvyeJyPqK08ZhnKcWRolBZD2wxhxlgIR25lktuETJIrIXu3bE6f88hLxiKFsSxSmmYkPq8QminOZKdORSTm5lAQz9SFJEJdiC4ai8c8RFp5zBIyatNO87CIwDoRYnMspY3gDEJwU2nbP4d/JgSPcQjs24SZwhQ7lVDaduZMDH3ermZGgllREmz/HCbEc136mU3TZ0UU7B6Wx0/ETGESuTDuFeRSbKUyO55hnBEJi2Yk0rj7sywiWDmOe41bFoOAkNwyQion9J2QlhFEUJnqeBHBjo9xl2jHwDOFKaiHhy0i/EcKYz3JwkFIYwRJfyzwF7vdbHfD0/fItaCG3eZt39fbj8th+9B6/nNCC75nTsNx279fhr6Qpo8a+2f4i6wOSMOLfYS4cpv8yrbLcku3VlqR8Mu1BPMX",
+      "debug_symbols": "nZfRbuIwEEX/Jc88eDy2Z8yvrKqK0rRCQoBSWGlV8e87Bt8EKjmq8kJurpPjGXtsk+/uvX+7fL7uDh/Hr27957t7G3b7/e7zdX/cbs6748Hc786VH2Lp1rzqKPhuncrV7sWu0d+vydVr7NbkTIgZREXEKhSOahWZTYQiihNXnXfFSUUUR02QOZ6LMMfbwz4EE+Xh0rcvD6dswnr32brw9hYT3ZuYSlM2wamKKFUkDwFH4AgchaNwMpxcneA8BByCQ3A8HF/DCEwQcAKcACc6iABR0wmJIbQKBB8QfFAAFcAMYI4QFRhdgKjASAxRgRFZRGQRkUXkCozBQQAY0EUEMKILTEHEFEQBUNCFAqjoQgHM6KLUD1tFpVI/dwGH4HiCSFWwg4hVBDgl+Jso1XITJdS7gCNwBH0p3srg5EoW5yBGJ1dB9S0JpcmbKHPKVvNaaoOssLXEQ3K9rjqszdfz0PdlaT4sVlvCp83QH87d+nDZ71fd383+cnvo67Q53K7nzWCttkD7w7tdDfix2/dFXVfT2679KnkmX183zROCnD5BqA2JThCCSR0RQk8E3yZoyFIJGsm3CPOJcJoSiamZSGhDgo5h2OJKrTDiXCKMobBZTssSeZyRqM1EZiHKcYRolCZE2xBhxmgIR27lktuETJIrIXu3bFqfE8mLRiOFsTRSmiYlPi8TminQZEdPRSTm5lgQz5SGJEJpiC4ajMc8RFp5zBIyytOO9LCIwDoRYnMspY3gDEJwU3V7W2+/JQSPcQjs24SZyhQ7mlDbdvBMVfVcVH5mJJgVJcH292FCyDNiZuP0WREFu4f18RMxU5hELozbBbkUW6nMjmcYZ0TCohmJNJ4ALIsIVo7jZuOWxSAgJLeMkMoxfSekZQQRVKY6XkSwE2TcJdox8ExhCurhYYsI/PsUxnqShYOQxgiS/ljgL3a72e6Gp4+Sa0ENu83bvq+3H5fD9qH1/O+EFnzUnIbjtn+/DH0hTV829vfwD1kdkIYX+xJx5Tb5lW2X5ZZurbQi4ZdrCeY/",
       "brillig_names": [
         "_check_block_number"
       ]
@@ -118,7 +118,7 @@
         }
       },
       "bytecode": "JwACBAEoAAABBIBLJwAABAMnAgMEAicCBAQAHwoAAwAEgEkdAIBJgEkCHQCASoBKBS4IgEkAAS4IgEoAAiUAAABZJQAAAIQoAgABBIBLJwICBAA7DgACAAEoAIBDAgADKACARAIAAigAgEUCAAEoAIBGAgAEKACARwIABigAgEgCAAUmJQAAA1IeAgAEAR4CAAUACioEBQYkAgAGAAAApSUAAAN7HgIABAknAgUAAQoqBAUGJAIABgAAAMElAAADjR4CAAQGHAoEBQAcCgIEAAoqBQQCDCoFBAYLIgABgEUABCcCBQEBJAIABAAAAzsjAAAA9AsiAAGARAAHFgoCCCQCAAcAAAMpIwAAAQ0LIgABgEMACSQCAAkAAAMXIwAAASILIgABgEYACiQCAAoAAAMAIwAAATcLIgABgEgAChYKBgskAgAKAAAC6SMAAAFQCyIAAYBHAAgkAgAIAAAC1yMAAAFlJwIBAkknAggCbicCCgJ2JwILAmEnAgwCbCcCDQJpJwIOAmQnAg8CICcCEAJvJwIRAnAnAhICZScCEwJyJwIUAnQtCAEVJwIWBBIACAEWAScDFQQBACIVAhYtChYXLQ4BFwAiFwIXLQ4IFwAiFwIXLQ4KFwAiFwIXLQ4LFwAiFwIXLQ4MFwAiFwIXLQ4NFwAiFwIXLQ4OFwAiFwIXLQ4PFwAiFwIXLQ4QFwAiFwIXLQ4RFwAiFwIXLQ4SFwAiFwIXLQ4TFwAiFwIXLQ4LFwAiFwIXLQ4UFwAiFwIXLQ4NFwAiFwIXLQ4QFwAiFwIXLQ4IFycCAQEAJwIIAAAKKgEFCiQCAAoAAALOJwILBBMtCAEMJwINBBMACAENAS0KDA0qAwANBRPmMpnlFxQJACINAg0AIhUCDicCDwQRLgIADoADLgIADYAELgIAD4AFJQAAA58nAg4EEQAqDQ4NLQ4IDQAiDQINPA4LDC0KAQYjAAAC4C0KCwYjAAAC4C0KBgIjAAAC9wQqCwgBLQoBAiMAAAL3LQoCCSMAAAMOEioGAgEtCgEJIwAAAw4tCgkHIwAAAyAtCgYHIwAAAyAtCgcEIwAAAzItCggEIwAAAzItCgQDIwAAA0QtCgIDIwAAA0QkAgADAAADUSUAAAPlJigAgAQEeAANAAAAgASAAyQAgAMAAAN6KgEAAQX3ofOvpa3UyjwEAgEmKgEAAQWeScksjTulvTwEAgEmKgEAAQW6OL+KoDMf/zwEAgEmAQCAA4AFgAcuAIADgAguAIAEgAkLAIAIgAeACiQAgAoAAAPkLgGACIAGLgSABoAJAQCACAACgAgBAIAJAAKACSMAAAOzJioBAAEFdS4blGTo99s8BAIBJg==",
-      "debug_symbols": "nVfRbiIxDPyXfeYhie3Y4VdOVUXbbYWEaEXhpFPFv59TMgtUyupuX8hkspnY8STsfg0v49Pp7XG7f33/HNa/voanw3a327497t6fN8ft+97ZryHUn0g6rGk1RE7DOtfW++qtpEubQ2tlWMfgQJ2IsQJpwMCYNVDIAVdQGVkNKVQmV1AZcxCdSVSBM8kfTswO6sN17VQfzsWBr56KL5F8FsV4GaJYh4oDyg2INpATABgFo2AMjIEpYEpjOCQAMBFMBJPApBYGUwQAw2AYjAQABmjpcCYAawDBM4Jng6BBsECwCEATlMAATVAiATRBQRaCLARZCDVB4QAAQcYSAkHBEiiBoASiEFQsYRA0LGEQLFii+ofcUbn65wLARDApAuQGKABIAwymBv8Nqlu+QQ31AsAoGMVahlkFOqUpawgAE1MaiG2Wch1KDmpNyT1v1RvRjW01nqjn82rA2Xw8HsaxHs2bw+pH+GNzGPfHYb0/7Xar4fdmd/p+6PNjs/9uj5uDj/oBHfcv3rrg63Y3VnReXWeH/tSYKKY23TFdJYreacS+hgRFBA5tUsjpTiH1FYyLNgWTmHoK83lQvuYhuZcH9zXYpij8aOVeFDKXB2EnvMZ5WR639RDr5TGrYSSThon2NKyvoUTYCyWhXialr1CilqZQUlhW0/s8yoK9KIo0SuFpvtyfjzhjzcwGhcyla+5IM66wNLnbWBbsxDWLGIL00pjbylCvpKbAyxTy5Mt4U86fW6l9CSqG4xWuG+mvDf+swAlnnCn1FWZcqf6XBF/LjSOi3d9VMztBZDA2+WvDVeLelGnmxkzFEAWFm838KTHjSy8C3xQkSy+V2f3kqSLKiyoicbr6SRcpaODpognLYlAo5LBMIde/54tCXqagCmdaoEUK/t8BBe3HQDPGVPhBr5Xg/0hh8pMu3IQ8RZDtxwF/8O7meXu4+xg5V6nDdvO0G1v39bR/vhk9/vnACD5mPg7vz+PL6TBWpesXjb8W/orug2j84F8goXb9wopZazfWromP6sO5BvMX",
+      "debug_symbols": "nZfRbuowDIbfpddcxHEcO7zK0TSxrZuQEJsYHOlo4t2PM/IXmJRq6g3986f5YidOS7+Gl/Hp9Pa43b++fw7rP1/D02G7223fHnfvz5vj9n3v7tcQ6g+xDmteDZTisM716m31q8TLNYd2lWFNwYW6QVSFNGFwzJoo7CJVUR1ZDTFUJ1dRHXNB7kSuwp3oN8eUXNSb69yx3pyLC589Fp8i+igmunQx1a7ignMTok3kCAFH4Sgcg2NwCpzSnBQiBByCQ3AinNjCSEwQcBKcBEcCRIJo6aTMENYEgk8IPhmABmABsAhEA0pIEA0oxBANKMhCkIUgC+EGlBQgAEyYQgAUTIEtEGyBKICKKQxAwxQGYMEUtX7YKyrX+rkIOAQnEkRuggOENJHg1OC/Ra2Wb1FDvQg4Ckcxl2FUAac0soYAMTmlCWqjNNWu6KLuKXvNW60N8sK2Gg/p+bwacDYfj4dxrEfz5rD6Ef7YHMb9cVjvT7vdavi72Z2+b/r82Oy/r8fNwXv9gI77F7868HW7G6s6r66jQ38oRabYhrvmK4KC3UGoD5GgCMGlTQilO0LsEywVbQQTij3CfCKcr4lI7iaS+pBkUxh+uHIvDJlLhLEUvst5WSK3OyLWTWQWYiwTxES7EOtDlBmroSzcy6X0CYW0NEKJYdm23idSlqxGUeRRSpoAcn9IaKY8czIQcirdAieeKQyLU4VbkgVLcc2CQpBeGnNrGepzqRHSMkKeSpNu9vPnUmofwcVwwsJ1IaMftt8SUsQ5Txz7hJmyVH8vobDlpiLovqLizEowGyqb/b/DFaH3iJmnZiyGKDjcLOZPxExd+iakmw3J0ktldj3TtCOaFu2I0PT4Z11E0JCmJ01YFoOCkMMyQq7v6AshLyOoojIt8CKCvz5A0H4MPFOYinrQ604k/n0KUz3pwkXIUwTZfhzwB29unreHuy+Sc0Udtpun3diar6f9803v8d8HevBF83F4fx5fToexkq6fNf7f8A95HZClB/8MCbXpDyzKWptUmybeqw/nGsx/",
       "brillig_names": [
         "_check_timestamp"
       ]
@@ -733,10 +733,10 @@
                 }
               },
               {
-                "name": "max_block_number",
+                "name": "include_by_timestamp",
                 "type": {
                   "kind": "struct",
-                  "path": "aztec::protocol_types::abis::max_block_number::MaxBlockNumber",
+                  "path": "aztec::protocol_types::abis::include_by_timestamp::IncludeByTimestamp",
                   "fields": [
                     {
                       "name": "_opt",
@@ -755,7 +755,7 @@
                             "type": {
                               "kind": "integer",
                               "sign": "unsigned",
-                              "width": 32
+                              "width": 64
                             }
                           }
                         ]
@@ -1757,7 +1757,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "pZbbjuIwDIbfpde9qO0ceRWEUIHOqFJVUIeOtEK8+zpDDnSlZDtw0z89fXWc341v1ak7zJ/7fvw4f1Wb7a06TP0w9J/74Xxsr/155Ku3qnEHIasN1pVQD9EPMQ+xLPe6Avcg8Anc+Sww9tep69ydJyh/6tJO3XitNuM8DHX13Q7zz0Nfl3b80Ws78d2mrrrxxMrAj37o3Ohep7eb/KtCo39ZoYivg1BrAZLAA6RWTwCzFsCPkieAsDoieLiSgFJoT0AFmCOIAoF0iAHJykhQy1nIPIEQjScQNZAjqEIeVINhLXhMKZloYQHRhYkAqjAREGki1CzjMIU40AQEoLUvIUilJYUmiyhNBFVIBqLOT6RkC2Eg2YJytgAsVAfEVRWgUn0oWO1uikFwUaU1lcsKhYI5QSOGCuexSPmU4jcQG5dVE9gspGBR0koGkxshciaHwrqCtCYweGxN1uVQMpiSJpaK1ll3gH3f50XGSqMXM7K67hHfL3yk9zOylkGgXmOszGoxHyv/H+WaIbSpZp62t39qBk2pZuIfhCC7P/4njJRTLYhyYVDpP2SVDZskWA3Zf5nbzvMmk1JGl0mThxQjMRCzaq3GLKRgERvjAHbcK32LwoZi5wPLtmPHZ+2xn5YdHiJ/gIlIXoVX6SzLqry6to+ziMarfSg1XsFtSKzolVypswrXRrBKr8wjl+Lvdurbw9C5KFyc83gMQfHp9c8l3AmN6WU6H7vTPHVuAqk75e9sGSxwx10oX9lKqKXaxZ7UXeIAkS+5HPwF",
+      "debug_symbols": "pZbtjqowEIbvhd/8YD76tbdijEFlNyQEDaubnBjv/UzXlqpJezj6x1cofZgO77Rzqfbd9vy16cfPw3f1sbpU26kfhv5rMxx27ak/jHL3UjX+h1X1gXXF+ibmJvYmTuRaV+AfBLmAq1xFxuY0dZ0fuYPKq47t1I2n6mM8D0Nd/bTD+feh72M7/uqpnWS0qatu3IsK8LMfOv/vWqfZTX4qGwyTNfI8HZRdClAEAaCMTgC9OAJgS4EA7ExCNItjQMUmIFADZhFcQJCJUSA5NSPMI0HlCYRoA4GogRxBFzKhHMypUA5TLqihB4gpLARQx4UAp4UQPn4RW4gDbUQAOvcSgnT6qNBkEaWFoI7WRDT5hZR8wRaSLyjrC8BCgQBzYDDYtBKz3OA0RwGsU42oRwIU3AkGMRa5/OcUhqb/gbj5uxoCl4UUPEpGq+hyy5xzOZiSza2Z41DWuqzNoeQwrWK5gTYmaw9w7xu9yFjo9HJGlhY+4vuVj/R+RpYyCPRrjIVZLeZj4QZSrhlCl2rm7oR7qhm0pZqJTmWC7BH5jzBSTg0T5cKg0j7kTCoZZ+4y8rSX+RM9bzINyWWa85BiJNbG7Qyb5m45z5CCRZyKGxGI415pXTQ2NDc/8NR5rOWy3fXTY5eH6IfrCikoB1Xes6I6qG/9JI1og7qbUhMU/JEkikGF541G7P0pqoIKj/wu+9NOfbsdOh+FD/Q87mJQcnn6c4wjsTk9Toddtz9PnV9A6lDlPSsBM66lE5U7KwW10uu5L/W3JECUWz4HfwE=",
       "brillig_names": [
         "store_in_execution_cache_oracle_wrapper",
         "notify_enqueued_public_function_call_wrapper"
@@ -2374,10 +2374,10 @@
                 }
               },
               {
-                "name": "max_block_number",
+                "name": "include_by_timestamp",
                 "type": {
                   "kind": "struct",
-                  "path": "aztec::protocol_types::abis::max_block_number::MaxBlockNumber",
+                  "path": "aztec::protocol_types::abis::include_by_timestamp::IncludeByTimestamp",
                   "fields": [
                     {
                       "name": "_opt",
@@ -2396,7 +2396,7 @@
                             "type": {
                               "kind": "integer",
                               "sign": "unsigned",
-                              "width": 32
+                              "width": 64
                             }
                           }
                         ]
@@ -3398,7 +3398,7 @@
         }
       },
       "bytecode": "H4sIAAAAAAAA/+XdBXhT9x6H8bRpC8Up7sUdkiZpE9zd3aGSAhuDYRtMO3d3Z8rcXZlvzN03Npi7O9zvbySXwyHb89zbk+2+zz3P8z5tk/Tk8z+RpsmRDN/2qZXf58v1b/8+Q/kTXzNVvuu05Ffn99kpLlctxWk1UpxWK8VpdVKcVi/FaQ3UANdpjVWF67QmKU5rmWJ+rVKclp/itNYpTmuT4jrapjitXYrT2qc4rUOK6+ioqrpO65RYBs4pI/E1eXooUBgOx4sK4sFQsDhQECuJRgLhSElhNBgNRqKRsoJoKBSPhqNFsZJYUSAWDIfiwfJILFQe2D7V8O+YV6BSU0FpOp01/3tnyH2C2fJUlsNqy2Gr47bY6rgNkt/XTFwm+Xu19HNtVUfV9e84PTllupZBoHJTsIOHyzPP753LeZ+1+eb70nufrefdfbYknc76Hjgj0eLyguJ4IJ3OBv+9M+w+IdVjq57jsVX/Tx5nDVyPrYb6uZFqrJqkeGz5XcsgULkp2MnDeTX0e3fbNPXucZrytmnquD0aOb5v7Pi+ieu2aaafm6sWqmXitsly3S6ppgHejCOU8RfXU9nrcD/eMry1Bzt6N6+0GTulwZgOZzN/epz/nrz+A57n4RNDqzT9AW+V+AOelfg5K8Vy8fqGzPD9f9/hvHbmpfmB4ZUz1bx3edBV9oHiJbizLz0L1usxe/iACnaBjDnTwzF3hYzZ7+GYu/1NYw5Ubgp293D51YI8offwMZw9Ic4AxBmEOAsgzhDEGYY4IxBnIcRZBHFGIc4YxNkL4uwNcfaBOPtCnP0gzv4Q5wCIcyDEOQjiHAxxDoE4h0KcwyDO4RDnCIhzJMQ5CuIcDXGOgTjHQpzjIM7xEOcEiHMixDkJ4pwMcU6BOKdCnNMgzukQ5wyIcybEOQvinA1xzoE450Kc8yDO+RDnAoizGOIsgThLIc4yiDMOcZZDnAshzkUQ52KIczeIc3eIcwnEuQfEuRTiXAZx7glxLoc4V0CcKyHOVRDnaohzL4hzb4hzDcS5FuLcB+LcF+LcD+LcH+I8AOI8EOKsgDgPgjgPhjgPgTgPhTgPgzgPhziPgDiPhDiPgjiPhjiPgTiPhTiPgziPhzhPgDhPhDhPgjhPhjhPgThPhThPgzhPhzjPgDjPhDjPgjjPhjjPgTjPhTjPgzjPhzgvgDjXQZwXQpwXQZwXQ5yXQJyXQpyXQZzrIc7LIc4rIM4rIc6rIM6rIc5rIM5rIc7rIM7rIc4bIM4bIc6bIM6bIc5bIM5bIc7bIM7bIc47IM47Ic67IM67Ic57IM57Ic77IM4NEOf9EOcDEOeDEOdDEOfDEOcjEOejEOdjEOfjEOdGiPMJiPNJiPMpiPNpiPMZiPNZiPM5iPN5iPMFiPNFiPMliPNliPMViPNViPM1iPN1iPMNiPNNiPMtiPNtiPMdiHMTxPkuxPkexLkZ4twCcb4PcX4AcX4IcX4EcX4McX4CcX4KcX4GcX4OcX4BcX4JcX4FcX4NcX4DcX4LcX4HcX4Pcf4Acf4Icf4Ecf4Mcf4Ccf4Kcf4Gcf4OcW6FOLdBnDZDgjMD4syEOP0QZxbEmQ1x5kCcVSDOqhBnLsRZDeKsDnHWgDhrQpy1IM7aEGcdiLMuxJkHcdaDOOtDnA0gzoYQZyOIszHE2QTibApxNoM4m0OcLSDOlhBnK4gzH+JsDXG2gTjbQpztIM72EGcHiLMjxNkJ4uwMcXaBOLtCnN0gzu4QZw+IsyfEGYA4gxBnAcQZgjjDEGcE4iyEOIsgzijEGYM4e6XJmelyhgKF4XC8qCAeDAWLAwWxkmgkEI6UFEaD0WAkGikriIZC8Wg4WhQriRUFYsFwKB4sj8RC5Yl5Z3g45t7/h2PuA7k/9s3wbvn91W0TqNwU7Oehs5n/77k/Bio3Bft7OOY8P+P+OADyuBkIcQ6COAdDnEMgzqEQ5zCIczjEOQLiHAlxjoI4R0OcYyDOsRDnOIhzPMQ5AeKcCHFOgjgnQ5xTIM6pEOc0iHM6xDkD4pwJcc6COGdDnHMgzrkQ5zyIcz7EuQDiLIY4SyDOUoizDOKMQ5zlEOdCiHMRxLkY4twN4twd4lwCce4BcS6FOJdBnHtCnMshzhUQ50qIcxXEuRri3Avi3BviXANxroU494E494U494M494c4D4A4D4Q4KyDOgyDOgyHOQyDOQyHOwyDOwyHOIyDOIyHOoyDOoyHOYyDOYyHO4yDO4yHOEyDOEyHOkyDOkyHOUyDOUyHO0yDO0yHOMyDOMyHOsyDOsyHOcyDOcyHO8yDO8yHOCyDOdRDnhRDnRRDnxRDnJRDnpRDnZRDneojzcojzCojzSojzKojzaojzGojzWojzOojzeojzBojzRojzJojzZojzFojzVojzNojzdojzDojzTojzLojzbojzHojzXojzPohzA8R5P8T5AMT5IMT5EMT5MMT5CMT5KMT5GMT5OMS5EeJ8AuJ8EuJ8CuJ8GuJ8BuJ8FuJ8DuJ8HuJ8AeJ8EeJ8CeJ8GeJ8BeJ8FeJ8DeJ8HeJ8A+J8E+J8C+J8G+J8B+LcBHG+C3G+B3Fuhji3QJzvQ5wfQJwfQpwfQZwfQ5yfQJyfQpyfQZyfQ5xfQJxfQpxfQZxfQ5zfQJzfQpzfQZzfQ5w/QJw/Qpw/QZw/Q5y/QJy/Qpy/QZy/Q5xbIc5tEKcvk+HMgDgzIU4/xJkFcWZDnDkQZxWIsyrEmQtxVoM4q0OcNSDOmhBnLYizNsRZB+KsC3HmQZz1IM76EGcDiLMhxNkI4mwMcTaBOJtCnM0gzuYQZwuIsyXE2QrizIc4W0OcbSDOthBnO4izPcTZAeLsCHF2gjg7Q5xdIM6uEGc3iLM7xNkD4uwJcQYgziDEWQBxhiDOMMQZgTgLIc4iiDMKccYgzl4QZ2+Isw/E2Rfi7Adx9oc4B0CcAyHOQRDnYIhzCMQ5FOIcBnEOhzhHQJwjIc5REOdoiHMMxDkW4hwHcY6HOCdAnBMhzkkQ52SIcwrEORXinAZxToc4Z0CcMyHOWRDnbIhzDsQ5F+KcB3HOhzgXQJzFEGcJxFkKcZZBnHGIsxziXAhxLoI4F0Ocu0Gcu0OcSyDOPSDOpRDnMohzT4hzOcS5AuJcCXGugjhXQ5x7QZx7Q5xrIM61EOc+EOe+EOd+EOf+EOcBEOeBEGcFxHkQxHkwxHkIxHkoxHkYxHk4xHkExHkkxHkUxHk0xHkMxHksxHkcxHk8xHkCxHkixHkSxHkyxHkKxHkqxHkaxHk6xHkGxHkmxHkWxHk2xHkOxHkuxHkexHk+xHkBxLkO4rwQ4rwI4rwY4rwE4rwU4rwM4lwPcV4OcV4BcV4JcV4FcV4NcV4DcV4LcV4HcV4Pcd4Acd4Icd4Ecd4Mcd4Ccd4Kcd4Gcd4Ocd4Bcd4Jcd4Fcd4Ncd4Dcd4Lcd4HcW6AOO+HOB+AOB+EOB+COB+GOB+BOB+FOB+DOB+HODdCnE9AnE9CnE9BnE9DnM9AnM9CnM9BnM9DnC9AnC9CnC9BnC9DnK9AnK9CnK9BnK9DnG9AnG9CnG9BnG9DnO9AnJsgznchzvcgzs0Q5xaI832I8wOI88M0OTNdzlCgMByOFxXEg6FgcaAgVhKNBMKRksJoMBqMRCNlBdFQKB4NR4tiJbGiQCwYDsWD5ZFYqDwx7w4ejvmjv2nMgcpNwY8zvVt+rfyM2znLw+X3CeS+ne3hmD+FjDnHwzF/BhlzFQ/H/DlkzFU9HPMXkDHnejjmLyFjrubhmL+CjLm6h2P+GjLmGh6O+RvImGt6OOZvIWOu5eGYv4OMubaHY/4eMuY6Ho75B8iY63o45h8hY87zcMw/QcZcz8Mx/wwZc30Px/wLZMwNPBzzr5AxN/RwzL9BxtzIwzH/DhlzYw/HvBUy5iYejnkbZMxNPRyzD/JebzMPx5wBGXNzD8ecCRlzCw/H7IeMuaWHY86CjLmVh2POhow538Mx50DG3NrDMVeBjLmNh2OuChlzWw/HnAsZczsPx1wNMub2Ho65uodj1qz+WN9lc2LAnVUX1VV1U91VD9XTrksFVYEtDxVWEVWoilRUxVQv1Vv1UX1VP9U/Mf6BapAarIaooWqYGq5GqJFqlBqtxqixapwaryaoiWqSmqymqKlqmpquZqiZapaareaouWqemq8WqGJVokpVmYqrcrVQLVKL1W5qd7VE7aGWqmVqT7VcrVAr1Sq1Wu2l9lZr1Fq1j9pX7af2VweoA1WFOkgdrA5Rh6rD1OHqCHWkOkodrY5Rx6rj1PHqBHWiOkmdrE5Rp6rT1OnqDHWmOkudrc5R56rz1PnqArVOXaguUherS9Sl6jK1Xl2urlBXqqvU1eoada26Tl2vblA3qpvUzeoWdau6Td2u7lB3qrvU3eoeda+6T21Q96sH1IPqIfWwekQ9qh5Tj6uN6gn1pHpKPa2eUc+q59Tz6gX1onpJvaxeUa+q19Tr6g31pnpLva3eUZvUu+o9tVltUe+rD9SH6iP1sfpEfao+U5+rL9SX6iv1tfpGfau+U9+rH9SP6if1s/pF/ap+U7+rrWqbsgdahspUfpWlslWOqqKqqlxVTVVXNVRNVUvVVnVUXZWn6qn6qoFqqBqpxqqJaqqaqeaqhWqpWql81Vq1UW1VO9VedVAdVSfVWXVRXVU31V31UD1VQAVVgQqpsIqoQlWkoiqmeqneqo/qq/qp/mqAGqgGqcFqiBqqhqnhaoQaqUap0WqMGqvGqfFqgpqoJqnJaoqaqqap6WqGmqlmqdlqjpqr5qn5aoEqViWqVJWpuCpXC9UitVjtpnZXS9QeaqlapvZUy9UKtVKtUqvVXmpvtUatVfuofdV+an91gDpQVaiD1MHqEHWoOkwdro5QR6qj1NHqGHWsOk4dr05QJ6qT1MnqFHWqOk2drs5QZ6qz1NnqHHWuOk+dry5Q69SF6iJ1sbpEXaouU+vV5eoKdaW6Sl2trlHXquvU9eoGdaO6Sd2sblG3qtvU7eoOdae6S92t7lH3qvvUBnW/ekA9qB5SD6tH1KPqMfW42qieUE+qp9TT6hn1rHpOPa9eUC+ql9TL6hX1qnpNva7eUG+qt9Tb6h21Sb2r3lOb1Rb1vvpAfag+Uh+rT9Sn6jP1ufpCfam+Ul+rb9S36jv1vfpB/ah+Uj+rX9Sv6jf1u9qqtil7UZGhMpVfZalslaOqqKoqV1VT1VUNVVPVUrVVHVVX5al6qr5qoBqqRqqxaqKaqmaquWqhWqpWKl+1Vm1UW9VOtVcdVEfVSXVWXVRX1U11Vz1UTxVQQVWgQiqsIqpQFamoiqleqrfqo/qqfqq/vUeoBqpBarAaooaqYWq4GqFGqlFqtBqjxqpxaryaoCaqSWqymqKmqmlqupqhZqpZaraao+aqeWq+WqCKVYkqVWUqrsrVQrVI2bHl7bjtdkx0O964HcvbjpNtx6C24zvbsZPtuMR2zF87nq4dq9aOA2vHWLXjl9qxQe24m3ZMSztepB2L0Y5zaMcQrFB27Ds7rpwds82Oh2bHGrPjeNkxsuz4U3ZsJztukh2TyI73Y8fSsePU2DFg7PgqduwSOy6IHXPDjmdhx4qw4zDYMQ7s+AG2b37b773tU9721277Qrf9jNs+vNcp2/e07dfZ9pls+yO2ff3afnRtH7W2/1fbt6rtt9T2CWr727R9Wdp+Im0fjLZ/Q9t3oO2Xz/Z5Z/uTs3212X7QbB9jtv8u2zeW7XfK9ulk+0uyfRHZfn5sHzoblO37xfarYvsssf2B2L42bD8Wto8I2/+C7dvA9htg2+Tb9u62Lbltp23bQNv2xbbtrm0Xa9uc2vactq2kbYdo2/jZ9nO2bZpt92XbVNn2SrYtkG1nY9uwbFK27YVt12Cvd219fFvX3dYjt3W0bZ1lWx/Y1mm1dTxtnUdbB9DWibN1xGydKVuHyNapsXVMbJ0LWwfBPpO3z6jtM1v7DNM+07PPuOwzH/sMxD4TsPfI7T1jew/V3lO099jsPSd7D8bek7D/0e1/Vvsfzv6nsdf4mdtfMvhsfV2bOvt2TImnE5vlH+fb+q22vqet/2jrA9r6cba+mK0/ZesT2fo1tr6JrX9h6yPY5/P2ebV9fmufZ9rne/Z5l33+Y5+H2OcD9n65vX9s76fa+4v2fpu9/5SvWqs2yv5/tf/n7P8bW3+8o+rk23XKdHzfNPG1wZaBTZZvXD/Uebm2f3Je8vdjia+5rtMzEstiQOLnQOWmYK5jvl7PPxoIx3J9O08e+0O5vp3vOx7PP5Kcf3Z65v/Herw2DanYMX/nWJLX63ddzv07dn7NxPcZvl0vkxxHOu5Hup3TvZz+fTtXSdP8k8stx7Hs/CnGlLz+mq7bKnl+qq/JebnPS15XNV9a78PBvxqb05+8b9RxXd69DP5sXjn/4bz+ydvUuaydt+kfl6nYcV6m67wsx3k5rvOyK3Ydo/2Nyndczv0YzHKdl7yf2DSiYsc8ujrm1y3xfXL5pfO5O13PGTbVS+F3XpdNVSp2LI/ksvE7Tksu8+RtUNV5edd5uY7zsip2vp5qiZ+zHNfjnFfSke26fJfEz7UTX3Mcv5P8/Toprj/Hdf07uVOc5l4uuSkun5vi8nYfTb7WqJ7I7kMhx/z+7DHifC2T/L62b9fng+TvpvnxXJC0ZqWwOp9fktdvrwcbJL5fuWrZivjIpUPXxEtXr1q8bOng4tJFcZ9rcj74nHdM9wtU5wJwDjTVPPyO30812Q2SfJGUVbHz7w1InB6oxFQUDQSS1518QGS7nD7X9We7Lh9N/FzNMa7k18psZFdeVBwsDxWXF0eKy8rCpcV5rvn7fDvueLacmiW+h78ojv5dL4rT9GIsnJx/Tnrmn/JFcaonnOR9eFjFjmU5rGJnU/Iywx2XGe64jE1/9cLZ/UfbpqGu85yPpWGu85xPVsnrtSfgur4d3yfv92n+gx79J/+gJ//wJJ+Q7ck5P/H90mWrFpevHbp0+er46njZhNUlSxaXDlu9tHT7E/WSJT7X5H7RneH6OdP1s/s5OSvFfNyT8/cyHGP4X3+uTr7p8E8/V/8LDQDv/nMeAgA=",
-      "debug_symbols": "pZbbjuIwDIbfpde9qO0ceRWEUIHOqFJVUIeOtEK8+zpDDnSlZDtw0z89fXWc341v1ak7zJ/7fvw4f1Wb7a06TP0w9J/74Xxsr/155Ku3qnEHIasN1pVQD9EPMQ+xLPe6Avcg8Anc+Sww9tep69ydJyh/6tJO3XitNuM8DHX13Q7zz0Nfl3b80Ws78d2mrrrxxMrAj37o3Ohep7eb/KtCo39ZoYivg1BrAZLAA6RWTwCzFsCPkieAsDoieLiSgFJoT0AFmCOIAoF0iAHJykhQy1nIPIEQjScQNZAjqEIeVINhLXhMKZloYQHRhYkAqjAREGki1CzjMIU40AQEoLUvIUilJYUmiyhNBFVIBqLOT6RkC2Eg2YJytgAsVAfEVRWgUn0oWBuEplCc5smZclmfULAmaMSA4LFI2ZTiNxAbF1UT2CykYFDSSgaLGyFyFofCqoK0JjB4bE3W41Cyl5ImForWWW+Afd/lRcZKmxczsrrqEd8ve6T3M7KWQaBeY6zMajEfK/8e5ZohtKlmnja3f2oGTalm4v+DILs7/ieMlFMtiHJhUGmPtcqGLRKshuyfzG3meZNJKaPLpMlDipEYiFm1VmMWUrCIjXEAO+6VrkVhQ7HvgWXTseOz9thPy/4OkT/ARCSvwqt0lmVVXl3Tx1lE49U+lBqv4LYjVvRKrtRZhWsiWKVX5pFL8Xc79e1h6FwULs55PIag+PT65xLuhLb0Mp2P3WmeOjeB1Jvyd7YMFrjjHpSvbCXUUu1iR+oucYDIl1wO/gI=",
+      "debug_symbols": "pZbdjuIwDIXfJde9iO38zqsghAp0RpWqgjow0grx7usMSQNIyXbhhkOb5qvjHie+iH23PX9t+vHz8C0+Vhexnfph6L82w2HXnvrDyHcvQoYfpcUHNkKZm9ibuJt4lmsjIDwIfAFXvkqMzWnqujByB+VXHdupG0/iYzwPQyN+2uH8+9D3sR1/9dROPCob0Y17VgZ+9kMX/l2bPFuWpyqLcbJBNU8H7ZYCNEEEaGsywCyOAJSjSADlbUbIxTGgVjYi0AAWEaqCIJuiQPJ6RthHgi4TCNFFApGEEsFUMqE9zKnQHnMuSNIDxFYWAmjSQkDlhRA+fhFXiQNdQgB6/xKCTP6oIIuI2kLQJGsi2vJCar5QDrIvqOgLwEqBgFKRocDlldjFUVhK9enuvKkf50PFm2ARE4L/qxyEof+B+PmrWgJfhFQcStbo5HGnVMnjYGsmd3aOQzvniyaHmr+MTsUGxtqiOcC/b/MqY6HP6xlZWvaI79c90vsZWcogMK8xFma1mo+F20e9Zgh9rpm78+2pZtDVaiY5VREUD8h/hJFzahVRKQyqHbPe5pLx9i4jTztZOM/LJjOQXWZUGVKNxLm0naGUd8t5hlQs4nXaiIAd90rjYlDS3PrAU9+x5st210+PPR5iGG4EUlQVVQfPspqoofHjNKKL6m9KMiqEA4kVozIvGI1U8Cerjso8CrvsTzv17XboQhQh0PO4S0Hx5enPMY2k1vQ4HXbd/jx1YQG5P+X3rBiscM19KN9ZaWi0Wc9dabjFASLfCjn4Cw==",
       "brillig_names": [
         "store_in_execution_cache_oracle_wrapper",
         "notify_enqueued_public_function_call_wrapper"
@@ -3665,8 +3665,8 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "process_message"
       ]
@@ -3742,7 +3742,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "public_dispatch"
       ]
@@ -3914,8 +3914,8 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "vb3fzuy6cW/7Lus6F2KRrCL9KhsbgZPtHRgw7MBxDnAQ5N1Ps6Sq0XPONKe+7rnOjT28vL4aakn10x9S0n/99n/+9C//+W///Oe//t+//cdvf/hf//Xbv/z9z3/5y5//7Z//8rd//eM//vy3vz7+6X/9dqz/KKX99of6T4//7r/9oa//1t/+YOu/7bc/zPXf47c/lLJgPmD9m3IElAAJqAEtoAdogAWMgKhco3KNyjUq16hco3KNyjUq16hco3KNyi0qt6jconKLyi0qt6jconKLyi0qt6jco3KPyj0q96jco3KPyj0q96jco3KPyhqVNSprVNaorFFZo7JGZY3KGpU1KltUtqhsUdmiskVli8oWlS0qW1S2qDyi8liV1340JKAGtIAeoAEWMALmBfMIiMozKs9VeSxoAT1AAyxgBDwqy2PHluNRWfqCEiABNaAF9IBHZZkLLGAEzAvKo3I9FpQACViV64IW0AMeletSrBY8YQTMC1YPnlACJKAGtIAeEJUlKktUlqhco3KNyjUq16hco3KNyjUq16hco3KNyi0qt6jconKLyqsHqy3oARpgASNgXrB68IQSIAE1ICr3qNyjco/KPSr3qKxRWaOyRmWNyhqVNSprVNaorFFZo7JFZYvKFpUtKltUtqhsUdmiskVli8ojKo+oPKLyiMojKo+oPKLyiMojKo+oPKPyjMozKs+oPKPyjMozKs+oPKPyvCrX4wgoARJQAx6V27GgB2iABYyAecHqwRNKgATUgKhconKJyiUqrx5sfcG8YPXgCSVAAmpAC+gBGmABUVmico3KNSqvHmxjQQ1oAT1AAyxgBMwLVg+eUAKicovKLSq3qNyi8urBLgtGwLxg9eAJJUACakAL6AEaEJV7VO5RWaOyRmWNyhqVNSprVNaorFFZo7JGZYvKFpUtKltUtqhsUdmiskVli8oWlUdUHlF5ROURlUdUHlF5ROURlUdUHlF5RuUZlWdUnlF5RuUZlWdUnlF5RuV5VW7HEVACJKAGtIAeoAEWMAKiconKJSqXqFyiconKJSqXqFyiconKJSpLVJaoLFFZorJEZYnKEpUlKktUlqhco3KNyjUq16hco3KNyjUq16hco3KNyi0qt6jconKLyi0qt6jconL0YIsebNGDzXuwLSgBElADWkAP0AALGAHzAo3KGpU1KmtU1qisUVmjskZljcoalS0qW1S2qGxR2aKyRWWLyhaVLSpbVB5ReUTlEZVHVB5ReUTlEZVHVB5ReUTlGZVnVJ5ReUblGZVnVJ5ReUblGZXnVbkfR0AJkIAa0AJ6gAZYwAiIyiUql6hconKJyiUql6hconKJyiUql6gsUVmiskRlicoSlSUqS1SWqCxRWaJyjco1KteoXKNyjco1KteoXKNyjco1Kreo3KJyi8otKreo3KJyi8otKreo3KJy9GCPHuzRgz16sEcP9ujBHj3Yowd79GCPHuzRgz16sEcP9ujBHj3Yowd79GCPHuzRgz16sEcP9ujBHj3Yowd79GCPHuzRg917cCwYAfMC70GHEiABNaAF9AANiMojKo+oPKPy6kHtCySgBrSAHqABFjAC5gm6evCEEiABNaAF9AANsIAREJVLVC5RuUTlEpVXD6ot6AEaYAEjYF6wevCEEiABNSAqS1SWqCxRefWgjgXzgtWDJ5QACagBLaAHaIAFROUalVtUblF59aCVBTWgBTwqW12gARYwAuYFqwdPKAESUANaQFTuUblH5R6VVw+aPmD14AklQAJqQAvoARpgASMgKltUtqhsUXn1oK2ts3rwhB6gARYwAuYFqwdPKAESEJVHVB5ReUTlEZVHVB5ReUblGZVnVJ5ReUblGZVnVJ5ReUbleVW24wgoARJQA1pAD9AACxgBUblE5RKVS1QuUblE5RKVS1QuUblE5RKVJSpLVJaoLFFZorJEZYnKEpUlKktUrlG5RuUalWtUrlG5RuUalWtUrlG5RuUWlVtUblG5ReUWlVtUblG5ReUWlVtU7lG5R+UelXtU7lG5R+UelXtU7lG5R2WNyhqVNSprVNaorFFZo7JGZY3K3oOP+3XmPehQAiSgBrSAHqABFjACovKIyiMqj6g8ovKIyiMqj6g8ovKIyiMqz6g8o/KMyjMqz6g8o/KMyjMqz6g8r8rjOAJKgATUgBbQAzTAAkZAVC5RuUTlEpVLVC5RuUTlEpVLVC5RuURlicoSlSUqS1SWqCxRWaKyRGWJyhKVa1SuUblG5RqVa1SuUblG5RqVa1SuUblF5RaVW1RuUblF5RaVW1RuUblF5RaVe1TuUblH5R6Ve1TuUblH5R6Ve1TuUVmjskZljcoalTUqa1TWqKxRWaNy9OCIHhzRgyN6cEQPjujBET04ogdH9OCIHhzRgyN6cEQPjujBET04ogdH9OCIHhzRgyN6cEQPjujBET04ogdH9OCIHhzRgyN6cEQPjujBET04owdn9OCMHpzRgzN6cEYPzujBGT04owdn9OCMHpzRgzN6cEYPzujBGT04owdn9OCMHpzRgzN6cEYPzujBGT04owdn9OCMHpzRgzN6cEYPzujBGT04owdn9OCMHpyrB4cs0AALGAHzgtWDJ5QACagBLSAqt6jconKLyqsHx+PUca4ePKEESEANaAE9QAMsYAREZY3KGpU1KmtU1qisUVmjskZljcoalS0qW1S2qGxR2aKyRWWLyhaVLSpbVB5ReUTlEZVHVB5ReUTlEZVHVB5ReUTlGZVnVJ5ReUblGZVnVJ5ReUblGZXnVbkcx5FUkiSpJrWknqRJlrQU5jSDVjte9HDMw0mSalJL6kmaZEkjaQatxrwoHZIOSYekQ9Ih6ZB0SDokHTUdNR01HTUdNR01HTUdNR01HTUdLR0tHS0dLR0tHS0dLR0tHS0dLR09HT0dPR09HT0dPR09HT0dPR09HZoOTYemQ9Oh6dB0aDo0HZoOTYelw9Jh6bB0WDosHZYOS4elw9Ix0jHSMdIx0jHSMdIx0jHSMdIx0jHTMdMx0zHTMdMx0zHTMdMx0zHDUY4jqSRJUk1qST1JkyxpJKWjpCP7vGSfl+zzkn1ess9L9nnJPi/Z5yX7vGSfl+zzkn1ess9L9nnJPi/Z5yX7vGSfl+zzkn1ess9L9nnJPi/Z5yX7vGSfl+zzkn1ess9L9nnJPi/Z5yX7vGSfl+zzkn1ess9L9nnJPi/Z5yX7vGSfl+zzkn1ess9L9nnJPi/Z5yX7vGSfl+zzkn1ess9L9nnJPi/Z5yX7vGSfl+zzkn1ess9L9nnJPi/Z5yX7vGSfl+zzkn1ess9L9nnJPi/Z5yX7vGSfl+zzkn1ess9L9nnJPi/Z5yX7vGSfl+zzkn1ess9L9nnJPi/Z5yX7XLLPJftcss8l+1yyzyX7XLLPJftcss8l+1yyzyX7XLLPJftcss8l+1yyzyX7XLLPJftcss8l+1yyzyX7XLLPJftcss8l+1yyzyX7XLLPJftcss8l+1yyzyX7XLLPJftcss8l+1yyzyX7XLLPJftcss8l+1yyzyX7XLLPJftcss8l+1yyzyX7XLLPJftcss8l+1yyzyX7XLLPJftcss8l+1yyzyX7XLLPJftcss8l+1yyzyX7XLLPJftcss997tAUJ02ypJE0g7zPTypJklSTWlI6RjpGOkY6RjpmOmY6ZjpmOmY6ZjpmOmY6ZjpmOHxS0UUlSZJqUkvqSZpkSSMpHSUdJR0lHSUdJR0lHSUdJR0lHSUdkg5Jh6RD0iHpkHRIOiQdkg5JR01HTUdNR01HTUdNR01HTUdNR01HS0dLR0tHS0dLR0tHS0dLR0tHS0dPR09HT0dPR09HT0dPR09HT0dPh6ZD06Hp0HRoOjQd3ufnrGVLGkkzyPv8pJIkSTWpJfWkdFg6LB2WjpGOkY6RjpGOkY6RjpGOkY6RjpGOmY6ZjpmOmY6ZjpmOmY6ZjpmOGQ6fuHRRSZKkmtSSepImWdJISkdJR0lHSUdJR0lHSUdJR0lHSUdJh6RD0iHpkHRIOiQdkg5Jh6RD0lHTUdNR01HTUdNR01HTUdNR01HT0dLhfW5OklST1nTt43DsoIIGDnAm+uT7CwsoYAWxdWwdW8fWsXVsik2xKTbFptgUm2JTbIpNsRk2w2bYDJthM2yGzbAZNsM2sA1sA9vANrANbAPbwDawDWwT28Q2sU1sE9vENrFNbBPbTJtPqgosoIAVbGAHFTRwgNgKtoKtYCvYCraCrWAr2Aq2gk2wCTbBJtgEm2ATbIJNsAm2iq1iq9gqtoqtYqvYKraKrWJr2Bq2hq1hI0s6WdLJkk6WdLKkkyWdLOlkSSdLOlnSyZJOlnSypJMlnSzpZEknSzpZ0smSTpZ0sqSTJZ0s6WRJJ0s6WdLJkk6WdLKkkyWdLOlkSSdLOlnSyZJOlnSypJMlnSzpZEknSzpZ0smSTpZ0sqSTJZ0s6WRJJ0s6WdLJkk6WdLKkkyWdLOlkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZEldmZJdRzgTDyz5MQCCljBBnZQQWwNW8PWsZ1Z0hwFrGADO6iggQOciWeWnIhNsSk2xabYFJtiU2yKzbAZNsNm2AybYTNshs2wGbaBbWAb2Aa2gW1gG9gGtoFtYJvYJraJbWKb2Ca2iW1im9hm2sZxgAUUsIIN7KCCBg4QW8FWsJ1ZMhwr2MBlK4ejggYOcCZ6llxYQAEr2EBsgk2wCTbBVrFVbBVbxVaxVWwVW8VWsVVsDVvD1rA1bA1bw9awNWwNW8PWsXVsHVvH1rF1bB1bx9axdWyKTbEpNsWm2BSbYlNsik2xGTbDZtgMm2EzbIbNsBk2wzawDWwD28A2sA1sA9vANrANbBPbxDaxTWwT28Q2sU1sE9tMm086DCyggBVsYAcVNHCA2Aq2gq1gK9gKNrJkkiWTLJlkySRLJlkyyZJJlkyyZJIlkyyZZMkkSyZZMsmSSZZMsmSSJZMsmWTJJEsmWTLJkkmWTLJkkiWTLJlkySRLJlkyyZJJlkyyZJIlkyyZZMkkSyZZMsmSSZZMsmSSJZMsmWTJJEsmWTLJkkmWTLJkkiWTLJlkySRLJlkyyZJJlkyyZJIlkyyZZMkkSyZZMsmSSZZMsmSSJZMsmWTJJEsmWTLJkkmWTLJkkiWTLJlkySRLJlkyyZJJlkyyZJIlkyyZZMnMLJEjs0SOzBI5MkvkyCyRI7NEjswSOTJL5MgskSOzRI4DW8FWsBVsBVvBVrAVbAVbwVawCTbBJtgEm2ATbIJNsAk2wVaxVWwVW8VWsVVsFVvFVrFVbA1bw9awNWwNW8PWsDVsDVvD1rF1bB1bx9axdWwdW8fWsXVsik2xKTbFptgUm2JTbIpNsRk2w2bYDJthM2yGzbAZNsM2sA1sA9vAdmZJdeygggYOcCaeWXJiAQWsILbzGmc6KmjgAGdgOa9xTiyggBVsYAcVNHCA2Aq2gq1gK9gKtoKtYCvYCraCTbAJNsEm2ASbYBNsgk2wCbaKrWKr2Cq2iq1iq9gqtoqtYmvYGraGrWFr2Bq2hq2lzWep+Ruz5MzG5uh7nDo2sIMKGjjAmXim4IkFFBBbw9awNWwNW8PWsHVsHVvH1rF1bB1bx9axdWwdm2JTbIpNsSk2xabYFJtiU2yGzbAZNsNm2AybYTNshs2wDWwD28A2sA1sA9uZgr6bnSl44gBn4pmCJxZw2c7d01PwwgZ2cNnE919PwQuXTcxxBvqstsACCljBBnZQQQMHiK1gK9g8BWU4VrCBHVTQwGXzN+HV88WSjuerJU9ctlodBaxgAzuo4LL5a8bq+arJE2fi+brJE93mS3a+cvLECnqx4ujF1jb2eWyPTHNcf9aaYwUb2EEFDVx1m9s8FE70ULiwgG7zZfBQuHDZ1puAxGe1BSpo4ABnoodCV8cCClhBt/nq81C40G2+kB4KFw5wJnooqIs9FC4UsIIN7OCyqS+Oh8KFA5yJHgrqC+mhcKGAbvO9z0Phwp7o3X2h/5n/Cu9j853Am/f6p2sZzBfSm9fRp6oFFlDAtQzrrQ/i09UCO6iggQNctrEW0ietBRZQwGUbxbGBHVy24UvmzXvhAN229l+fvva4/+foNnMUsIIN7KCCyzZd4c174Uz05r2wgAJWsIEdVBBbxVaxNWze3dN/sXf3hR1U0MCR6K03fUV5653orTd9EyqLriy6sujeDNNXlDfDhQoaOMCZ6M1wYQEFrCC2gW1gG9gGtoFtYvNj4RyOXmE6Pio8rq0dBzgDfQ5XYAEFrGADO6iggQPEVrAVbAVbwVawFWwFW8FWsBVsgk2wCTbBJtgEm2ATbIJNsFVsFVvFVrFVbBVbxVaxVWwVW8PWsDVsDVvD1rA1bA1bw9awdWwdW8fWsXVsHVvH1rF1bB2bYlNsik2xKTbFptgUm2JTbIbNsBk2w2bYDJthM2yGzbANbAPbwDawDWwD28A2sA1sA9vENrFNbBPbxDaxTWxkSSdLOlmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFmiZImSJUqWKFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFliZImRJUaWGFkyyJJBlgyyZJAlgywZZMkgSwZZMsiSQZYMsmSQJYMsGWTJIEsGWTLIkkGWDLJkkCWDLBlkySBLBlkyyJJBlgyyZJAlgywZZMkgSwZZMsiSQZYMsmSQJYMsGWTJIEsGWTLIkkGWDLJkkCWDLBlnQ1bHCjbQF6c7KmjgAGfi2ZAnFlDACjYQm2E7G3I6DnAmng15YgEFXDYf9/OJUIEdVHDZfBzHJ0IFzkRvyOJL5g15oYBuU8cGdlBBt627Ej7lSdZnYcSnPAUKWMFVVw7HVdc/IuNTnh5DUo4GDnAmeuv5nX+f8hQoYAXd1h1d4cvr/eZ30n2ek/g9c5/nJH7z2+c5BRZQwAo2sIPLVpujgW5z8Tn85uj9dmEBBazgsjVfD95vFypo4LI1XxzvtxO93y5cNr997vOcAivoNnV0my+DH7svNHCAM9GP3Re6bToKWMEGdlBBAwc4E/3YfSE2xabYFJti86jovk96VFw4QN9uvkd5VFxYQAEr2MBl675+PSouNHCAM9Gj4sICCljBBmIb2Aa2gc1DoftCeihcWMEGdlBBAwc4L6zH+bmoEwsoYAUb2EEFDRwgtoKtYCvYCraCrWAr2Aq2gq1gE2yCTbAJNsEm2ASbYBNsgq1iq9gqtoqtYqvYKraKrWKr2Bq2hq1ha9gatoatYWvYGraGrWPr2Dq2jq1j69g6to6tY+vYFJtiU2yKTbEpNsWm2BSbYjNshs2wGTbDZtgMm2EzbIZtYBvYBraBbWAb2Aa2gW1gG9gmtoltYpvYJraJbWKb2CY2sqSQJYUsKWeWqGMFG9hBBQ10hSw8A+TEAgpYwQZ2UEEDB4hNsAk2wSbYBJtgE2yCTbAJtoqtYqvYKraKrWKr2Cq2iq1ia9gatoatYWvYGraGrWFr2Bq2jq1j69g6to6tY+vYOraOrWNTbIpNsSk2xabYFJtiU2yKzbAZNsNm2AybYTNshs2wGbaBbWAb2Aa2gW1gG9gGtoFtYJvYJraJbWKb2Ca2iW1im9hm2q5vV55YQAEr2MAOKmjgALGRJUKWyJkl07GCDVy2NW2i+qvtAg0c4Ez0LLlw2dRtniUXVnDZtDh2UEEDBzgTPUvWF1iqv+kuUMAKNrCDCho4wJnYsDVsDVvD5lmizbGDCho4wJnoWbLmuFSfWBgooNuGYwM7qKDX9Q3r+WC+hTwfLmzgqmC+hTwfLjRwLe/6xEr1yYIXej5cWEC3+Q/yfLiwgR30ur76vOfX1JjqEwADK+i/2BXe8xcqaOAAZ6L3/IUFdJuvX+/5CxvYQQUNHOAM9AmAgQUUsIIN7KCCBrrNPxfp3X2hgBVsYAcVNPCp7kz07r4Qm2ATbIJNsAk2wSbYBFvFVrFVbBVbxVaxVWwVW8VWsTVsDVvD1rA1bA1bw9awNWwNW8fWsXVsHVvH1rF1bB1bx9axKTbFptgUm2JTbIpNsSk2xWbYDJthM2yGzbAZNsNm2AzbwDawDWwD28A2sA1sA9vANrBNbBPbxDaxTWwT28Q2sU1sM23tOMACCljBBnZQQQMHiK1gI0saWdLIkkaWNLKkkSWNLGlkSSNLGlnSyJJGljSypJEljSxpZEkjSxpZ0siSRpY0sqSRJY0saWRJI0saWdLIkkaWNLKkkSWNLGlkSSNLGlnSyJJGljSypJEljSxpZEkjSxpZ0siSRpY0sqSRJY0saWRJI0saWdLIkkaWNLKkkSWNLGlkSSNLGlnSyJJGljSypJEljSxpZEkjSxpZ0siSRpY0sqSRJY0saWRJI0saWdLIkkaWNLKkkSWNLGlkSSNLGlnSyJJGljSypJEljSxpZEkjSzpZ0smSTpZ0sqSTJZ0s6WRJJ0s6WdLJkk6WdLLknIy5ZjHXczLmhQ3soIIGDnAmepZcWEBsgk2wCTbBJtgEm2Cr2Cq2M0CmYwM7qKCBA5yJZ4CcWEABsTVsDVvD1rA1bA1bx9axdWwdW8fWsXVsHVvH1rEpNsWm2BSbYlNsik2xKTbFZtgMm2EzbIbNsBk2w2bYDNvANrANbAPbwDawDWwD28A2sE1sE9vENrFNbBPbxDaxTWwzbecMzAsLKGAFG9hBBQ0cILaCrWAr2Aq2gq1gK9gKtoKtYBNsgk2wCTbBJtgEm2ATbIKtYqvYKjayRMkSJUuULFGy5JyBuZ4BqecMzPWIRz1nYF5YQAEr2MAOKmjgALF1bB1bx9axdWyeJes5lHrOwLzQwAHORM+SC90mjss2T6xgAzuooIEDnImeJRcWEJthM2yGzbAZNsNm2Aa2gW1gG9gGtoFtYPPUWO93ruesyqGOFfQK5thBBQ0c4Az0WZV1zZKpPqsyUMAKtoXi2EEFbWF1HOBMLG5rjgUUsIJu645eVx0HOBPlAL3ucPS603HVXc/iV58/+bjX4rh+RfElW0lQi4tXEgQOcCauJKjFl2wlQaCAFXSbr+rqCl+c1f5VfHFW+1fx9bvav4ovzmr/x20XxwIKWMEGdlBBt/kytJHoPe871zlT8kIBK9jADipo4ABz/z1nSl6ITf0H+SrRCjZw/aDqK2r1fKCBA5yJq+cDCyhgBRuIzbCZ23x5bYAzcRxgAQV0m6/10cAOKug233/HAGfiOn943AFwzIQ5Z0peWMEGdlBBAweYeXbOlLywgAJWsIEdVNDAAWIr2Aq2gq1gK9gKtoKtYCvYCjbBJtgEm2ATbIJNsAk2wSbYKraKrWKr2Cq2is0DZD0DXX2mZODaS9r5L8xED5ALC7j2ydYdK9jADipo4ABnYnebOhbQj1nm6GdB57+roNc9/4UBzkQ9wAIKWEH/FdOxgwouWz8cBzgTPTXW/LPq0zkDBcyhjHM654UdVNDAAc7E86rjxAIK6EMkvujnEMmJ/it8y3s+XDgTPR8uLKCAFVzrrFfHDirotuY4wBno0zmrj076dM5AAXO46pzOeWEHFTRwgDPxvL44sYAC+q/ojgoaOED/FWtV+xzOwAIKWK8HaOv5rroLO6iggQOciecD1ScWcNWtJ65f4eOxPlsz0MABzkTv+QvXr/AhSZ+tGVjBBrrNV4n3/IUGus3Xg/f8id7zF7ptOLrNf8U6f6jraf3qszUDO6iggQNcNh++9NmagQUUsIIN7KCCBg4Qm2EzbIbNsPn5g4+F+mzNQAXd5mvHzx8unIl+/nBhAQVcNr9K8tmagR1UcNnW12+rz9YMnImeD3715XM4H9nhKGAFG9hBBQ0c4Lyw+RzOR2A4FnDZ1kfTms/hDGxgB5dtnS42n8MZOMCZ6NcXFxZQwAq6rTl20G3d0cABzkRPjQsfCn8tUvOJm3W9XaD5xM3ADipooCt87filxol+qXFhAQWs4MPWDv9tK0ACFTRwLPTlXQFy4QqQwLLQf9sKkMAKus0c3eabu7nNF6cZOMCZ2A+wgH5IcupJmmRJI2kGrQ5u69Ku+czJwAIKWMEGdlBBAweIbWAb2Aa2gW1gG9gGtoFtYBvYJraJbWKb2Ca2iW1im9gmtpk2nzkZWEABK9jADipo4ACxFWwFW8FWsBVsBVvBVrAVbAWbYBNsgk2wCTbBJtgEm2ATbBVbxVaxVWwVW8VWsVVsFVvF1rA1bA1bw9awNWwNW8PWsDVsHVvH1rF1bB1bx9axdWwdW8em2BSbYlNsik2xKTbFptjIkkKWFLKkkCWFLClkSSFLCllSyJJClhSypJAlhSwpZEkhSwpZUsiSQpYUsqSQJYUsKWRJIUsKWVLIkkKWFLKkkCWFLClkSSFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLhCwRskTIEiFLKllSyZJKllSypJIllSypZEklSypZUsmSSpZUsqSSJZUsqWRJJUsqWVLJkkqWVLKkkiWVLKlkSSVLKllSyZJKllSypJIllSypZEklSypZUsmSSpZUsqSSJZUsqWRJJUsqWVLJkkqWVLKkkiWVLKlkSSVLKllSyZJKllSypJIllSypZEklSypZUsmSSpZUsqSSJZUsqWRJJUsqWVLJkkqWVLKkkiWVLKlkSSVLKllSyZJKllSypJIllSypZEklSypZUsmSSpZUsqSSJZUsqWRJJUsqWVLJkkqWVLKkkiWVLKlkSSVLKllSyZJKllSypJEljSxpZEkjSxpZ0siSRpY0sqSRJY0saWRJI0saWdLIkkaWNLKkkSWNLGlkSSNLGlnSyJJGlrSz0ZtjBRvot7WcNMmSRtIM8juRJ5UkSapJLSkdLR0tHS0dLR09HT0dPR1nW6tjAzvoq3A4GrhW4RqNbT578kJv6wsLKGAFG9hBBQ3EptgMm2HzthbfYN7WFzawgwoa6LbqOBO9rS/0uzBOklSTWlJP0iSv6LuLN+l6j0LzuZBNfH17k17YQQV9SX0reJNeOAN9LmRgAf3GpVNNctd07KCCy7XeMdx8JmTgTPQWXYO3zWdCBq5ftt7O0HwmZGADl607aZIljaQZ5N15klc8cf1xVUdfUnMc4Ez0g/eFvqT+A72nL6xgAzu4bL7e/Nh90khaKi/vB+6TSpIk1aSWtCS+f/jMxkBL9KPzhevvm698b9gLVwVfEd6vJ1nSWsrmm8a79UTv1gvXgp6r17v1Qld5Be/WC31hfbm9W8+f793afD15t65BreZTFS/0br2wgAJWsIEd9F3Fl9e7tfuu5N3afXm9L7svpDdm94X0zrywgR1U0MCR6I3a/Wd6o17YwA4qaOAI9MmDbT2F2HzyYKCCBq4/WwNVzScPtvVcYPPJg/7bfe7gRZJUk1pST9IkSxpJM0jSIemQdEg6JB2SDkmHpEPSIemo6ajpqOmo6fBuWw9VNp8D2E+aQavdLipJklSTWlJP0iRLSkdLR09HT0dPR09HT0dPR09HT0dPR0+HpkPT4b2mvha81y400PcQ31m819ZAZPOpfM18v/GuMt9vvFPWg4vNJ+I183/Xj2sXFtDzyndY758LG9hBBQ0c4Ez009U1bN/8VYiBAi7b8N/mrTR8cbyVLvTEPf/dGejT8wILKPFnPj0vsIEdVNDAkeiHugvXBhpOklSTWlJP0iQvbo4DnIl+xnmhL57/mR/qfFDQ590FDnAm+qHuwgIKuFaGjxr6vLvADi7bLI4GDnDZfHzQp+AFFlDACjawgwoaOEBsHVvH1rF1bB1bx+YHSB/E9Nl4gSPRD4Y+XOmT7ZqPO/q0ukBfHN9C3mnTt5Af1S4U0Cv4Wvej2oVrx/ARRp8U132o0Cev9cMV8wALKODa3XxY0SevBXZQQQNHoE9T6z4a6dPUAivodadjBxU0cIAz0Y9UFxZw/btrjmnzSWYX+hHnwgIKWMG1ZKU4dlBBAwc4E/3Y45d1PsksUMAKuq06et3m6HW740z0g9GFBRSwgg30X6GOChroNt9uflQ60Q9LF/oxw9fOeWA6sYIN7KCCBg7Qj0++zs4DlK8H9Qq+HlRBA0ei+ZL5zzQBK9jADipo4AB9yXzteA9dWEABK+gKX2dDQS/mu723k1/++KyuXn09eOP4NY/P6jrRZ3Wt9xU0n9R1kSTVpJbUkzTJkkaSS9b+55O5AgsoYAUb2EEFLdE7zi/YfNpW90szn7a1pig1n7V1kSZZ0kiaQd5VfmnmE7YCBaxgAzvoq3ltKJ+a1f2CzadmBa4K/q96+5zUkzTJkkaSr9O1ZX1SVmABBaxgA/2Edu0QPtGq+8WXT7SykySpJj3+3M4/6UmaZEkjaQaZS3wTeRtdKGAH/RTbt6G3xoneGheuXdR/xuqMi2pSS+pJmuQ/3NfiGOBM9APWhQUUsIIN7KCC2CY277t14dl9tlRgAd02HSvo+8nh6DtKcfQ9pToaOMBlW/tN99lSgcu2LjG7z5bq3cWrAc3/avXfRT1JkyxpBPnBbp0adp8G1bsvtB/W1JfUD2sXGriWdF0UdZ8GdaE34IUFFNDruthbbV1FdJ/a1NV/oB/ALiyggBVsYAcVNNBtvuK8DU/0NrzQbb46vQ0vrGAD3ebrzA9gFxq4Vu9Zdgathr1o9asvlffrSTWpJfUkTXKJbyM/xl04E71lL6zgWkzzndCPZheuCubb01v2RG/ZC9eSeoHVshfVpJbUkzTJkkbSDFr9elE6ZjpmOmY6ZjpmOmY6ZjpmOHxG1EUlSZJq0tqya5Jo99lQgQr6KmuOA5yJ3qG+cX02VODaj06FHyIvbGAHFVy29dhz99lQgcu2Hj/sPhuqD18y7941X7T7bKjACvrFoC+k9/SFCj5sV62RNINWQ19UkiTJK3ZHX1L/2d7N6wKy+9ymwAIK6EvqP9u7+cIOKmjgWlT/fd7M01eLN/P0f+rNfOGSTV/G1bbXP1zzvQ///f5Rt8Or+kfdLqzgWq51MdV9XlKgggYOcCZ6S15YQAEriM2wGTbD5u07fSG9fU/09r2wgAJWsOd68I9XXWigryi3+cerTvSPV124DuqH76GrfQMr2MAOKrhO6Q7fn1YTB66TuvU4Y/fJSIEF9Jm8h2MFG9hBBQ0c4EzMD2Z3yQ9mdynYCraCrWAr2Aq2gq1gE2yCTbCJr8nq2MAO+ppsjgYOcCZWX5Pd0dekOrrNi52fij2xgW4zRwUNHOBMbAdYQAEr2EBsDVvDdn4qVhxn4vmp2BMLKGAFG9hBBQ3E1rGp/7bhWEABK9jADipo4ABnorltOhZQwA6uCsVbZIWCnsu7QiGwgAKu5T03t5+JX9hBBQ0c4EycB1hAAbFNbBPbxDaxTWyeD+tOSPcJRoFuU0cBK+g2c+ygggYOcCaWAyyg24ZjBRvYwWVbdze6TzAKHOBMXPkQuGzr1kP3CUaBFWxgBxV023Qc4Ez0fLhw2aqLVz4EVnDZ1oV89wlGWl3h+XChgQOciZ4PFxZQwAo2EFvD1rA1bA1bx9axdWwdW8fWsXVsHVvH1rEpNsWm2BSbYlNsik2xKTbFZtgMm2EzbIbNsBk2w2bYDNvANrANbAPbwDawDWwD28A2sE1sE9vENrFNbBPbxDaxTWwzbT7BKNBt6iig28yxgR1UcNnW3ZruE4wCZ6JnyYUFFLCCDVy2deun+wSjQD90TMeZKAfoiuoooCv8F3uAXNhBV/iP9wC5cID+g/wXe4BcWEABK9jADipo4ACxrajw83mfqXRRS1pn++e/p0mW5BWH40z0kLiwgAJW0Jff16yHxIUK+mm0b7HzeuPEmejft72wgAJWsIEdVBCbYlNshs2wGTbDZtgMm2EzbIbNQ8Jvdfl0pcACSlyttfMq5ES/5jn/hQ4qaHEN5y97C3TbOgL5y94C3eZ7gIfEhRX033ZiBxU0cIAz0Kcy6Zob0H3akvqtOZ+2pH5rzqctBQ5wJnrj+003n7YUKGAFG7hsfiPN5y0FGjjAmegZcOGy+Q0vf4FbYAUb6DZzVNBAt03HZfObJT7RKbCAAlawgR1U0MABYmvYGraGrWFr2Bq2hq1ha9gato6tY+vYOraOrWPr2Dq2jq1jU2yKTbEpNsWm2BSbYlNsis2wGTbDZtgMm2EzbIbNsBm2gW1gG9gGtoFtYBvYBraBzfPBb3L7u9wC3ebN6/lwYQUb6Dbf1/0k4kIDBzgD9RyVO7GAArptODbQFdPRwAHORA8QvzHok7ACBaxgi4zyiViBCho4wJnoAXJhAQXs1/04n3x1kSWtu3X+w/3GopPfWDzJl784CljBBnZQwWVqTiNpBnlC+P1Kn6AVKOA6efA15ScPJ/UkTbKkkTSDVjRcVJIkKR09HT0dPR09HT0dPR2aDk2HpkPT4WFwrnsPgwsV9GFU33QeBhf6QKpvFA+DCwvoK813Vg+DCxvYQQUNHOBM9DDwO7s+ByxQwAr6OKFv93Og8EQFDRzgsk3f3h4GFxZwrceTalJL6kmaZEkjaV7kM8IuKkmSVJNaUk/SJEsaSeko6fAQ8PNenxKma6JQ9zlhgQ3soIIGDnAmeghcWEBsgk2wCTY/i/DTb59DFjjAmehnERcWcI3e+L1Mn0MW2MAOKmjgAGfiyojAAmJr2Bq2hq1ha9gatoatY+vYOraOrWPr2Do2H2D0e7rnbLHi1JL8j6ajggYOcCbaAfrsAt+1TMAKNnDZ/Facv5gt0MBlK760q/8vXP0f6DbfXXzI8cIKNtBtvmP4EKPfXvNZbBf6IOOFBVx1/Z6az2Iz8RXlA43izeQjjeLL60ONfvfMZ7GZuNgHGy+cgf4KtsBlWzN7us9tC6xgA902HX18vjj6AL04LsWaJ9N9Qpv57Qmf0GbrMYru710LrGADO6iggW7zZSgzcbW5+W7k8+ACK7gUzRdytXmgggYOcCauNg8soIAVxFaxeZv7nQqfHRc4wJnobX5hAd3mv9jb/MIGdtAH4g9HAwe4bH4lOmjzQZsP2nzQ5oM2H7T5oM19dlzgADNUfHZcIDbFptgUm2JTbIpNsSk2w2bYDJthM2yGzbAZNsNm2Aa2gW1gG9gGtoFtYBvYBraBbWKb2Ca2iW1i89TwWwz+YrZA30vOf2GAM9Cn8AX6vBBzFLCCDeygggYO0G2r0X0uX6AfVqej1z2xgwoa6FNbDseZKAdYQIlJAecMvwsb2EEFDRzgTPR88HlIPqMvsIEdVNASPQn8lojP6DOfkuRT+synJPmcvkAFvUJ3HKCvB18y7/kLC+jL69vCe/7CBnZQQQMH6DbfhOeUohMLKGAFG9hjBtA56e9cD97dJxprx7vb7/H4tL/ACjawg+tXnArv7gsHOBO9u/2S3acIBgq4bH5F7rMEAzvoNt8W3t0XDtBtvuW9u31+jk8UNL8i94mC5pfhPlEwsIFe13+b9/GF80L1KYGBq+669laf/Oc7l/rkv0AFDZyJPnPowgo2sF+T59Sn9wUaOMCZ6DOHLiyggBVcC7kusNXn/QUOcCb6YXxdTavP+wsUsIIxy1DP2YAXKmjgAGeizyq6sIACxqxUPWcDXui/4sQBzkRv3gv9V/h68Oa9sIIN7KCCPof0xAHORD3AAgpYwQZ2UEH/FX2hN++FBRTQf4U6NrCDCvqv8G18zu89cSaOAyyggBVsoG8LcxzgTPQ2vdB/xXAUsIIN7KCCBg7QbWuHOWcKXlhAAX2y4OHYwA4q6FPczXGAM/GcUH9iAQWsYAM76HWro093XCvV5wUGFtBnPIqj/4ru2MAOKmjgAGei9/yFblNHr+sL6X28JvWrzwO0NWlNfR5goIAV9Aq+1v0gfKGCBg5wJnofX1hyGc7J9SdWsIEdVJBf4X184UxcHTsO3/KrY8fha311bGAHFVw3LQ/fLOsgHDgTVx+Pw7fx6uNAASvYwA4q6DZfXhvgTBxu8605CihgBRvYQQXd5vvDGOBMnG7zvWQWUMAKNrCDCrrN9505wBnoEwjHmk6nPoFwrBlP6hMIx7ptoT6BcKwbFOoTCAM7qOCyrfsP6hMIx7r/oD6BcBS3lQMsoIDLJr44q7vHuv+gPoFwiC/ZOqIHGjhA/21rB/cJhIEFFND3dbf5ifeFHVTQwAHOxPMBmxML6L/C12TtoIIG+q/wNem36E9sB1hAASvYwA4q6HXXjuiTAgML6HV9E/YKNrCDCnpd39ze8+Jb03v+wgZ2UEG7HtzU861jF87E83HOEwsoYAUb2EFfv77lvbtP9O6+sIDrV5yb0Du2+o7oHXvhTPSOrb73ecdeKKAPAfk29t6svqq9N6uvPu/Ncz14bzr65L3AAgpYQa9rjgYOcCaeT0v7n/mLQS4UsIIN7KCCBo5Ef0vPmpGj5xu/Lqzg2h/WrTSt5wDZietX+FmQT8gLHKAPXa2V6hPyAgu41o6f9/mEvMAGdlBBt/naOcfJTpyJ3oUXFlDACjbQ6/oqOd8T4r/CO6v5L/bOurCDa8m6r6h1jA1cS9bPCjNxnSsHriXrvh68Cy+sYAM7qKCBbquOM9GPvBcWUMAKtvzFfoztvqq9Cy+cid6FF3rd7ihgBRu49knvofPNXBcaOMCZ6K86uLCAAvraOVFBAwfov2Jtbp8iF1hAAVcHeNKe7+C6sIMKGjjAmeh9fOLawafvyj5hLFBBAwc4E9cOHlhAASuIrWFr2Bo2H7/1ZvBJX4EDnIk+hnthAQWsYAM7iE2xKTbFZtgMm2EzbIbNsBk2w2bYDNvANrANbAPbwDawDWwD28A2sE1sE9vENrFNbBPbxDaxTWwzbf5Wq8ACCljBBnZQQQMHiK1gK9gKtoKtYCvYCraCzYPfb5L4JKoLPfgvLKCAFWxgBxU0EFvD1rF1bB1bx9axdWwdW8d2HjqG40w8Dx0nFlDACjawgwoaiE2xGTbDZtgMm2EzbIbNsBk2wzawDWwD28A2sA1sA9vANrANbBPbxDaxTWwT28Q2sU1sE9tMmx4HWEABK9jADipo4ACxFWwFW8FWsBVsBVvBVrAVbAWbYBNsgk2wCTbBJtgEm2ATbBVbxVaxVWwVW8VWsVVsFVvF1rA1bA1bw9awNWwNW8PWsDVsHVvH1rF1bB1bx9axdWxkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlSpYoWaJkiZIlRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpb4tKyxRqDVp2UNHzLzaVmBA5yJniUXFlDACjawg9g6to6tY1Nsik2xKTbPEh+V8/lcgQoaOMCZ6FmyBqPV53MFCrhs5uvMs+TCDipo4ABnomfJGrtVn88VKGAFG9hBBQ0c4Eyc2Ca2iW1im9gmtoltYpvYZtp8lldgAQWsYAM7qKCBA8RWsBVsBVvBVrAVbAVbwVawFWyCTbAJNsEm2ASbYBNsgk2wVWwVW8VWsVVsFVvFVrFVbBVbw9awNWwNW8PWsDVsDVvD1rB1bB1bx9axdWwdW8fWsXVsHZtiU2yKTbEpNs+SNStCfe5XoIEDnImeJRcWUMAKNhCbYTNshs2wDWwD28A2sA1sA9vANrANbAPbxDaxTWwT28Q2sU1sE9vENtM2jwMsoIAVbGAHFTRwgNgKtoKtYCvYCraCrWAr2Aq2gk2wCTbBJtgEm2ATbIJNsAm2iq1iq9gqtoqtYqvYKraKrWJr2Bq2hq1ha9gatoatYWvYGraOrWPr2Dq2jq1j69g6to6tY1Nsik2xKTbFRpZMsmSSJZMsmWTJJEsmWTLJkkmWTLJkkiWTLJlkySRLJlkyyZJJlkyyZJIlkyyZZMk8s6Q5GjjAmXhmyYkFFLCCDXSbOipo4ADnhXacWXJiAd02HSvYwA4qaOAAZ2KJM0fzqWhjTYQ0n4oWaOAAZ6Lnw4UFFLCCDcQm2ASbYBNsFVvFVrFVbBVbxVaxVWwVW8XWsDVsDVvD1rA1bA1bw9awNWwdW8fWsXVsHVvH1rF1bB1bx6bYFJtiU2yKTbEpNsWm2BSbYTNshs2wGTbDZtgMm2EzbAPbwDawDWwD28A2sA1sA9vANrFNbBPbxDaxTWwT28Q2sc20+RS3wAIKWMEGdlBBAweIrWDzc401G9Z8ittYEyzNp7gFNrCDCho4wJnoWXJhAbEJNsEm2DxL1sRNO1+Id+EAZ6JnyYUFdFtxrGADR0RmOaPCsR1gAQWsoBc7sYMK+qKb4wBnokfFmr1gPjMuUMAKNrCDCho4wJl4nkr4lj9PJU4U0G3TsYEdVNDAAc5Ej4oLl21NebRzvtyFFWxgBxU0cIAz0aNi+pb3qLhQwAo2sIMKGjjAmTixTWwT28Q2sU1sE9vENrHNtJ3z5dZ0Tjvny10oYAUb2EEFDRzgTCzYCraCrWAr2Aq2gq1gK9gKNsEm2CROykykgg2MkzITUdBAt5njTPSouLCAAlawgR1cw7hrdqn5LLrAAc5En95wYQEFrGAD16DxmpRqcj7sfqKBA5yJ5wPvJxZQwArmCec5t+5CBd0mjgOcieej7ycWUMAKNtB/W3dU0MABzkSfNnFhAQWsoNt8J/AJEmvOqfk8vECv6z/TJ0hcWMBVt/i28AkSFzawgwoaOMCZ6BMkLiwgtoltYpvYJraJbWKbafOZfIEFFLCCDeyg24qjgQOciT5B4sIC+sFyNY5PL5t+cPfpZYEDXMXWExHm08sCCyhgBRvYQQUNHCA2w2bYfJ6NH8Z9ytj0A7bPE7v+qe8lfmD1eWLTD3U+TyywgwoaOMCZ6HvJ9A3ge8mFAi7b9PXre4kfAH322Jy+Jn0v8UOHzx67Ft33kgvzB/nksLmeETOfHBbYQQUNHOBM9J3gwgIKuGx+ruHvT5vrIt78/WmBChq4bOseqfmr1C5ch47AAgpYwQZ20OuudeavR5t+bPF3os31nJqdU9z8gHJOcbtQQUv0tL/QK/j69Vy/0CsMRxf7KvFU9tNxf4NZYAd93/H1cDbOiQOciWfj+G87G+dE4V+oYAM7qLkevHEuHOBM9Pw9f7Hxi41f7NPWTvQdsftK9R2x+5/5juh4zue6sIACLsWa0WjnzK01tmjnzK0LBzgTfZ+8sIACet3p2MAOKmjgAGei75NrqNP81V6BAlawgR1U0EBvsrWF/H1egQUUsIIN7KCCBg4QW8Pm5zDrKVTzqWiBFWxgBxVkYzU2VmNjdTaW7/ZruNV89thc46bms8cCCyigL053bGAHFTRwgDPRjwwXFlBAbIbNsBk2w+YHlPO3+RmIX0765LDAlj/IjyIXKmigL7r3hR9FTvSjyIW+6L5S/ShyYQWxTWwT28TmzXthbhafHBZYQAEr2MBU6DnBcjgWUMAK+gTL6dhBBQ30/exwnInephcWUMAKNrCDChqITbBVbBVbxVaxVWzem2uSvfkkrrmmyJvP3JprrrudL8q6sIEdVNDAAfpC+gY4W+/EAgpYcxn8QHVhBxU0cIAzUflB3scnepOVEwX081RfXm+yCzuooJ+n+vL6Gf+FM9H77cICCljBBnZQQWznCX139GLq6MV8pz1P6E/soIIGDnAGnm+wurCAAlbQbdOxgwoaOMCZeJ7Qn1hAASuIrWAr2Lwh15N55rOmAmeiN+SFBRSwgg3soILYBJs35HrMz3zWVGABG+j/7mo9n/MUWEABK9jADipo4Ej01luP45lPdJrrsTnziU6BFWygK7qjggYOcCZ6611YQAEr2EBsik2xKTbFZti8u9eje+YTnQJd4VvIm1d8//XmvXAmevOK71HevBcKWMEGdlBBAwc4E2cqfKbOXE/mmc/UmesZPPOZOhf6/nthAQVcS7aezDOfkzPXk3nmc3ICBzgTfU+9sIACet3m2MAOKmjgAGei7+vrQUHzOTmBAlawgR1U0EBXrM3tE3ECCyhgBRvYQQUNHCA2xeb7+noW0XwiTmAFG9hBBdlYysZSNpaxsfyQtN7lZT53ZlbfjXz/vbCAAtbcz3z/vbCDCrJP+v574Uz0U8ALCyggtoltYpvYJjY/JPlvm+dDOIdjBVv8IJ8aE6iggf64TXGciefZ4Il+NiiOAlYQW8FWsBVsZ/OemJtlygEWUMAKYjv7eP73f//Tb3/527/+8R9//ttf//kff//Tn377w3/lP/iP3/7wv/7rt3//49//9Nd//PaHv/7nX/7yT7/9P3/8y3/6v/Qf//7Hv/p//+OPf3/8v49196e//p/Hfz8K/t8//+VPi/77n/jr4/WfPgYA1wmd//ljBLBIlnj8r2+KlNdF/MF3L/HIhCxg9Zu/l9d/798P8r9/nCizAH3eXoB1dXQuwDheLUDbLMC6o+J//zhBemcB/CTSCzyC69UC6Ou/90/B+t8/LovfWoAev+Bxh+rVAozNGqy5Cft7a2CNcly7USmvlqBsdkVbd2vOjWD2chF2+/LjhmGUeAy8jv56X97sjDPbobAlWr3997Va7M21Pa2JVe6bGpv9saybfV7iMUKXFR634L+t0Dfb82j/Q0v+UGGzS/rN6nOPmm9W0Ja7xCGvS+xWpn/b7lyZjyvy1ytzvq7xGPKTWJu1PnVX1W8D6tht1AiYx+1yKui8/0tU+CXVXv4S2dRYr2WOmHhcbmYN/XaFrguC1z0yIyhK7/KyRNvtWrFjPE7PnvrU7lfoGdemrytsdq3HsHNu03JQo333M2yzECMj+/mo9/1CbDLzMWIbJR4jtk87uJb3toe93h67vcJabJD1luFXJeomvKXn8esxgFtelpBPt2ndrAop1XKbPh2EvtumdbNjyYijWD1eFvjJuiysy/FyRXyeersS1e/jXXEzXx9C6tjtWJbL0Z+OZHL0b2vM3XnZyPMyfarQbv+SdhzRp49hudf53cruYJjnNmU8nx+Wbw/qbbNdS7HcuUp5nPlTRb49V27183Xa2qfrdPtb5NBYqUVK6a9/yy5Bi5GgYz4tybcd2zYRKpZbVx633OiWL/yWOvOUTdrzqef3v2V3hNc8dRRV1oeUb3uu747wRWLD1MeR8anGt8vRy/bUL3ay+jg2vK6xWw5pearxfAr7Q43NftpmLsf6/PjLGvst4x8bu7aMPe2r32+Z3ndrNfeQKrapsdtT/cMP115Wj9c1dnuqSCSqSB3v1Wit5eF+vk6QvkvUFqtDlXPAOr/dT/XYnZYPrrPm6xKb3XS9y4/r7eN1jd3useZxxoKsWYuvq2x21PU509hRZT7tHt8mu24v3SVX6ePW+MsSu/Uh3XJ9jM1m2eyk5XFDMC8cH9xeVtnu6pZnUQ983S7bxq01V2qpTV83jM7dAXNwX6g8blC+CHc7ftfDQzvyLP1xdd9fH+pMftdDbtPcRR48Xx+mbHd2Wrmsf76MlO/uTlj/dJ1ul6KVjMLWjpdLsTslk9LylxQrL0/JbOwuiPPqqdrTPYrH6dntGq3mtWirz3v6dzXG8flJ3Sgf72HbNZqXLutY9fokd1dDKjU2W2V8fOdpfHznaXx852m/JkZ2yeO+y+s1sbuAqjOPtO35wFK+PUEec3dCKLmP12Gva2wv5PKY8Gi11zXmbn3UvL8svenLGtt16t+svdbpN7/lC3uo5joV+2Y5vq0xP95D58d76Px991DLA4rMTb/P3f2nw7hhUp8vjL9NrrnZQ9eslLzr3sdbNR7Dojl4oM+XcN/VKEf5PIb9guJ3zGEf9L22i+l7e7nPkL5uQ8l4WaMc/eMhgEM/HgM47Pfc0etRZ14BVtmsjLm9GM1r0frNnq5fKOJT4q5VOtrrImW3m6530cairLe0Pq2U74YkdqMBI8eIxtOBun53Mrm/U3lwp/LpDrjeH1xpNVfI4wCnrwdXdgNNj30h77mWb8Y1+heKyGH/807yfRH7eGijlPHp2Ma+xK0b4WU32nRzdKNI+XR4o+x2sbvjG/e3im22yvYuUt55qbI7wMjnI6Ly+ZCo/IIx0e3q6JmGdXu8ld2B33IHWVPeXo6K7ouMHNS0bxrm+yK1fN6329Gne337+QBW2Q4/3ezb2j/u292gy+2+vb1VNn273z0097Ex39zHRskRglGfFuSHIm13ke+feLmO2k8H7R9G8Ld9N3MiQZ22OdTtbyXd29t341A39/ZtiXt7e+uf7+27Uaibe/t2EOru3n57q7x7lJp5C+cx7Kmvd49+fL577Iahbu4e2xL3do/dINTd3aO3j3eP3QjU7d3j9lZ5e/fI9HjsHuO9E+V2lLzhebTdPrZJ1JvTiIr+gv1UP99P9fP9VH/Bfqqf76f6K/ZT/QX76Xbv+AUXlv5B7HMvNZuvLyx3I1Dru1NxM6fVzXF/NwQ1D0ZLn/b0Hw77+xUirBCxN1fqrTlaxXY7auPW1GMo+nWN9nnbWv+4bbcl7rWt2edtuxs+utm2Nn9B297eKpu23e8dOX/lsXfoezU6d8i6vj4wjLq7Bctk/qO0t2r0mfPxtzX2v+XWlMYy9OM9fVvi3p4+xud7+m4g6uaePo/dXI2cXN/ladz4hz19OxB1Z4Lmfm3cmyVaZv10KXYro/mjzecRbj51yo8r43aR8V6RfuT8l35sN8u2iOa2PZ4nJn2tSN4e64+hjTeLlLxl0Mt8XUSO3WnQPHJy44PHUywXezdCXk4Glt2IlHEHxDbXQPtThztTkuVon1827IvUTPbH+djYFNnOcFJmONnrRxiOz2/0y/Hxjf59iXtPMZTPb/RL+fhGv5RfcKP//lbZPMmw3ztYH+P1gX9b4zGWxIDj69P1n9U4Pq7RSh5l2tMI/5dqMAflUe51jTI/PiHb1rh5QvaT9WGav2WOj2v0Q95cp3lx+hj/fL1tdw8wPe4h5xRLa5uu2y6IcRpi83UU7oaT7m7cXY1fsnE5SNVd4+5u9D8G758evTzeXKmMSD0G51/vZbuhj5aD0U0227ZuJ+HOnCXQjtendvvlqHm8fX505ofVsT1m51Bhq88jMN8fs3dDUjdvPMhuTOruMbvax8fsbYl7x+zdQ1F3j9m74aibx+ztJKPbDx/q58fs/d5x68bDvsa9Gw+yG466G2P75bh100Da53tp+wV76e1f8joHd6Met65d9vHT8mGmpk+T+n6Iny6fTtyQ3VjUvYkbP/kphclSu6uf7XLcm/2xXxB/g0pcZstmQezzdTo+XqfbEr9gdXTe+dBL26yO3TDS53t6b3mg7X1urrB1/9wePyVLyPFdou9Gou49HyL7h7LyfsPTtPcfl2L32G/J65Ymz+fY90us8ZqnF9P0470izPl8sJY3i3C2X55H9r+yUnO6dx+bTWvldy1RDuO89Bjl5U/ZF7m5ZfZFbm6ZnxS5t2W2nas5NajP56lBX7k3piV/jX77nPuXimT/P5Zpc7K+G5DKG59PE5S+e3vNfiFaTjxf37F/85dUq1nEXs9Q9Md0PjxGjc+P++N3PmSvr7PH6tCyWx27GOr+FsDrZH32lzv72Bz319e3Y/84dHO03A3BNOFUSObrkXkZ+9n4OY5z1NeXHtsBlHsX6rsBqTIOXkAwHpv45VDBzzbOUdk4T6e6X0ii9dWD2DiP232vN85sn99g3z0gdfdifX48drovce8yaH4+dirz47HTuhuQun2xfnurbC7W93vHvRvsuxp3b7D/pMbxcY2bN9i3Ne7dYK+7gY+nGw99Tnurxs37uHeXY3sDZL9OeVrr+W0sP7xLqny+Pm7W+OC33BtwuFtjN+Cw38duDTjU3av0bg84bBfk3oBD3T3ddHvjjs939pvL8f4Ocm/Qou6ekbo9aLFdkHuDFlXap+dCdfeE1N1Bi/1y3Bu0+NmZbns60311F6PuXs5393R5W+TmfYzteS6vNS2mr3eyX/CEVP38Can6K17x9/kTUvXzJ6Tqr3hCqv6CJ6R+chWUVx/y/FDAD1v2FwzOb6+kbnbtblzMH2e/Nq3Ut1aHlLyzJOXpiv371bF7sulmEO7e0Xc7CLfLcW+V/uT+1tPR5XiaU/eVm2SPP5wUkZdB2Mbnd9q2RX7JXeGba2Rb5O4a6fIL1siuyL018pMJkyUf5iny7vzPcjCmJOV1ke3TnhxwH3eZ7eVtobp/yd6tuQa1j88Pl7tZlzcPl9sS9w6Xu3Gpu4fL3Zv6bh4ut49I3T1c3t4qttkq9vFcg32Ne3MNqv6Cy3X9/HL9J7/l3nubd49I3dzTtyXu7en3f8nrE6HdfO17c633EZbvZbHnq9sfIsz652f89vl0qWr2+Yb9eCJKtc+nS9Xx8XSpOn7BdKn7W2UTYdu94+YZ/+4lfXejY78ct8Zf6tCPT7V3A1L3zpL3S3GvxPatmveuXX5S4961y/x45mmdv2Dm6X45bq3Sn7y2I19ON8rYfHVj+46rW0/ebr9scPN8cn7+vEmdHz9vsi9xK4zb8fnzJu34+HmTdvyC503ub5VNGJfPTyfLx2eT7fh8Ev+2xt1Dwi+4Q/j57lU+Pta37Tv6bj/+d/+bKC8P1K18eka6/RKI5fSTx1nW82tCv/9+xvbtegxy1ud94wsleI7gmxfZfl/CPr3XsV0ZOnPQeBx9szK2F/Z3ZhU12b6C/9ZLMbclbn4kZny6Sbafd8m36j2/Re6Hz7vsKiifMxivK2yHafL21XpH11ONfr9Gy3G8R43+skbbfQ6qTMlPjT14vtzHP76dt/9OjWq+seQx6PuUgD98p+b4uOO3Je51fP18dewOKMYbju05g7+t0D7dx7cVbu3j288G3dzH958eurmPbxvl7j6+GzqTvFX8zYvqf/hu0K5G51XivW9qbL9PI3mR8mDdfDloV+Zmp2xL3OuU3T72C4Lju9UxX6+O7YeUOCHW+vwBI3mzhn1e42m6y5c+6HRoni0cuvkI0vbFb8Oy7caomyLbz+PmlfDTrM6vlch3x41ub5ZouRRPb5F4t4TW91aodL5R8Xwt/cUiHBa09Dc37Sx5/Tg322X3PFfVvFqpz68V/dLHumoeYB7hXd+rwQe/2hyvt+7tj5dtatz+EJu97tumn140bZfCeHf+ODYptnsfn/XsfOvPT05/9x0A3b5qYHBkeB5O+P5QuRsYmU8vK3p+3O/7GmM74J3fHXvw0xfyvv81u7U6ZOZafT5ofyXXR173PFBf19ge6XrLKQCPJNgc6XYfhZrcIjiebzTYt+d12zGrwhopfWyWY/fqyBwOmGWzUnclnqZEPI8o/Fhjd//o3pfY2m606Oan2La/pRz5ob7y/DqrH3/MdlYVF1FzbgJgHJ8HwCifB8DuMai7AbB7iOl+AGy3TeVjbHXKezvrt0Xm61O77dccOczIeH3mv6/BvcrHRcB7NaoyuHC8/iKkbsfO85xqvPc5x8bd9MdF4nirxuNeZ07rLuP1xwvbbuhJNS9BHljeK2I1b9BZfZqa9cUio2eROd4s0vi4Qav1zSIjxwfs+aT5Sxun5XS1/vyQypdqWK6RPo7yZo28oupDNl+43L6b73GPM6dHPC7M6qbM7h6/MHn/wVo2ZXYnE70zi6/rcby9NDwS/ViauSmzfQ/s6Hxzbth4dxXzLeMH93f3mOf3Dtp7NZhk0OfTx4y/9LXaI/dcLeW95dCSV65adl0oH5/dbD+aqz1j9sFPz99+6dO7ypnJg8e7VZR7gWqHvVnFhF/0/Em/L1bJIZUHbwJ7X2XkOOqDS3l3WZ7W7iiv127fPZ/0hXzajVatfHqaezDn+2VuxtxPftTdmNs+M/U47y7E3G4V/6TMzbT8yfbuT/uevr3v5WuJH9zf7abJTqNT27tV+DS3TpvvVTHJb4Yu7u9W4TPS9rjGfF1lN0Hil3yg2xiFGdbLm1UGjw6MUY43q8ynZZmbU+X9x8L5ZLBtRgq3NQYT38bTMeBrNTo3hvT1VdD+ps6kf+rzcx0/LEndPll65/uf+xK3Bgz3JW6NGP7k6+tPD5fM49Xbcfpunc5i3Fp6OS61LyH5NqkpMt4Zl6qdGzr1eR7N175pz4eDS7Xyukpv+ulg377ErcG+/vljUF9YHfL+SqXnrL7Zuevj7VTpmzsp/eNx2H2Je5um/77jsN+ujt047E82DRfJZsfLKrtb3PeibFvh3tyH7UlarU+fUd/cJOu7u2T3JoJsSzzSsPIhdW1vFrGn85nnvf1rRXKA6sFD39nP1hd7c732+vrwv//wjOaZ1YNneauK+BuWrlupTycRcoz3ajxdEXypRs+3jT5uEJe3alSmjtbnL0b9UOPz11ruSrSj5IBueb7ZUOb9GiXvtD9yrb2s0XfPVN3M5W2Je7m8e7biXi5vV4ZUHq14Pln+YWXsprDOvG593PTVTZHdm0t4Nd7T5cN3d5F+shjKYlh997fwstFvP1L/tSJ8N6a/vVbziZV+6PGyyNi/vyA/cFJ3Ncqnh8tthVuHy7H9Tu29qYLbGjenCvbxC6YKbl+c1vNybHR5/fbnPj+eyrovcS+A5sdTWfcrQ5+mcNlmZbRPV8butfFV8imiWp+fMfs+gPbv9rszh77vnt65N4d+X+Lmp9SPX1Fje7HOxZh883El/W4UeLNdZt5Wmk/vX7DvXgSxf+rlXsfui6gYowLy9MRJPepXyvAqywc/HV6+XEYo02RTZncXI69Anl8DVb87w/3ZkvBYpX7zXOXXflBrDJe051GBr5XpT6u3Pz0Z+X0Z3T1q9YvKyMGDUsfzvczvZ0Fsi/Aa98d95/5mEcmMFbHXRbbtLHzmTB6x/7qdy+fv6vxJDVqxl/ryOL4vcvOE4idLcu+MQrdjUHfzabtxGrtJn+P1xpHtfIqckN2/ecV1/b7IdmTj1lseVOrNveT1g8W6e9/evac29yVuPVisu29I3XzyU3dPYN178lN37+u7+2Dx/a2y6d3t3nHvLQ9aP38H6k+W49ZbHrR+/EI13b327/5btvdLcuu1BNsVcvNNDz+pcetND1rH5yt1F6g33/SwX457b3r4yUnN0+yN9jR5+IfTiM+fxNLPn8TS1n7XEjdf6vaTVcr09Mfq7S9X6e4y7ebFze6q9XGHOydSann9WZvtlS+Tr0aV9uaV773tsnvA5eZ22b77QvOFJOP5JtH3P6UcHw/L7EvcutG0/Sl3Twz3Re6eGPZf8OT19j3/Pe/MyvPU4+83jPbPX9Wr27Gdm6d0u9mKN0/ptiXundLp5y/z0N3XqG6e0u2ew7p9Snd7q2xO6frnr+pV/fyt5T9ZjnundPbxh1PUfsmHU/ZLcu+Urn/+4uGf1Lh3SrcdpLq5UvUXnNJtl+PeKd32+GI55Xr0Nw9ROYtWx+upWOPz05fd+6Sr5CtpHze+n0cg7H4Ny+N1nd+8deZ+jXZkjXY8T5H5vlXGxzf/94uRJ+qtbBfj85cg/qTGzVtb+88E3Ly1tV+Sm2cw8/gFZzDbU6nO7JRiL7fNroYww0VU9b0aPSe4iFp7vY/M9ukAke6+dnRvgGhf4ub1z3aNPs2xPXSzNn7Bpyh0bh9qz237+AHyckls92TQ3S+32fak/94JiO2ODveOlXbUX3IC8pONc+vLbXX7udORV5bPZw/fv5jMju107lsfbrPj8zdV2vHxmyr3JW5dfVj5/E2VVj5+U6WVX/CmyvtbxTZbZbt33Ppw27bGzQ+3/azG8XGNex9u29e49+E2K/c+nLL7ltW2xs13d95djm2N/Tq99eE22w183F0fN2t88Ftufbjtdo3Nh9t+so/d+nCbbT9DdfPDbfsFuffhNtu9z+/uxt3VuLuz31yO93eQex9us+2Q1M0Pt+0X5N6H26x+/BJ1q/b5bYP9cty7E/OzE907H26zdnx+trwtcnPC8PY0997dYGufD/Bb+3iAf1/i3vlY+3yA39rHA/zWfsEA//2tsjsfKx/fDbZefkEUyqddu/0pN++f/qTGrfun1j++f2r9F9w/3S/HrVW6nQd+6/bpvsKdu6f7h2HymvSBT+9Z+soDNcpDOTrrezVGvsBAnm+ffu2hHE7EDnn9W7pt3wd678mebZHH9szB22EvH8vdlpjZbjrF3ivBEPLzl9b0/laxPFCLPb9m7Stb9psa7c0aQo262cOsfHpjfF/i1vQC+/wxp22Jm2ct2/Wp/+Nzkl/bJk/3POebyfG8HO/W4LRlvWLgzRpNbtX4eDDMPh4L+8mT+DnYMUXefJg/X737wJdPrm7fbHBrVfykxK11sX3fBK8Q/uaU+EvvrCi8Inbz/Py+Rp7PyvO7+75Wgz4Z8/Vj3j95J0njbSKjb15vdb/K7t1UP6nSqGKv3xpjc3cX6d7bSG03BnX3fV3797QIr/+em7cR/mSdcL3x2MhvvzPmeVnq21W4Qh+zvfmGocctQB5gl1bfraJP7wZ6+z1FPPr5YJF3q7SnKv3dtx3V+lxF363ydM+wjrfXiz1VmcebVdrTW6CavLul2/Fc5e29jlfHPi7wX2+jsX1crz09m9Z2O8zPyvA6icfCvH6H09jO9L39ErOfLU1emDx484rDr/yoD8oYL6d4flXwj+um//+xbp7uCjy/guSDH/VBmVZ45cbuvbJj+zTVr1o3fB/xwa3/kh/V3o3P42AOzPMn1b/4+rt5PFV5vfP95O2/+Q7xB843i2hh+rzYm0V6Ti6yPt/9OZY3Tm28/W7m55/zfhG+76D27ruZLed7P67r27tLkq/AeBTp7y5J53MVvf2CrVM2kVB/yduDf/LG6qJ39pT9i9ErL1fvmxeLbT80lZ95kOe5m99/JGpsP5J3b87k59/ZG+34XUvcfDPZbn1W3o5U7fVHt8Zu6OTWy2u2S9G4ufQ8tv/jUvSPLw/HbkHufqxi+xkz4Quh0l/+ln2N5+/Hvl4frW3nbN78ntquyL1b2/sSt25t/6TEnVvb2+/13bpHta9w5xbV9ruYt5ZhX+HOMmxfMtef3jH3PG39u1GovhtutXz/5+NO/avh/O3M6BzUK/Obd6N84YcMPub7/A2V73/I/pGqOxOSx+688t6E5H2JexOSt6/JGHz5RI7NythdV6mxVdReHk1+VqQ+vze7viyyO0/oDD335/OEH37ObtbJ00elvl2t9bsi24dUc/7cKN02RWw72vA0R7u+/jnbB6sar0IpTZ7yo3w3aLFdlsfZDhM1j82eshuQEuULV9pev61mX4RX2D/ypG+K9N95+1TJWQr1m+nvP6yT7Ve/Gi1YxubnjM9/zu6M0PLtas3qfCdam+ae1qxtonV8Hq3j82gdn0frzyLt6fX7r1/uOsavyMXx8fsu96k4hSNvfzsVJWeOleebIF8rkmdDQ8pmSXaPWNnMu/w2n4e4fiiyG+XPr6i2p3cZPC40v5DOB/dAHvz8JbXj+G5Jdt+4lLxnkAXau0eatjnS7J6PKuNpLOjpEui7OX0/yeWbe8i+yN09ZPyKPWR+vofYp1cwPzk63F2p4/OVOncPWd1dqXP3WaubK3V75GaQr9ZvXrzxhSKPe/b59Nuhrw//8/i9i9y71t6XuHWt/ZMSd/bU3Vx+Bgf7N2ODNm+X6JlBjwuAN0vkXI5HtfJOCSk8OPv8vbTv99F9ibwKKU/Txb9UgumW8vReuu9LzGK7e2P5mEc93iwx+Vhaf+uHMNPo8VfyVgmem/l26ukXSljeyBbbrYvtu75+RZGiyofJnmflfamIGaPfU94swntmHyeI720ZyR8jYu/1Ss1Hbh97SnlvKbiorMdbP6Qcwieg9a0dfT05FCWeX9P/pRLKl3nHe0tRn77jMt9biqev9PSnK8EvlVCeqhjzvR/C3vn80uAvlWD+We1v/RDLKaPP3zP8QoGZ5+azv/UjuGn6POfsKwVyn5rWP/wJ7xV4HA6NI2p5dW0xd4NN8vTh65cVPn+GfO6Gmu49szR3QzzrHjh3sI/n73V+96KC3UlOzlnq3zwA0d4o8M18/9sF7n1bbVfg1nvvdgVuvfXu+HRY5vgdR2Xu3djZvsksnxkr7Wk05PtXXO+/MfH0ypv2Vgl7mi3Z3luKoU+TYvWtEjNP/Mus460SyiiZ2ns/RHmQ+PkVMV8pcTCx8RjvLYXwDlZ5von6hRKV6bjffGb8K0vR+BSCvvdDODcstein6+LtEvlNy8cPeQrc8pWlMLaIfF5C3ypRcwT3geO9Evr8mcC3SjxHTntvXVQm0bfn5wjfLfHeRm3yND+2vFeCi8Gm+mYJfsjzJdhXSuRNuceFy3sbtU0e9j+ON/cLrhnkrY3Kez7aeGtlsms+f6Po+wJz92a+R+w10uLpNHHcv5PGjTR761fkC/W0vbUpeh4I+/Pdqy8UyGkafdb3CuSkrtk+K6DHe0vw9Dz+W1Gp+bkarfPDJfh+M/7vx//847/++e///Je//esf//Hnv/31Px5/99+r1N///Md/+cufrv/5f//zr//69P/+4//99/h//uXvf/7LX/78b//873//27/+6f/859//tCqt/++34/qP/2WP++z/ZI8b7P/7n34r63+vJ6zsMRzx+N/V///H3TCrouv/X3+g7XFZ8fiPsf6B/4U+DhaP/5j/+7/XIv9/",
       "brillig_names": [
         "sync_private_state"
       ]
@@ -4172,147 +4172,155 @@
     }
   },
   "file_map": {
-    "102": {
+    "100": {
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/aztec.nr",
+      "source": "use crate::{\n    macros::{\n        authwits::AUTHWIT_TYPES,\n        dispatch::generate_public_dispatch,\n        functions::{stub_registry, utils::check_each_fn_macroified},\n        notes::{generate_note_export, NOTES},\n        storage::STORAGE_LAYOUT_NAME,\n        utils::{get_trait_impl_method, module_has_storage},\n    },\n    messages::discovery::private_notes::MAX_NOTE_PACKED_LEN,\n};\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `sync_private_state` utility function.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n    let interface = generate_contract_interface(m);\n\n    // Functions that don't have #[private], #[public], #[utility], #[contract_library_method], or #[test] are not\n    // allowed in contracts.\n    check_each_fn_macroified(m);\n\n    let contract_library_method_compute_note_hash_and_nullifier =\n        generate_contract_library_method_compute_note_hash_and_nullifier();\n    let note_exports = generate_note_exports();\n    let public_dispatch = generate_public_dispatch(m);\n    let sync_private_state = generate_sync_private_state();\n    let process_message = generate_process_message();\n    generate_authwit_exports();\n\n    quote {\n        $note_exports\n        $interface\n        $contract_library_method_compute_note_hash_and_nullifier\n        $public_dispatch\n        $sync_private_state\n        $process_message\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::messages::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n    let notes = NOTES.entries();\n\n    if notes.len() > 0 {\n        let max_note_packed_len = notes.fold(\n            0,\n            |acc, (_, (_, len, _, _)): (Type, (TypeDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n                if len > acc {\n                    len\n                } else {\n                    acc\n                }\n            },\n        );\n\n        if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n            panic(\n                f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n            );\n        }\n\n        // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n        // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n        // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n        // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n        let mut if_note_type_id_match_statements_list = &[];\n        for i in 0..notes.len() {\n            let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n            let get_note_type_id = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteType },\n                quote { get_id },\n            );\n            let unpack = get_trait_impl_method(\n                typ,\n                quote { crate::protocol_types::traits::Packable<_> },\n                quote { unpack },\n            );\n\n            let compute_note_hash = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_note_hash },\n            );\n\n            let compute_nullifier_unconstrained = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_nullifier_unconstrained },\n            );\n\n            let if_or_else_if = if i == 0 {\n                quote { if }\n            } else {\n                quote { else if }\n            };\n\n            if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n                quote {\n                    $if_or_else_if note_type_id == $get_note_type_id() {\n                        // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n                        // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n                        // unpack function on it.\n                        let expected_len = $packed_note_length;\n                        let actual_len = packed_note.len();\n                        assert(\n                            actual_len == expected_len,\n                            f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n                        );\n\n                        let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n                        let note_hash = $compute_note_hash(note, storage_slot);\n    \n                        // The message discovery process finds settled notes, that is, notes that were created in prior\n                        // transactions and are therefore already part of the note hash tree. We therefore compute the\n                        // nullification note hash by treating the note as a settled note with the provided note 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(note_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::messages::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 `note_nonce`.\n            ///\n            /// The signature of this function notably matches the `aztec::messages::discovery::ComputeNoteHashAndNullifier` type,\n            /// and so it can be used to call functions from that module such as `discover_new_messages`, \n            /// `do_process_log` and `attempt_note_discovery`.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                packed_note: BoundedVec<Field, aztec::messages::discovery::private_notes::MAX_NOTE_PACKED_LEN>,\n                storage_slot: Field,\n                note_type_id: Field,\n                contract_address: aztec::protocol_types::address::AztecAddress,\n                note_nonce: Field,\n            ) -> Option<aztec::messages::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::messages::discovery::private_notes::MAX_NOTE_PACKED_LEN>,\n                _storage_slot: Field,\n                _note_type_id: Field,\n                _contract_address: aztec::protocol_types::address::AztecAddress,\n                _nonce: Field,\n            ) -> Option<aztec::messages::discovery::NoteHashAndNullifier> {\n                panic(f\"This contract does not use private notes\")\n            }\n        }\n    }\n}\n\ncomptime fn generate_authwit_exports() {\n    let authwits = AUTHWIT_TYPES.values();\n    authwits.for_each(|(s): TypeDefinition| { s.add_attribute(\"abi(authwits)\"); });\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n    let notes = NOTES.values();\n    // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n    // generating partial note helper functions.\n    notes\n        .map(|(s, _, note_type_id, fields): (TypeDefinition, u32, Field, [(Quoted, u32, bool)])| {\n            generate_note_export(s, note_type_id, fields)\n        })\n        .join(quote {})\n}\n\ncomptime fn generate_sync_private_state() -> Quoted {\n    // We obtain the `utility` function on the next line instead of directly doing\n    // `#[aztec::macros::functions::utility]` in the returned quote because the latter would result in the function\n    // attribute having the full path in the ABI. This is undesirable because we use the information in the ABI only\n    // to determine whether a function is `private`, `public`, or `utility`.\n    let utility = crate::macros::functions::utility;\n\n    // All we need to do here is trigger message discovery, but this is already done by the #[utility] macro - we don't\n    // need to do anything extra.\n    quote {\n        #[$utility]\n        unconstrained fn sync_private_state() {\n        }\n    }\n}\n\ncomptime fn generate_process_message() -> Quoted {\n    // We obtain the `utility` function on the next line instead of directly doing\n    // `#[aztec::macros::functions::utility]` in the returned quote because the latter would result in the function\n    // attribute having the full path in the ABI. This is undesirable because we use the information in the ABI only\n    // to determine whether a function is `private`, `public`, or `utility`.\n    let utility = crate::macros::functions::utility;\n\n    // TODO(#15012): Here we use PRIVATE_LOG_CIPHERTEXT_LEN for message ciphertext length. Fix message vs log naming.\n    quote {\n        #[$utility]\n        unconstrained fn process_message(\n            message_ciphertext: BoundedVec<Field, aztec::protocol_types::constants::PRIVATE_LOG_CIPHERTEXT_LEN>,\n            message_context: aztec::messages::processing::message_context::MessageContext,\n        ) {\n            aztec::messages::discovery::process_message::do_process_message(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\n                message_ciphertext,\n                message_context,\n            );\n        }\n    }\n}\n"
+    },
+    "101": {
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/dispatch.nr",
+      "source": "use super::utils::{compute_fn_selector, size_in_fields};\nuse poseidon::poseidon2::Poseidon2Hasher;\nuse std::{collections::umap::UHashMap, hash::BuildHasherDefault, panic};\n\n/// Returns an `fn public_dispatch(...)` function for the given module that's assumed to be an Aztec contract.\npub comptime fn generate_public_dispatch(m: Module) -> Quoted {\n    let functions = m.functions();\n    let functions =\n        functions.filter(|function: FunctionDefinition| function.has_named_attribute(\"public\"));\n\n    let unit = get_type::<()>();\n\n    let seen_selectors =\n        &mut UHashMap::<Field, Quoted, BuildHasherDefault<Poseidon2Hasher>>::default();\n\n    let ifs = functions.map(|function: FunctionDefinition| {\n        let parameters = function.parameters();\n        let return_type = function.return_type();\n\n        let selector: Field = compute_fn_selector(function);\n        let fn_name = function.name();\n\n        // Since function selectors are computed as the first 4 bytes of the hash of the function signature,\n        // it's possible to have collisions. With the following check, we ensure it doesn't happen within\n        // the same contract.\n        if seen_selectors.contains_key(selector) {\n            let existing_fn = seen_selectors.get(selector).unwrap();\n            panic(\n                f\"Public function selector collision detected between functions '{fn_name}' and '{existing_fn}'\",\n            );\n        }\n        seen_selectors.insert(selector, fn_name);\n\n        let mut parameters_size = 0;\n        for param in parameters {\n            parameters_size += size_in_fields(param.1);\n        }\n\n        let initial_read = if parameters.len() == 0 {\n            quote {}\n        } else {\n            // The initial calldata_copy offset is 1 to skip the Field selector\n            // The expected calldata is the serialization of\n            // - FunctionSelector: the selector of the function intended to dispatch\n            // - Parameters: the parameters of the function intended to dispatch\n            // That is, exactly what is expected for a call to the target function,\n            // but with a selector added at the beginning.\n            quote {\n                let input_calldata: [Field; $parameters_size] = dep::aztec::context::public_context::calldata_copy(1, $parameters_size);\n                let mut reader = dep::aztec::protocol_types::utils::reader::Reader::new(input_calldata);\n            }\n        };\n\n        let parameter_index: &mut u32 = &mut 0;\n        let reads = parameters.map(|param: (Quoted, Type)| {\n            let parameter_index_value = *parameter_index;\n            let param_name = f\"arg{parameter_index_value}\".quoted_contents();\n            let param_type = param.1;\n            let read = quote {\n                let $param_name: $param_type = reader.read_struct(dep::aztec::protocol_types::traits::Deserialize::deserialize);\n            };\n            *parameter_index += 1;\n            quote { $read }\n        });\n        let read = reads.join(quote { });\n\n        let mut args = &[];\n        for parameter_index in 0..parameters.len() {\n            let param_name = f\"arg{parameter_index}\".quoted_contents();\n            args = args.push_back(quote { $param_name });\n        }\n\n        let args = args.join(quote { , });\n        // name of the function is assigned just before the call so debug metadata doesn't span most of this macro when figuring out where the call comes from.\n        let name = function.name();\n        let call = quote { $name($args) };\n\n        let return_code = if return_type == unit {\n            quote {\n                $call;\n                // Force early return.\n                dep::aztec::context::public_context::avm_return([]);\n            }\n        } else {\n            quote {\n                let return_value = dep::aztec::protocol_types::traits::Serialize::serialize($call);\n                dep::aztec::context::public_context::avm_return(return_value.as_slice());\n            }\n        };\n\n        let if_ = quote {\n            if selector == $selector {\n                $initial_read\n                $read\n                $return_code\n            }\n        };\n        if_\n    });\n\n    if ifs.len() == 0 {\n        // No dispatch function if there are no public functions\n        quote {}\n    } else {\n        let ifs = ifs.push_back(quote { panic(f\"Unknown selector {selector}\") });\n        let dispatch = ifs.join(quote {  });\n\n        let body = quote {\n            // We mark this as public because our whole system depends on public\n            // functions having this attribute. However, the public MACRO will\n            // handle the public_dispatch function specially and do nothing.\n            #[public]\n            pub unconstrained fn public_dispatch(selector: Field) {\n                $dispatch\n            }\n        };\n\n        body\n    }\n}\n\ncomptime fn get_type<T>() -> Type {\n    let t: T = std::mem::zeroed();\n    std::meta::type_of(t)\n}\n"
+    },
+    "108": {
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr",
+      "source": "use crate::macros::{\n    functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n    notes::NOTES,\n    utils::{\n        add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_contract_library_method,\n        is_fn_initializer, is_fn_internal, is_fn_private, is_fn_public, is_fn_test, is_fn_utility,\n        is_fn_view, modify_fn_body, module_has_initializer, module_has_storage,\n    },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n    // Private Kernel Circuit.\n    // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n    // about the execution context (e.g. the caller).\n    let original_params = f.parameters();\n    f.set_parameters(&[(\n        quote { inputs },\n        quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n    )]\n        .append(original_params));\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    // TODO: Optimize args_hasher for small number of arguments\n    let args_hasher_name = quote { args_hasher };\n    let args_hasher = original_params.fold(\n        quote {\n            let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n        },\n        |args_hasher, param: (Quoted, Type)| {\n            let (name, typ) = param;\n            let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n            quote {\n                $args_hasher\n                $appended_arg\n            }\n        },\n    );\n\n    let context_creation = quote {\n        let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    // All private functions perform message discovery, since they may need to access notes. This is slightly\n    // inefficient and could be improved by only doing it once we actually attempt to read any. Note that the message\n    // discovery call syncs private events as well. We do not sync those here if there are no notes because we don't\n    // have an API that would access events from private functions.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n    // circuit expects.\n    let return_value_var_name = quote { macro__returned__values };\n\n    let return_value_type = f.return_type();\n    let return_value = if body.len() == 0 {\n        quote {}\n    } else if return_value_type != type_of(()) {\n        // The original return value is passed to a second args hasher which the context receives.\n        let (body_without_return, last_body_expr) = body.pop_back();\n        let return_value = last_body_expr.quoted();\n        let return_value_assignment =\n            quote { let $return_value_var_name: $return_value_type = $return_value; };\n        let return_hasher_name = quote { return_hasher };\n        let return_value_into_hasher =\n            add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n        body = body_without_return;\n\n        quote {\n            let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n            $return_value_assignment\n            $return_value_into_hasher\n            context.set_return_hash($return_hasher_name);\n        }\n    } else {\n        let (body_without_return, last_body_expr) = body.pop_back();\n        if !last_body_expr.has_semicolon()\n            & last_body_expr.as_for().is_none()\n            & last_body_expr.as_assert().is_none()\n            & last_body_expr.as_for_range().is_none()\n            & last_body_expr.as_assert_eq().is_none()\n            & last_body_expr.as_let().is_none() {\n            let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n            body = body_without_return.push_back(\n                quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n            );\n        }\n        quote {}\n    };\n\n    let context_finish = quote { context.finish() };\n\n    let to_prepend = quote {\n        $args_hasher\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n        $message_discovery_call\n    };\n\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $context_finish\n    };\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n    f.set_return_type(\n        quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n            .as_type(),\n    );\n    f.set_return_data();\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Public functions undergo a lot of transformations from their Aztec.nr form.\n    let original_params = f.parameters();\n    let args_len = original_params\n        .map(|(name, typ): (Quoted, Type)| {\n            generate_serialize_to_fields(name, typ, false).0.len()\n        })\n        .fold(0, |acc: u32, val: u32| acc + val);\n\n    // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n    let context_creation = quote {\n        let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n        // We start from 1 because we skip the selector for the dispatch function.\n        let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n        dep::aztec::hash::hash_args_array(serialized_args)\n        });\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n        // referenced. We instead ignore 'unused variable' warnings for it.\n        quote {\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n    };\n\n    let to_append = quote {\n        $mark_as_initialized\n    };\n\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n\n    // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n    // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n    // bytecode.\n    f.set_unconstrained(true);\n    f.set_return_public(true);\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_utility(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // Check if function is marked as unconstrained\n    if !f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[utility] but not marked as unconstrained, add unconstrained keyword\",\n        );\n    }\n\n    // Create utility context\n    let context_creation =\n        quote { let mut context = dep::aztec::context::utility_context::UtilityContext::new(); };\n    let module_has_storage = module_has_storage(f.module());\n\n    // Initialize Storage if module has storage\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(context);\n        }\n    } else {\n        quote {}\n    };\n\n    // All utility functions perform message discovery, since they may need to access private notes that would be\n    // found during this process or they may be used to sync private events from TypeScript\n    // (`sync_private_state` function gets invoked by PXE::getPrivateEvents function).\n    let message_discovery_call = create_message_discovery_call();\n\n    // Inject context creation, storage initialization, and message discovery call at the beginning of the function\n    // body.\n    let to_prepend = quote {\n        $context_creation\n        $storage_init\n        $message_discovery_call\n    };\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, quote {});\n    f.set_body(modified_body);\n\n    f.set_return_public(true);\n\n    fn_abi\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called internally\";\n    quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called statically\";\n    if is_fn_private(f) {\n        // Here `context` is of type context::PrivateContext\n        quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n    } else {\n        // Here `context` is of type context::PublicContext\n        quote { assert(context.is_static_call(), $assertion_message); }\n    }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\n/// Injects a call to `aztec::messages::discovery::discover_new_messages`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_message_discovery_call() -> Quoted {\n    quote {\n        /// Safety: message discovery returns nothing and is performed solely for its side-effects. It is therefore\n        /// always safe to call.\n        unsafe {\n            dep::aztec::messages::discovery::discover_new_messages(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\n            );\n        };\n    }\n}\n\n/// Checks if each function in the module is marked with either #[private], #[public], #[utility],\n/// #[contract_library_method], or #[test]. Non-macroified functions are not allowed in contracts.\npub(crate) comptime fn check_each_fn_macroified(m: Module) {\n    for f in m.functions() {\n        let name = f.name();\n        if !is_fn_private(f)\n            & !is_fn_public(f)\n            & !is_fn_utility(f)\n            & !is_fn_contract_library_method(f)\n            & !is_fn_test(f) {\n            panic(\n                f\"Function {name} must be marked as either #[private], #[public], #[utility], #[contract_library_method], or #[test]\",\n            );\n        }\n    }\n}\n"
+    },
+    "113": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/mod.nr",
       "source": "use protocol_types::{address::AztecAddress, debug_log::{debug_log, debug_log_format}};\n\npub mod nonce_discovery;\npub mod partial_notes;\npub mod private_events;\npub mod private_notes;\npub mod process_message;\n\nuse crate::{\n    messages::{\n        discovery::{private_notes::MAX_NOTE_PACKED_LEN, process_message::do_process_message},\n        processing::{\n            get_private_logs, pending_tagged_log::PendingTaggedLog,\n            validate_enqueued_notes_and_events,\n        },\n    },\n    utils::array,\n};\n\npub struct NoteHashAndNullifier {\n    /// The result of NoteHash::compute_note_hash\n    pub note_hash: Field,\n    /// The result of NoteHash::compute_nullifier_unconstrained (since all of message discovery is unconstrained)\n    pub inner_nullifier: Field,\n}\n\n/// A function which takes a note's packed content, address of the emitting contract, note nonce, storage slot and note\n/// type ID and attempts to compute its note hash (not hashed by note nonce nor siloed by address) and inner nullifier\n/// (not siloed by address).\n///\n/// This function must be user-provided as its implementation requires knowledge of how note type IDs are allocated in a\n/// contract. The `#[aztec]` macro automatically creates such a contract library method called\n/// `_compute_note_hash_and_nullifier`, which looks something like this:\n///\n/// ```\n/// |packed_note, contract_address, note_nonce, storage_slot, note_type_id| {\n///     if note_type_id == MyNoteType::get_id() {\n///         assert(packed_note.len() == MY_NOTE_TYPE_SERIALIZATION_LENGTH);\n///\n///         let note = MyNoteType::unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n///\n///         let note_hash = note.compute_note_hash(storage_slot);\n///         let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n///             RetrievedNote{ note, contract_address, metadata: SettledNoteMetadata::new(note_nonce).into() },\n///             storage_slot\n///         );\n///\n///         let inner_nullifier = note.compute_nullifier_unconstrained(note_hash_for_nullify);\n///\n///         Option::some(\n///             aztec::messages::discovery::NoteHashAndNullifier {\n///                 note_hash, inner_nullifier\n///             }\n///         )\n///     } else if note_type_id == MyOtherNoteType::get_id() {\n///           ... // Similar to above but calling MyOtherNoteType::unpack_content\n///     } else {\n///         Option::none() // Unknown note type ID\n///     };\n/// }\n/// ```\ntype ComputeNoteHashAndNullifier<Env> = unconstrained fn[Env](/* packed_note */BoundedVec<Field, MAX_NOTE_PACKED_LEN>, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /* note nonce */ Field) -> Option<NoteHashAndNullifier>;\n\n/// Performs the message discovery process, in which private are downloaded and inspected to find new private notes,\n/// partial notes and events, etc., and pending partial notes are processed to search for their completion logs.\n/// This is the mechanism via which a contract updates its knowledge of its private state.\n///\n/// Receives the address of the contract on which discovery is performed along with its\n/// `compute_note_hash_and_nullifier` function.\npub unconstrained fn discover_new_messages<Env>(\n    contract_address: AztecAddress,\n    compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n    debug_log(\"Performing message discovery\");\n\n    // First we process all private logs, which can contain different kinds of messages e.g. private notes, partial\n    // notes, private events, etc.\n    let mut logs = get_private_logs(contract_address);\n    logs.for_each(|i, pending_tagged_log: PendingTaggedLog| {\n        debug_log_format(\n            \"Processing log with tag {0}\",\n            [pending_tagged_log.log.get(0)],\n        );\n\n        // We remove the tag from the pending tagged log and process the message ciphertext contained in it.\n        let message_ciphertext = array::subbvec(pending_tagged_log.log, 1);\n\n        do_process_message(\n            contract_address,\n            compute_note_hash_and_nullifier,\n            message_ciphertext,\n            pending_tagged_log.context,\n        );\n        logs.remove(i);\n    });\n\n    // Then we process all pending partial notes, regardless of whether they were found in the current or previous\n    // executions.\n    partial_notes::fetch_and_process_partial_note_completion_logs(\n        contract_address,\n        compute_note_hash_and_nullifier,\n    );\n\n    // Finally we validate all notes and events that were found as part of the previous processes, resulting in them\n    // being added to PXE's database and retrievable via oracles (get_notes) and our TS API (PXE::getPrivateEvents).\n    validate_enqueued_notes_and_events(contract_address);\n}\n"
     },
-    "103": {
+    "114": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/nonce_discovery.nr",
       "source": "use crate::messages::discovery::{ComputeNoteHashAndNullifier, private_notes::MAX_NOTE_PACKED_LEN};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    constants::MAX_NOTE_HASHES_PER_TX,\n    debug_log::debug_log_format,\n    hash::{compute_note_hash_nonce, compute_siloed_note_hash, compute_unique_note_hash},\n    traits::ToField,\n};\n\n/// A struct with the discovered information of a complete note, required for delivery to PXE. Note that this is *not*\n/// the complete note information, since it does not include content, storage slot, etc.\npub struct DiscoveredNoteInfo {\n    pub note_nonce: Field,\n    pub note_hash: Field,\n    pub inner_nullifier: Field,\n}\n\n/// Searches for note nonces that will result in a note that was emitted in a transaction. While rare, it is possible\n/// for multiple notes to have the exact same packed content and storage slot but different nonces, resulting in\n/// different unique note hashes. Because of this this function returns a *vector* of discovered notes, though in most\n/// cases it will contain a single element.\n///\n/// Due to how nonces are computed, this function requires knowledge of the transaction in which the note was created,\n/// more specifically the list of all unique note hashes in it plus the value of its first nullifier.\npub unconstrained fn attempt_note_nonce_discovery<Env>(\n    unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    first_nullifier_in_tx: Field,\n    compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n    contract_address: AztecAddress,\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n) -> BoundedVec<DiscoveredNoteInfo, MAX_NOTE_HASHES_PER_TX> {\n    let discovered_notes = &mut BoundedVec::new();\n\n    debug_log_format(\n        \"Attempting nonce discovery on {0} potential notes on contract {1} for storage slot {2}\",\n        [unique_note_hashes_in_tx.len() as Field, contract_address.to_field(), storage_slot],\n    );\n\n    // We need to find nonces (typically just one) that result in a note hash that, once siloed into a unique note hash,\n    // is one of the note hashes created by the transaction.\n    unique_note_hashes_in_tx.for_eachi(|i, expected_unique_note_hash| {\n        // Nonces are computed by hashing the first nullifier in the transaction with the index of the note in the\n        // new note hashes array. We therefore know for each note in every transaction what its nonce is.\n        let candidate_nonce = compute_note_hash_nonce(first_nullifier_in_tx, i);\n\n        // Given note nonce, note content and metadata, we can compute the note hash and silo it to check if it matches\n        // the note hash at the array index we're currently processing.\n        // TODO(#11157): handle failed note_hash_and_nullifier computation\n        let hashes = compute_note_hash_and_nullifier(\n            packed_note,\n            storage_slot,\n            note_type_id,\n            contract_address,\n            candidate_nonce,\n        )\n            .expect(f\"Failed to compute a note hash for note type {note_type_id}\");\n\n        let siloed_note_hash = compute_siloed_note_hash(contract_address, hashes.note_hash);\n        let unique_note_hash = compute_unique_note_hash(candidate_nonce, siloed_note_hash);\n\n        if unique_note_hash == expected_unique_note_hash {\n            // Note that while we did check that the note hash is the preimage of the expected unique note hash, we\n            // perform no validations on the nullifier - we fundamentally cannot, since only the application knows\n            // how to compute nullifiers. We simply trust it to have provided the correct one: if it hasn't, then\n            // PXE may fail to realize that a given note has been nullified already, and calls to the application\n            // could result in invalid transactions (with duplicate nullifiers). This is not a concern because an\n            // application already has more direct means of making a call to it fail the transaction.\n            discovered_notes.push(\n                DiscoveredNoteInfo {\n                    note_nonce: candidate_nonce,\n                    note_hash: hashes.note_hash,\n                    inner_nullifier: hashes.inner_nullifier,\n                },\n            );\n\n            // We don't exit the loop - it is possible (though rare) for the exact same note content to be present\n            // multiple times in the same transaction with different nonces. This typically doesn't happen due to\n            // notes containing random values in order to hide their contents.\n        }\n    });\n\n    debug_log_format(\n        \"Found valid nonces for a total of {0} notes\",\n        [discovered_notes.len() as Field],\n    );\n\n    *discovered_notes\n}\n\nmod test {\n    use crate::{\n        messages::discovery::{NoteHashAndNullifier, private_notes::MAX_NOTE_PACKED_LEN},\n        note::{\n            note_interface::{NoteHash, NoteType},\n            note_metadata::SettledNoteMetadata,\n            retrieved_note::RetrievedNote,\n            utils::compute_note_hash_for_nullify,\n        },\n        oracle::random::random,\n        test::mocks::mock_note::MockNote,\n        utils::array,\n    };\n\n    use dep::protocol_types::{\n        address::AztecAddress,\n        hash::{compute_note_hash_nonce, compute_siloed_note_hash, compute_unique_note_hash},\n        traits::{FromField, Packable},\n    };\n\n    use super::attempt_note_nonce_discovery;\n\n    // This implementation could be simpler, but this serves as a nice example of the expected flow in a real\n    // implementation, and as a sanity check that the interface is sufficient.\n    unconstrained fn compute_note_hash_and_nullifier(\n        packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n        storage_slot: Field,\n        note_type_id: Field,\n        contract_address: AztecAddress,\n        note_nonce: Field,\n    ) -> Option<NoteHashAndNullifier> {\n        if note_type_id == MockNote::get_id() {\n            let note = MockNote::unpack(array::subarray(packed_note.storage(), 0));\n            let note_hash = note.compute_note_hash(storage_slot);\n\n            let note_hash_for_nullify = compute_note_hash_for_nullify(\n                RetrievedNote {\n                    note,\n                    contract_address,\n                    metadata: SettledNoteMetadata::new(note_nonce).into(),\n                },\n                storage_slot,\n            );\n\n            let inner_nullifier = note.compute_nullifier_unconstrained(note_hash_for_nullify);\n\n            Option::some(NoteHashAndNullifier { note_hash, inner_nullifier })\n        } else {\n            Option::none()\n        }\n    }\n\n    global VALUE: Field = 7;\n    global FIRST_NULLIFIER_IN_TX: Field = 47;\n    global CONTRACT_ADDRESS: AztecAddress = AztecAddress::from_field(13);\n    global STORAGE_SLOT: Field = 99;\n\n    #[test]\n    unconstrained fn no_note_hashes() {\n        let unique_note_hashes_in_tx = BoundedVec::new();\n        let packed_note = BoundedVec::new();\n\n        let discovered_notes = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            compute_note_hash_and_nullifier,\n            CONTRACT_ADDRESS,\n            STORAGE_SLOT,\n            MockNote::get_id(),\n            packed_note,\n        );\n\n        assert_eq(discovered_notes.len(), 0);\n    }\n\n    #[test(should_fail_with = \"Failed to compute a note hash\")]\n    unconstrained fn failed_hash_computation() {\n        let unique_note_hashes_in_tx = BoundedVec::from_array([random()]);\n        let packed_note = BoundedVec::new();\n        let note_type_id = 0; // This note type id is unknown to compute_note_hash_and_nullifier\n\n        let discovered_notes = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            compute_note_hash_and_nullifier,\n            CONTRACT_ADDRESS,\n            STORAGE_SLOT,\n            note_type_id,\n            packed_note,\n        );\n\n        assert_eq(discovered_notes.len(), 0);\n    }\n\n    struct NoteAndData {\n        note: MockNote,\n        note_nonce: Field,\n        note_hash: Field,\n        unique_note_hash: Field,\n        inner_nullifier: Field,\n    }\n\n    unconstrained fn construct_note(value: Field, note_index_in_tx: u32) -> NoteAndData {\n        let note_nonce = compute_note_hash_nonce(FIRST_NULLIFIER_IN_TX, note_index_in_tx);\n\n        let retrieved_note = MockNote::new(value)\n            .contract_address(CONTRACT_ADDRESS)\n            .note_metadata(SettledNoteMetadata::new(note_nonce).into())\n            .build_retrieved_note();\n        let note = retrieved_note.note;\n\n        let note_hash = note.compute_note_hash(STORAGE_SLOT);\n        let unique_note_hash = compute_unique_note_hash(\n            note_nonce,\n            compute_siloed_note_hash(CONTRACT_ADDRESS, note_hash),\n        );\n        let inner_nullifier = note.compute_nullifier_unconstrained(compute_note_hash_for_nullify(\n            retrieved_note,\n            STORAGE_SLOT,\n        ));\n\n        NoteAndData { note, note_nonce, note_hash, unique_note_hash, inner_nullifier }\n    }\n\n    #[test]\n    unconstrained fn single_note() {\n        let note_index_in_tx = 2;\n        let note_and_data = construct_note(VALUE, note_index_in_tx);\n\n        let mut unique_note_hashes_in_tx = BoundedVec::from_array([\n            random(), random(), random(), random(), random(), random(), random(),\n        ]);\n        unique_note_hashes_in_tx.set(note_index_in_tx, note_and_data.unique_note_hash);\n\n        let discovered_notes = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            compute_note_hash_and_nullifier,\n            CONTRACT_ADDRESS,\n            STORAGE_SLOT,\n            MockNote::get_id(),\n            BoundedVec::from_array(note_and_data.note.pack()),\n        );\n\n        assert_eq(discovered_notes.len(), 1);\n        let discovered_note = discovered_notes.get(0);\n\n        assert_eq(discovered_note.note_nonce, note_and_data.note_nonce);\n        assert_eq(discovered_note.note_hash, note_and_data.note_hash);\n        assert_eq(discovered_note.inner_nullifier, note_and_data.inner_nullifier);\n    }\n\n    #[test]\n    unconstrained fn multiple_notes_same_preimage() {\n        let first_note_index_in_tx = 3;\n        let first_note_and_data = construct_note(VALUE, first_note_index_in_tx);\n\n        let second_note_index_in_tx = 5;\n        let second_note_and_data = construct_note(VALUE, second_note_index_in_tx);\n\n        // Both notes have the same preimage (and therefore packed representation), so both should be found in the same\n        // call.\n        assert_eq(first_note_and_data.note, second_note_and_data.note);\n        let packed_note = first_note_and_data.note.pack();\n\n        let mut unique_note_hashes_in_tx = BoundedVec::from_array([\n            random(), random(), random(), random(), random(), random(), random(),\n        ]);\n        unique_note_hashes_in_tx.set(first_note_index_in_tx, first_note_and_data.unique_note_hash);\n        unique_note_hashes_in_tx.set(second_note_index_in_tx, second_note_and_data.unique_note_hash);\n\n        let discovered_notes = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            compute_note_hash_and_nullifier,\n            CONTRACT_ADDRESS,\n            STORAGE_SLOT,\n            MockNote::get_id(),\n            BoundedVec::from_array(packed_note),\n        );\n\n        assert_eq(discovered_notes.len(), 2);\n\n        assert(discovered_notes.any(|discovered_note| {\n            (discovered_note.note_nonce == first_note_and_data.note_nonce)\n                & (discovered_note.note_hash == first_note_and_data.note_hash)\n                & (discovered_note.inner_nullifier == first_note_and_data.inner_nullifier)\n        }));\n\n        assert(discovered_notes.any(|discovered_note| {\n            (discovered_note.note_nonce == second_note_and_data.note_nonce)\n                & (discovered_note.note_hash == second_note_and_data.note_hash)\n                & (discovered_note.inner_nullifier == second_note_and_data.inner_nullifier)\n        }));\n    }\n}\n"
     },
-    "104": {
+    "115": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/partial_notes.nr",
       "source": "use crate::{\n    capsules::CapsuleArray,\n    messages::{\n        discovery::{ComputeNoteHashAndNullifier, nonce_discovery::attempt_note_nonce_discovery},\n        encoding::MAX_MESSAGE_CONTENT_LEN,\n        processing::{\n            enqueue_note_for_validation, get_pending_partial_notes_completion_logs,\n            log_retrieval_response::LogRetrievalResponse,\n        },\n    },\n    utils::array,\n};\n\nuse protocol_types::{\n    address::AztecAddress,\n    debug_log::debug_log_format,\n    hash::sha256_to_field,\n    traits::{Deserialize, Serialize},\n};\n\nglobal PARTIAL_NOTE_PRIVATE_MSG_CONTENT_NON_NOTE_FIELDS_LEN: u32 = 2;\n\n/// Partial notes have a maximum packed length of their private fields bound by extra content in their private message\n/// (e.g. the storage slot, note completion log tag, etc.).\npub global MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN: u32 =\n    MAX_MESSAGE_CONTENT_LEN - PARTIAL_NOTE_PRIVATE_MSG_CONTENT_NON_NOTE_FIELDS_LEN;\n\n/// The slot in the PXE capsules where we store a `CapsuleArray` of `DeliveredPendingPartialNote`.\npub global DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT\".as_bytes(),\n);\n\n/// A partial note that was delivered but is still pending completion. Contains the information necessary to find the\n/// log that will complete it and lead to a note being discovered and delivered.\n#[derive(Serialize, Deserialize)]\npub(crate) struct DeliveredPendingPartialNote {\n    pub(crate) note_completion_log_tag: Field,\n    pub(crate) storage_slot: Field,\n    pub(crate) note_type_id: Field,\n    pub(crate) packed_private_note_content: BoundedVec<Field, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN>,\n    pub(crate) recipient: AztecAddress,\n}\n\npub unconstrained fn process_partial_note_private_msg(\n    contract_address: AztecAddress,\n    recipient: AztecAddress,\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) {\n    let (note_type_id, storage_slot, note_completion_log_tag, packed_private_note_content) =\n        decode_partial_note_private_msg(msg_metadata, msg_content);\n\n    // We store the information of the partial note we found in a persistent capsule in PXE, so that we can later search\n    // for the public log that will complete it.\n    let pending = DeliveredPendingPartialNote {\n        note_completion_log_tag,\n        storage_slot,\n        note_type_id,\n        packed_private_note_content,\n        recipient,\n    };\n\n    CapsuleArray::at(\n        contract_address,\n        DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n    )\n        .push(pending);\n}\n\n/// Searches for logs that would result in the completion of pending partial notes, ultimately resulting in the notes\n/// being delivered to PXE if completed.\npub unconstrained fn fetch_and_process_partial_note_completion_logs<Env>(\n    contract_address: AztecAddress,\n    compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n    let pending_partial_notes = CapsuleArray::at(\n        contract_address,\n        DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n    );\n\n    debug_log_format(\n        \"{} pending partial notes\",\n        [pending_partial_notes.len() as Field],\n    );\n\n    // Each of the pending partial notes might get completed by a log containing its public values. For performance\n    // reasons, we fetch all of these logs concurrently and then process them one by one, minimizing the amount of time\n    // waiting for the node roundtrip.\n    let maybe_completion_logs =\n        get_pending_partial_notes_completion_logs(contract_address, pending_partial_notes);\n\n    // Each entry in the maybe completion logs array corresponds to the entry in the pending partial notes array at the\n    // same index. This means we can use the same index as we iterate through the responses to get both the partial note\n    // and the log that might complete it.\n    assert_eq(maybe_completion_logs.len(), pending_partial_notes.len());\n\n    maybe_completion_logs.for_each(|i, maybe_log: Option<LogRetrievalResponse>| {\n        // We clear the completion logs as we read them so that the array is empty by the time we next query it.\n        // TODO(#14943): use volatile arrays to avoid having to manually clear this.\n        maybe_completion_logs.remove(i);\n\n        let pending_partial_note = pending_partial_notes.get(i);\n\n        if maybe_log.is_none() {\n            debug_log_format(\n                \"Found no completion logs for partial note with tag {}\",\n                [pending_partial_note.note_completion_log_tag],\n            );\n\n            // Note that we're not removing the pending partial note from the capsule array, so we will continue\n            // searching for this tagged log when performing message discovery in the future until we either find it or\n            // the entry is somehow removed from the array.\n        } else {\n            debug_log_format(\n                \"Completion log found for partial note with tag {}\",\n                [pending_partial_note.note_completion_log_tag],\n            );\n            let log = maybe_log.unwrap();\n\n            // Public fields are assumed to all be placed at the end of the packed representation, so we combine the\n            // private and public packed fields (i.e. the contents of the private message and public log plaintext to get\n            // the complete packed content.\n            let complete_packed_note = array::append(\n                pending_partial_note.packed_private_note_content,\n                log.log_payload,\n            );\n\n            let discovered_notes = attempt_note_nonce_discovery(\n                log.unique_note_hashes_in_tx,\n                log.first_nullifier_in_tx,\n                compute_note_hash_and_nullifier,\n                contract_address,\n                pending_partial_note.storage_slot,\n                pending_partial_note.note_type_id,\n                complete_packed_note,\n            );\n\n            // TODO(#11627): is there anything reasonable we can do if we get a log but it doesn't result in a note\n            // being found?\n            if discovered_notes.len() == 0 {\n                panic(\n                    f\"A partial note's completion log did not result in any notes being found - this should never happen\",\n                );\n            }\n\n            debug_log_format(\n                \"Discovered {0} notes for partial note with tag {1}\",\n                [discovered_notes.len() as Field, pending_partial_note.note_completion_log_tag],\n            );\n\n            discovered_notes.for_each(|discovered_note| {\n                enqueue_note_for_validation(\n                    contract_address,\n                    pending_partial_note.storage_slot,\n                    discovered_note.note_nonce,\n                    complete_packed_note,\n                    discovered_note.note_hash,\n                    discovered_note.inner_nullifier,\n                    log.tx_hash,\n                    pending_partial_note.recipient,\n                );\n            });\n\n            // Because there is only a single log for a given tag, once we've processed the tagged log then we\n            // simply delete the pending work entry, regardless of whether it was actually completed or not.\n            pending_partial_notes.remove(i);\n        }\n    });\n}\n\nfn decode_partial_note_private_msg(\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) -> (Field, Field, Field, BoundedVec<Field, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN>) {\n    let note_type_id = msg_metadata as Field; // TODO: make note type id not be a full field\n\n    assert(\n        msg_content.len() > PARTIAL_NOTE_PRIVATE_MSG_CONTENT_NON_NOTE_FIELDS_LEN,\n        f\"Invalid private note message: all partial note private messages must have at least {PARTIAL_NOTE_PRIVATE_MSG_CONTENT_NON_NOTE_FIELDS_LEN} fields\",\n    );\n\n    // If PARTIAL_NOTE_PRIVATE_MSG_CONTENT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail, then the\n    // destructuring of the partial note private message encoding below must be updated as well.\n    std::static_assert(\n        PARTIAL_NOTE_PRIVATE_MSG_CONTENT_NON_NOTE_FIELDS_LEN == 2,\n        \"unexpected value for PARTIAL_NOTE_PRIVATE_MSG_CONTENT_NON_NOTE_FIELDS_LEN\",\n    );\n\n    // We currently have two fields that are not the partial note's packed representation, which are the storage slot\n    // and the note completion log tag.\n    let storage_slot = msg_content.get(0);\n    let note_completion_log_tag = msg_content.get(1);\n\n    let packed_private_note_content = array::subbvec(msg_content, 2);\n\n    (note_type_id, storage_slot, note_completion_log_tag, packed_private_note_content)\n}\n"
     },
-    "105": {
+    "116": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/private_events.nr",
-      "source": "use crate::{\n    messages::{encoding::MAX_MESSAGE_CONTENT_LEN, processing::enqueue_event_for_validation},\n    prelude::AztecAddress,\n    utils::array,\n};\nuse protocol_types::{\n    abis::event_selector::EventSelector, constants::GENERATOR_INDEX__EVENT_COMMITMENT,\n    hash::poseidon2_hash_with_separator_bounded_vec, traits::FromField,\n};\n\n/// The number of fields in a private event message content that are not the event's serialized representation\n/// (1 field for randomness).\nglobal PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN: u32 = 1;\n\n/// The maximum length of the packed representation of an event's contents. This is limited by private log size,\n/// encryption overhead and extra fields in the message (e.g. message type id, randomness, etc.).\npub global MAX_EVENT_SERIALIZED_LEN: u32 =\n    MAX_MESSAGE_CONTENT_LEN - PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN;\n\npub unconstrained fn process_private_event_msg(\n    contract_address: AztecAddress,\n    recipient: AztecAddress,\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n    tx_hash: Field,\n) {\n    // In the case of events, the msg metadata is the event selector.\n    let event_type_id = EventSelector::from_field(msg_metadata as Field);\n\n    assert(\n        msg_content.len() > PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN,\n        f\"Invalid private event message: all private event messages must have at least {PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN} fields\",\n    );\n\n    // If PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN is changed, causing the assertion below to fail, then the\n    // destructuring of the private event message encoding below must be updated as well.\n    std::static_assert(\n        PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN == 1,\n        \"unexpected value for PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN\",\n    );\n\n    let serialized_event_with_randomness = msg_content;\n\n    let event_commitment = poseidon2_hash_with_separator_bounded_vec(\n        serialized_event_with_randomness,\n        GENERATOR_INDEX__EVENT_COMMITMENT,\n    );\n\n    // Randomness was injected into the event payload in `emit_event_in_private_log` but we have already used it\n    // to compute the event commitment, so we can safely discard it now.\n    let serialized_event = array::subbvec(\n        serialized_event_with_randomness,\n        PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN,\n    );\n\n    enqueue_event_for_validation(\n        contract_address,\n        event_type_id,\n        serialized_event,\n        event_commitment,\n        tx_hash,\n        recipient,\n    );\n}\n"
+      "source": "use crate::{\n    event::event_selector::EventSelector,\n    messages::{encoding::MAX_MESSAGE_CONTENT_LEN, processing::enqueue_event_for_validation},\n    prelude::AztecAddress,\n    utils::array,\n};\nuse protocol_types::{\n    constants::GENERATOR_INDEX__EVENT_COMMITMENT, hash::poseidon2_hash_with_separator_bounded_vec,\n    traits::FromField,\n};\n\n/// The number of fields in a private event message content that are not the event's serialized representation\n/// (1 field for randomness).\nglobal PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN: u32 = 1;\n\n/// The maximum length of the packed representation of an event's contents. This is limited by private log size,\n/// encryption overhead and extra fields in the message (e.g. message type id, randomness, etc.).\npub global MAX_EVENT_SERIALIZED_LEN: u32 =\n    MAX_MESSAGE_CONTENT_LEN - PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN;\n\npub unconstrained fn process_private_event_msg(\n    contract_address: AztecAddress,\n    recipient: AztecAddress,\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n    tx_hash: Field,\n) {\n    // In the case of events, the msg metadata is the event selector.\n    let event_type_id = EventSelector::from_field(msg_metadata as Field);\n\n    assert(\n        msg_content.len() > PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN,\n        f\"Invalid private event message: all private event messages must have at least {PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN} fields\",\n    );\n\n    // If PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN is changed, causing the assertion below to fail, then the\n    // destructuring of the private event message encoding below must be updated as well.\n    std::static_assert(\n        PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN == 1,\n        \"unexpected value for PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN\",\n    );\n\n    let serialized_event_with_randomness = msg_content;\n\n    let event_commitment = poseidon2_hash_with_separator_bounded_vec(\n        serialized_event_with_randomness,\n        GENERATOR_INDEX__EVENT_COMMITMENT,\n    );\n\n    // Randomness was injected into the event payload in `emit_event_in_private_log` but we have already used it\n    // to compute the event commitment, so we can safely discard it now.\n    let serialized_event = array::subbvec(\n        serialized_event_with_randomness,\n        PRIVATE_EVENT_MSG_CONTENT_NON_EVENT_FIELDS_LEN,\n    );\n\n    enqueue_event_for_validation(\n        contract_address,\n        event_type_id,\n        serialized_event,\n        event_commitment,\n        tx_hash,\n        recipient,\n    );\n}\n"
     },
-    "106": {
+    "117": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/private_notes.nr",
       "source": "use crate::{\n    messages::{\n        discovery::{ComputeNoteHashAndNullifier, nonce_discovery::attempt_note_nonce_discovery},\n        encoding::MAX_MESSAGE_CONTENT_LEN,\n        processing::enqueue_note_for_validation,\n    },\n    utils::array,\n};\nuse protocol_types::{\n    address::AztecAddress, constants::MAX_NOTE_HASHES_PER_TX, debug_log::debug_log_format,\n};\n\n/// The number of fields in a private note message content that are not the note's packed representation.\n// See the call to `std::static_assert` below to see what's in these fields.\nglobal PRIVATE_NOTE_MSG_CONTENT_NON_NOTE_FIELDS_LEN: u32 = 1;\n\n/// The maximum length of the packed representation of a note's contents. This is limited by private log size,\n/// encryption overhead and extra fields in the message (e.g. message type id, storage slot, etc.).\npub global MAX_NOTE_PACKED_LEN: u32 =\n    MAX_MESSAGE_CONTENT_LEN - PRIVATE_NOTE_MSG_CONTENT_NON_NOTE_FIELDS_LEN;\n\npub unconstrained fn process_private_note_msg<Env>(\n    contract_address: AztecAddress,\n    tx_hash: Field,\n    unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    first_nullifier_in_tx: Field,\n    recipient: AztecAddress,\n    compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) {\n    let (note_type_id, storage_slot, packed_note) =\n        decode_private_note_msg(msg_metadata, msg_content);\n\n    attempt_note_discovery(\n        contract_address,\n        tx_hash,\n        unique_note_hashes_in_tx,\n        first_nullifier_in_tx,\n        recipient,\n        compute_note_hash_and_nullifier,\n        storage_slot,\n        note_type_id,\n        packed_note,\n    );\n}\n\n/// Attempts discovery of a note given information about its contents and the transaction in which it is\n/// suspected the note was created.\npub unconstrained fn attempt_note_discovery<Env>(\n    contract_address: AztecAddress,\n    tx_hash: Field,\n    unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    first_nullifier_in_tx: Field,\n    recipient: AztecAddress,\n    compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n) {\n    let discovered_notes = attempt_note_nonce_discovery(\n        unique_note_hashes_in_tx,\n        first_nullifier_in_tx,\n        compute_note_hash_and_nullifier,\n        contract_address,\n        storage_slot,\n        note_type_id,\n        packed_note,\n    );\n\n    debug_log_format(\n        \"Discovered {0} notes from a private message\",\n        [discovered_notes.len() as Field],\n    );\n\n    discovered_notes.for_each(|discovered_note| {\n        enqueue_note_for_validation(\n            contract_address,\n            storage_slot,\n            discovered_note.note_nonce,\n            packed_note,\n            discovered_note.note_hash,\n            discovered_note.inner_nullifier,\n            tx_hash,\n            recipient,\n        );\n    });\n}\n\nfn decode_private_note_msg(\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) -> (Field, Field, BoundedVec<Field, MAX_NOTE_PACKED_LEN>) {\n    let note_type_id = msg_metadata as Field; // TODO: make note type id not be a full field\n\n    assert(\n        msg_content.len() > PRIVATE_NOTE_MSG_CONTENT_NON_NOTE_FIELDS_LEN,\n        f\"Invalid private note message: all private note messages must have at least {PRIVATE_NOTE_MSG_CONTENT_NON_NOTE_FIELDS_LEN} fields\",\n    );\n\n    // If PRIVATE_NOTE_MSG_CONTENT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail, then the\n    // destructuring of the private note message encoding below must be updated as well.\n    std::static_assert(\n        PRIVATE_NOTE_MSG_CONTENT_NON_NOTE_FIELDS_LEN == 1,\n        \"unexpected value for PRIVATE_NOTE_MSG_CONTENT_NON_NOTE_FIELDS_LEN\",\n    );\n\n    // We currently have a single field that is not the note's packed representation, which is the storage slot.\n    let storage_slot = msg_content.get(0);\n    let packed_note = array::subbvec(msg_content, PRIVATE_NOTE_MSG_CONTENT_NON_NOTE_FIELDS_LEN);\n\n    (note_type_id, storage_slot, packed_note)\n}\n"
     },
-    "107": {
+    "118": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/process_message.nr",
       "source": "use crate::messages::{\n    discovery::{\n        ComputeNoteHashAndNullifier, partial_notes::process_partial_note_private_msg,\n        private_events::process_private_event_msg, private_notes::process_private_note_msg,\n    },\n    encoding::decode_message,\n    encryption::{aes128::AES128, log_encryption::LogEncryption},\n    msg_type::{\n        PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID, PRIVATE_EVENT_MSG_TYPE_ID, PRIVATE_NOTE_MSG_TYPE_ID,\n    },\n    processing::message_context::MessageContext,\n};\n\nuse protocol_types::{\n    address::AztecAddress,\n    constants::PRIVATE_LOG_CIPHERTEXT_LEN,\n    debug_log::{debug_log, debug_log_format},\n};\n\n/// Processes a message that can contain notes, partial notes, or events.\n///\n/// Notes result in nonce discovery being performed prior to delivery, which requires knowledge of the transaction hash\n/// in which the notes would've been created (typically the same transaction in which the log was emitted), along with\n/// the list of unique note hashes in said transaction and the `compute_note_hash_and_nullifier` function. Once\n/// discovered, the notes are enqueued for validation.\n///\n/// Partial notes result in a pending partial note entry being stored in a PXE capsule, which will later be retrieved to\n/// search for the note's completion public log.\n///\n/// Events are processed by computing an event commitment from the serialized event data and its randomness field, then\n/// enqueueing the event data and commitment for validation.\npub unconstrained fn do_process_message<Env>(\n    contract_address: AztecAddress,\n    compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n    message_ciphertext: BoundedVec<Field, PRIVATE_LOG_CIPHERTEXT_LEN>,\n    message_context: MessageContext,\n) {\n    let message = AES128::decrypt_log(message_ciphertext, message_context.recipient);\n\n    // The first thing to do after decrypting the message is to determine what type of message we're processing. We\n    // have 3 message types: private notes, partial notes and events.\n\n    // We decode the message to obtain the message type id, metadata and content.\n    let (msg_type_id, msg_metadata, msg_content) = decode_message(message);\n\n    if msg_type_id == PRIVATE_NOTE_MSG_TYPE_ID {\n        debug_log(\"Processing private note msg\");\n\n        process_private_note_msg(\n            contract_address,\n            message_context.tx_hash,\n            message_context.unique_note_hashes_in_tx,\n            message_context.first_nullifier_in_tx,\n            message_context.recipient,\n            compute_note_hash_and_nullifier,\n            msg_metadata,\n            msg_content,\n        );\n    } else if msg_type_id == PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID {\n        debug_log(\"Processing partial note private msg\");\n\n        process_partial_note_private_msg(\n            contract_address,\n            message_context.recipient,\n            msg_metadata,\n            msg_content,\n        );\n    } else if msg_type_id == PRIVATE_EVENT_MSG_TYPE_ID {\n        debug_log(\"Processing private event msg\");\n\n        process_private_event_msg(\n            contract_address,\n            message_context.recipient,\n            msg_metadata,\n            msg_content,\n            message_context.tx_hash,\n        );\n    } else {\n        debug_log_format(\"Unknown msg type id {0}\", [msg_type_id as Field]);\n    }\n}\n"
     },
-    "108": {
+    "119": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/encoding.nr",
       "source": "// TODO(#12750): don't make these values assume we're using AES.\nuse crate::{\n    messages::encryption::log_encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS, utils::array,\n};\n\npub global MAX_MESSAGE_LEN: u32 = PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\n\nglobal MESSAGE_EXPANDED_METADATA_LEN: u32 = 1;\n\n// The standard message layout is composed of:\n//  - an initial field called the 'expanded metadata'\n//  - an arbitrary number of fields following that called the 'message content'\n//\n// ```\n// message: [ msg_expanded_metadata, ...msg_content ]\n// ```\n//\n// The expanded metadata itself is interpreted as a u128, of which:\n//  - the upper 64 bits are the message type id\n//  - the lower 64 bits are called the 'message metadata'\n//\n// ```\n// msg_expanded_metadata: [  msg_type_id    |  msg_metadata  ]\n//                        <---  64 bits --->|<--- 64 bits --->\n// ```\n//\n// The meaning of the message metadata and message content depend on the value of the message type id. Note that there\n// is nothing special about the message metadata, it _can_ be considered part of the content. It just has a different\n// name to make it distinct from the message content given that it is not a full field.\n\n/// The maximum length of a message's content, i.e. not including the expanded message metadata.\npub global MAX_MESSAGE_CONTENT_LEN: u32 = MAX_MESSAGE_LEN - MESSAGE_EXPANDED_METADATA_LEN;\n\n/// Encodes a message following aztec-nr's standard message encoding. This message can later be decoded with\n/// `decode_message` to retrieve the original values.\n///\n/// - The `msg_type` is an identifier that groups types of messages that are all processed the same way, e.g. private\n/// notes or events. Possible values are defined in `aztec::messages::msg_type`.\n/// - The `msg_metadata` and `msg_content` are the values stored in the message, whose meaning depends on the\n///  `msg_type`. The only special thing about `msg_metadata` that separates it from `msg_content` is that it is a u64\n/// instead of a full Field (due to details of how messages are encoded), allowing applications that can fit values into\n/// this smaller variable to achieve higher data efficiency.\npub fn encode_message<let N: u32>(\n    msg_type: u64,\n    msg_metadata: u64,\n    msg_content: [Field; N],\n) -> [Field; (N + MESSAGE_EXPANDED_METADATA_LEN)] {\n    std::static_assert(\n        msg_content.len() <= MAX_MESSAGE_CONTENT_LEN,\n        \"Invalid message content: it must have a length of at most MAX_MESSAGE_CONTENT_LEN\",\n    );\n\n    // If MESSAGE_EXPANDED_METADATA_LEN is changed, causing the assertion below to fail, then the destructuring of\n    // the message encoding below must be updated as well.\n    std::static_assert(\n        MESSAGE_EXPANDED_METADATA_LEN == 1,\n        \"unexpected value for MESSAGE_EXPANDED_METADATA_LEN\",\n    );\n    let mut message: [Field; (N + MESSAGE_EXPANDED_METADATA_LEN)] = std::mem::zeroed();\n\n    message[0] = to_expanded_metadata(msg_type, msg_metadata);\n    for i in 0..msg_content.len() {\n        message[MESSAGE_EXPANDED_METADATA_LEN + i] = msg_content[i];\n    }\n\n    message\n}\n\n/// Decodes a standard aztec-nr message, i.e. one created via `encode_message`, returning the original encoded values.\n///\n/// Note that `encode_message` returns a fixed size array while this function takes a `BoundedVec`: this is because\n/// prior to decoding the message type is unknown, and consequentially not known at compile time. If working with\n/// fixed-size messages, consider using `BoundedVec::from_array` to convert them.\npub unconstrained fn decode_message(\n    message: BoundedVec<Field, MAX_MESSAGE_LEN>,\n) -> (u64, u64, BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>) {\n    assert(\n        message.len() >= MESSAGE_EXPANDED_METADATA_LEN,\n        f\"Invalid message: it must have at least {MESSAGE_EXPANDED_METADATA_LEN} fields\",\n    );\n\n    // If MESSAGE_EXPANDED_METADATA_LEN is changed, causing the assertion below to fail, then the destructuring of\n    // the message encoding below must be updated as well.\n    std::static_assert(\n        MESSAGE_EXPANDED_METADATA_LEN == 1,\n        \"unexpected value for MESSAGE_EXPANDED_METADATA_LEN\",\n    );\n\n    let msg_expanded_metadata = message.get(0);\n    let (msg_type_id, msg_metadata) = from_expanded_metadata(msg_expanded_metadata);\n    let msg_content = array::subbvec(message, MESSAGE_EXPANDED_METADATA_LEN);\n\n    (msg_type_id, msg_metadata, msg_content)\n}\n\nglobal U64_SHIFT_MULTIPLIER: Field = 2.pow_32(64);\n\nfn to_expanded_metadata(msg_type: u64, msg_metadata: u64) -> Field {\n    // We use multiplication instead of bit shifting operations to shift the type bits as bit shift operations are\n    // expensive in circuits.\n    let type_field: Field = (msg_type as Field) * U64_SHIFT_MULTIPLIER;\n    let msg_metadata_field = msg_metadata as Field;\n\n    type_field + msg_metadata_field\n}\n\nfn from_expanded_metadata(input: Field) -> (u64, u64) {\n    input.assert_max_bit_size::<128>();\n    let msg_metadata = (input as u64);\n    let msg_type = ((input - (msg_metadata as Field)) / U64_SHIFT_MULTIPLIER) as u64;\n    // Use division instead of bit shift since bit shifts are expensive in circuits\n    (msg_type, msg_metadata)\n}\n\nmod tests {\n    use crate::utils::array::subarray::subarray;\n    use super::{\n        decode_message, encode_message, from_expanded_metadata, MAX_MESSAGE_CONTENT_LEN,\n        to_expanded_metadata,\n    };\n\n    global U64_MAX: u64 = (2.pow_32(64) - 1) as u64;\n    global U128_MAX: Field = (2.pow_32(128) - 1);\n\n    #[test]\n    unconstrained fn encode_decode_empty_message(msg_type: u64, msg_metadata: u64) {\n        let encoded = encode_message(msg_type, msg_metadata, []);\n        let (decoded_msg_type, decoded_msg_metadata, decoded_msg_content) =\n            decode_message(BoundedVec::from_array(encoded));\n\n        assert_eq(decoded_msg_type, msg_type);\n        assert_eq(decoded_msg_metadata, msg_metadata);\n        assert_eq(decoded_msg_content.len(), 0);\n    }\n\n    #[test]\n    unconstrained fn encode_decode_short_message(\n        msg_type: u64,\n        msg_metadata: u64,\n        msg_content: [Field; MAX_MESSAGE_CONTENT_LEN / 2],\n    ) {\n        let encoded = encode_message(msg_type, msg_metadata, msg_content);\n        let (decoded_msg_type, decoded_msg_metadata, decoded_msg_content) =\n            decode_message(BoundedVec::from_array(encoded));\n\n        assert_eq(decoded_msg_type, msg_type);\n        assert_eq(decoded_msg_metadata, msg_metadata);\n        assert_eq(decoded_msg_content.len(), msg_content.len());\n        assert_eq(subarray(decoded_msg_content.storage(), 0), msg_content);\n    }\n\n    #[test]\n    unconstrained fn encode_decode_full_message(\n        msg_type: u64,\n        msg_metadata: u64,\n        msg_content: [Field; MAX_MESSAGE_CONTENT_LEN],\n    ) {\n        let encoded = encode_message(msg_type, msg_metadata, msg_content);\n        let (decoded_msg_type, decoded_msg_metadata, decoded_msg_content) =\n            decode_message(BoundedVec::from_array(encoded));\n\n        assert_eq(decoded_msg_type, msg_type);\n        assert_eq(decoded_msg_metadata, msg_metadata);\n        assert_eq(decoded_msg_content.len(), msg_content.len());\n        assert_eq(subarray(decoded_msg_content.storage(), 0), msg_content);\n    }\n\n    #[test]\n    unconstrained fn to_expanded_metadata_packing() {\n        // Test case 1: All bits set\n        let packed = to_expanded_metadata(U64_MAX, U64_MAX);\n        let (msg_type, msg_metadata) = from_expanded_metadata(packed);\n        assert_eq(msg_type, U64_MAX);\n        assert_eq(msg_metadata, U64_MAX);\n\n        // Test case 2: Only log type bits set\n        let packed = to_expanded_metadata(U64_MAX, 0);\n        let (msg_type, msg_metadata) = from_expanded_metadata(packed);\n        assert_eq(msg_type, U64_MAX);\n        assert_eq(msg_metadata, 0);\n\n        // Test case 3: Only msg_metadata bits set\n        let packed = to_expanded_metadata(0, U64_MAX);\n        let (msg_type, msg_metadata) = from_expanded_metadata(packed);\n        assert_eq(msg_type, 0);\n        assert_eq(msg_metadata, U64_MAX);\n\n        // Test case 4: No bits set\n        let packed = to_expanded_metadata(0, 0);\n        let (msg_type, msg_metadata) = from_expanded_metadata(packed);\n        assert_eq(msg_type, 0);\n        assert_eq(msg_metadata, 0);\n    }\n\n    #[test]\n    unconstrained fn from_expanded_metadata_packing() {\n        // Test case 1: All bits set\n        let input = U128_MAX as Field;\n        let (msg_type, msg_metadata) = from_expanded_metadata(input);\n        assert_eq(msg_type, U64_MAX);\n        assert_eq(msg_metadata, U64_MAX);\n\n        // Test case 2: Only log type bits set\n        let input = (U128_MAX - U64_MAX as Field);\n        let (msg_type, msg_metadata) = from_expanded_metadata(input);\n        assert_eq(msg_type, U64_MAX);\n        assert_eq(msg_metadata, 0);\n\n        // Test case 3: Only msg_metadata bits set\n        let input = U64_MAX as Field;\n        let (msg_type, msg_metadata) = from_expanded_metadata(input);\n        assert_eq(msg_type, 0);\n        assert_eq(msg_metadata, U64_MAX);\n\n        // Test case 4: No bits set\n        let input = 0;\n        let (msg_type, msg_metadata) = from_expanded_metadata(input);\n        assert_eq(msg_type, 0);\n        assert_eq(msg_metadata, 0);\n    }\n\n    #[test]\n    unconstrained fn to_from_expanded_metadata(original_msg_type: u64, original_msg_metadata: u64) {\n        let packed = to_expanded_metadata(original_msg_type, original_msg_metadata);\n        let (unpacked_msg_type, unpacked_msg_metadata) = from_expanded_metadata(packed);\n\n        assert_eq(original_msg_type, unpacked_msg_type);\n        assert_eq(original_msg_metadata, unpacked_msg_metadata);\n    }\n}\n"
     },
-    "109": {
+    "120": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/encryption/aes128.nr",
       "source": "use dep::protocol_types::{\n    constants::{\n        GENERATOR_INDEX__SYMMETRIC_KEY, GENERATOR_INDEX__SYMMETRIC_KEY_2,\n        PRIVATE_LOG_CIPHERTEXT_LEN,\n    },\n    hash::poseidon2_hash_with_separator,\n    point::Point,\n};\n\nuse crate::{\n    keys::{\n        ecdh_shared_secret::derive_ecdh_shared_secret_using_aztec_address,\n        ephemeral::generate_ephemeral_key_pair,\n    },\n    messages::{\n        encryption::log_encryption::{\n            EPH_PK_SIGN_BYTE_SIZE_IN_BYTES, EPH_PK_X_SIZE_IN_FIELDS,\n            HEADER_CIPHERTEXT_SIZE_IN_BYTES, LogEncryption, PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS,\n        },\n        logs::arithmetic_generics_utils::{\n            get_arr_of_size__log_bytes__from_PT, get_arr_of_size__log_bytes_padding__from_PT,\n        },\n    },\n    oracle::{aes128_decrypt::aes128_decrypt_oracle, shared_secret::get_shared_secret},\n    prelude::AztecAddress,\n    utils::{\n        array,\n        conversion::{\n            bytes_to_fields::{bytes_from_fields, bytes_to_fields},\n            fields_to_bytes::{fields_from_bytes, fields_to_bytes},\n        },\n        point::{get_sign_of_point, point_from_x_coord_and_sign, point_to_bytes},\n        random::get_random_bytes,\n    },\n};\n\nuse std::aes128::aes128_encrypt;\n\nfn extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_poseidon2(\n    shared_secret: Point,\n) -> [u8; 32] {\n    let rand1: Field = poseidon2_hash_with_separator(\n        [shared_secret.x, shared_secret.y],\n        GENERATOR_INDEX__SYMMETRIC_KEY,\n    );\n    let rand2: Field = poseidon2_hash_with_separator(\n        [shared_secret.x, shared_secret.y],\n        GENERATOR_INDEX__SYMMETRIC_KEY_2,\n    );\n    let rand1_bytes: [u8; 16] = rand1.to_le_bytes();\n    let rand2_bytes: [u8; 16] = rand2.to_le_bytes();\n    let mut bytes: [u8; 32] = [0; 32];\n    for i in 0..16 {\n        bytes[i] = rand1_bytes[i];\n        bytes[i + 1] = rand2_bytes[i];\n    }\n    bytes\n}\n\n// TODO(#10537): Consider nuking this function.\nfn extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_sha256(\n    shared_secret: Point,\n) -> [u8; 32] {\n    let shared_secret_bytes: [u8; 32] = point_to_bytes(shared_secret);\n\n    let mut shared_secret_bytes_with_separator: [u8; 33] = std::mem::zeroed();\n    for i in 0..shared_secret_bytes.len() {\n        shared_secret_bytes_with_separator[i] = shared_secret_bytes[i];\n    }\n    shared_secret_bytes_with_separator[32] = GENERATOR_INDEX__SYMMETRIC_KEY;\n\n    sha256::digest(shared_secret_bytes_with_separator)\n}\n\nfn derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret(\n    shared_secret: Point,\n    randomness_extraction_fn: fn(Point) -> [u8; 32],\n) -> ([u8; 16], [u8; 16]) {\n    let random_256_bits = randomness_extraction_fn(shared_secret);\n    let mut sym_key = [0; 16];\n    let mut iv = [0; 16];\n    for i in 0..16 {\n        sym_key[i] = random_256_bits[i];\n        iv[i] = random_256_bits[i + 16];\n    }\n    (sym_key, iv)\n}\n\n// TODO(#10537): Consider nuking this function.\npub fn derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n    shared_secret: Point,\n) -> ([u8; 16], [u8; 16]) {\n    derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret(\n        shared_secret,\n        extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_sha256,\n    )\n}\n\n// TODO(#10537): This function is currently unused. Consider using it instead of the sha256 one.\npub fn derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_poseidon2(\n    shared_secret: Point,\n) -> ([u8; 16], [u8; 16]) {\n    derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret(\n        shared_secret,\n        extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_poseidon2,\n    )\n}\n\npub struct AES128 {}\n\nimpl LogEncryption for AES128 {\n    fn encrypt_log<let PLAINTEXT_LEN: u32>(\n        plaintext: [Field; PLAINTEXT_LEN],\n        recipient: AztecAddress,\n    ) -> [Field; PRIVATE_LOG_CIPHERTEXT_LEN] {\n        // AES 128 operates on bytes, not fields, so we need to convert the fields to bytes.\n        // (This process is then reversed when processing the log in `do_process_log`)\n        let plaintext_bytes = fields_to_bytes(plaintext);\n\n        // *****************************************************************************\n        // Compute the shared secret\n        // *****************************************************************************\n\n        let (eph_sk, eph_pk) = generate_ephemeral_key_pair();\n\n        let eph_pk_sign_byte: u8 = get_sign_of_point(eph_pk) as u8;\n\n        // (not to be confused with the tagging shared secret)\n        let ciphertext_shared_secret =\n            derive_ecdh_shared_secret_using_aztec_address(eph_sk, recipient);\n\n        // TODO: also use this shared secret for deriving note randomness.\n\n        // *****************************************************************************\n        // Convert the plaintext into whatever format the encryption function expects\n        // *****************************************************************************\n\n        // Already done for this strategy: AES expects bytes.\n\n        // *****************************************************************************\n        // Encrypt the plaintext\n        // *****************************************************************************\n\n        let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n            ciphertext_shared_secret,\n        );\n\n        let ciphertext_bytes = aes128_encrypt(plaintext_bytes, iv, sym_key);\n\n        // |full_pt| = |pt_length| + |pt|\n        // |pt_aes_padding| = 16 - (|full_pt| % 16)\n        // or... since a % b is the same as a - b * (a // b) (integer division), so:\n        // |pt_aes_padding| = 16 - (|full_pt| - 16 * (|full_pt| // 16))\n        // |ct| = |full_pt| + |pt_aes_padding|\n        //      = |full_pt| + 16 - (|full_pt| - 16 * (|full_pt| // 16))\n        //      = 16 + 16 * (|full_pt| // 16)\n        //      = 16 * (1 + |full_pt| // 16)\n        assert(ciphertext_bytes.len() == 16 * (1 + (PLAINTEXT_LEN * 32) / 16));\n\n        // *****************************************************************************\n        // Compute the header ciphertext\n        // *****************************************************************************\n\n        // Header contains only the length of the ciphertext stored in 2 bytes.\n        // TODO: consider nuking the header altogether and just have a fixed-size ciphertext by padding the plaintext.\n        // This would be more costly constraint-wise but cheaper DA-wise.\n        let mut header_plaintext: [u8; 2] = [0 as u8; 2];\n        let ciphertext_bytes_length = ciphertext_bytes.len();\n        header_plaintext[0] = (ciphertext_bytes_length >> 8) as u8;\n        header_plaintext[1] = ciphertext_bytes_length as u8;\n\n        // TODO: this is insecure and wasteful:\n        // \"Insecure\", because the esk shouldn't be used twice (once for the header,\n        // and again for the proper ciphertext) (at least, I never got the\n        // \"go ahead\" that this would be safe, unfortunately).\n        // \"Wasteful\", because the exact same computation is happening further down.\n        // I'm leaving that 2nd computation where it is, because this 1st computation\n        // will be imminently deleted, when the header logic is deleted.\n        let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n            ciphertext_shared_secret,\n        );\n\n        // Note: the aes128_encrypt builtin fn automatically appends bytes to the\n        // input, according to pkcs#7; hence why the output `header_ciphertext_bytes` is 16\n        // bytes larger than the input in this case.\n        let header_ciphertext_bytes = aes128_encrypt(header_plaintext, iv, sym_key);\n        // I recall that converting a slice to an array incurs constraints, so I'll check the length this way instead:\n        assert(header_ciphertext_bytes.len() == HEADER_CIPHERTEXT_SIZE_IN_BYTES);\n\n        // *****************************************************************************\n        // Prepend / append more bytes of data to the ciphertext, before converting back\n        // to fields.\n        // *****************************************************************************\n\n        let mut log_bytes_padding_to_mult_31 =\n            get_arr_of_size__log_bytes_padding__from_PT::<PLAINTEXT_LEN * 32>();\n        // Safety: this randomness won't be constrained to be random. It's in the\n        // interest of the executor of this fn to encrypt with random bytes.\n        log_bytes_padding_to_mult_31 = unsafe { get_random_bytes() };\n\n        let mut log_bytes = get_arr_of_size__log_bytes__from_PT::<PLAINTEXT_LEN * 32>();\n\n        assert(\n            log_bytes.len() % 31 == 0,\n            \"Unexpected error: log_bytes.len() should be divisible by 31, by construction.\",\n        );\n\n        log_bytes[0] = eph_pk_sign_byte;\n        let mut offset = 1;\n        for i in 0..header_ciphertext_bytes.len() {\n            log_bytes[offset + i] = header_ciphertext_bytes[i];\n        }\n        offset += header_ciphertext_bytes.len();\n\n        for i in 0..ciphertext_bytes.len() {\n            log_bytes[offset + i] = ciphertext_bytes[i];\n        }\n        offset += ciphertext_bytes.len();\n\n        for i in 0..log_bytes_padding_to_mult_31.len() {\n            log_bytes[offset + i] = log_bytes_padding_to_mult_31[i];\n        }\n\n        assert(\n            offset + log_bytes_padding_to_mult_31.len() == log_bytes.len(),\n            \"Something has gone wrong\",\n        );\n\n        // *****************************************************************************\n        // Convert bytes back to fields\n        // *****************************************************************************\n\n        // TODO(#12749): As Mike pointed out, we need to make logs produced by different encryption schemes\n        // indistinguishable from each other and for this reason the output here and in the last for-loop of this function\n        // should cover a full field.\n        let log_bytes_as_fields = bytes_to_fields(log_bytes);\n\n        // *****************************************************************************\n        // Prepend / append fields, to create the final log\n        // *****************************************************************************\n\n        let mut ciphertext: [Field; PRIVATE_LOG_CIPHERTEXT_LEN] = [0; PRIVATE_LOG_CIPHERTEXT_LEN];\n\n        ciphertext[0] = eph_pk.x;\n\n        let mut offset = 1;\n        for i in 0..log_bytes_as_fields.len() {\n            ciphertext[offset + i] = log_bytes_as_fields[i];\n        }\n        offset += log_bytes_as_fields.len();\n\n        for i in offset..PRIVATE_LOG_CIPHERTEXT_LEN {\n            // We need to get a random value that fits in 31 bytes to not leak information about the size of the log\n            // (all the \"real\" log fields contain at most 31 bytes because of the way we convert the bytes to fields).\n            // TODO(#12749): Long term, this is not a good solution.\n\n            // Safety: we assume that the sender wants for the log to be private - a malicious one could simply reveal its\n            // contents publicly. It is therefore fine to trust the sender to provide random padding.\n            let field_bytes = unsafe { get_random_bytes::<31>() };\n            ciphertext[i] = Field::from_be_bytes::<31>(field_bytes);\n        }\n\n        ciphertext\n    }\n\n    unconstrained fn decrypt_log(\n        ciphertext: BoundedVec<Field, PRIVATE_LOG_CIPHERTEXT_LEN>,\n        recipient: AztecAddress,\n    ) -> BoundedVec<Field, PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS> {\n        let eph_pk_x = ciphertext.get(0);\n\n        let ciphertext_without_eph_pk_x_fields = array::subbvec::<Field, PRIVATE_LOG_CIPHERTEXT_LEN, PRIVATE_LOG_CIPHERTEXT_LEN - EPH_PK_X_SIZE_IN_FIELDS>(\n            ciphertext,\n            EPH_PK_X_SIZE_IN_FIELDS,\n        );\n\n        // Convert the ciphertext represented as fields to a byte representation (its original format)\n        let ciphertext_without_eph_pk_x = bytes_from_fields(ciphertext_without_eph_pk_x_fields);\n\n        // First byte of the ciphertext represents the ephemeral public key sign\n        let eph_pk_sign_bool = ciphertext_without_eph_pk_x.get(0) != 0;\n        // With the sign and the x-coordinate of the ephemeral public key, we can reconstruct the point\n        let eph_pk = point_from_x_coord_and_sign(eph_pk_x, eph_pk_sign_bool);\n\n        // Derive shared secret and symmetric key\n        let ciphertext_shared_secret = get_shared_secret(recipient, eph_pk);\n        let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n            ciphertext_shared_secret,\n        );\n\n        // Extract the header ciphertext\n        let header_start = EPH_PK_SIGN_BYTE_SIZE_IN_BYTES; // Skip eph_pk_sign byte\n        let header_ciphertext: [u8; HEADER_CIPHERTEXT_SIZE_IN_BYTES] =\n            array::subarray(ciphertext_without_eph_pk_x.storage(), header_start);\n        // We need to convert the array to a BoundedVec because the oracle expects a BoundedVec as it's designed to work\n        // with logs with unknown length at compile time. This would not be necessary here as the header ciphertext length\n        // is fixed. But we do it anyway to not have to have duplicate oracles.\n        let header_ciphertext_bvec =\n            BoundedVec::<u8, HEADER_CIPHERTEXT_SIZE_IN_BYTES>::from_array(header_ciphertext);\n\n        // Decrypt header\n        let header_plaintext = aes128_decrypt_oracle(header_ciphertext_bvec, iv, sym_key);\n\n        // Extract ciphertext length from header (2 bytes, big-endian)\n        let ciphertext_length =\n            ((header_plaintext.get(0) as u32) << 8) | (header_plaintext.get(1) as u32);\n\n        // Extract and decrypt main ciphertext\n        let ciphertext_start = header_start + HEADER_CIPHERTEXT_SIZE_IN_BYTES;\n        let ciphertext_with_padding: [u8; (PRIVATE_LOG_CIPHERTEXT_LEN - EPH_PK_X_SIZE_IN_FIELDS) * 31 - HEADER_CIPHERTEXT_SIZE_IN_BYTES - EPH_PK_SIGN_BYTE_SIZE_IN_BYTES] =\n            array::subarray(ciphertext_without_eph_pk_x.storage(), ciphertext_start);\n        let ciphertext: BoundedVec<u8, (PRIVATE_LOG_CIPHERTEXT_LEN - EPH_PK_X_SIZE_IN_FIELDS) * 31 - HEADER_CIPHERTEXT_SIZE_IN_BYTES - EPH_PK_SIGN_BYTE_SIZE_IN_BYTES> =\n            BoundedVec::from_parts(ciphertext_with_padding, ciphertext_length);\n\n        // Decrypt main ciphertext and return it\n        let plaintext_bytes = aes128_decrypt_oracle(ciphertext, iv, sym_key);\n\n        // Each field of the original note log was serialized to 32 bytes so we convert the bytes back to fields.\n        fields_from_bytes(plaintext_bytes)\n    }\n}\n\nmod test {\n    use crate::{\n        keys::ecdh_shared_secret::derive_ecdh_shared_secret_using_aztec_address,\n        messages::encryption::log_encryption::{LogEncryption, PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS},\n        test::helpers::test_environment::TestEnvironment,\n    };\n    use super::AES128;\n    use protocol_types::{\n        address::AztecAddress,\n        indexed_tagging_secret::IndexedTaggingSecret,\n        traits::{Deserialize, FromField},\n    };\n    use std::{embedded_curve_ops::EmbeddedCurveScalar, test::OracleMock};\n\n    #[test]\n    unconstrained fn encrypt_decrypt_log() {\n        let mut env = TestEnvironment::new();\n        // Advance 1 block so we can read historic state from private\n        env.advance_block_by(1);\n\n        let plaintext = [1, 2, 3];\n\n        let recipient = AztecAddress::from_field(\n            0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n        );\n\n        // Mock random values for deterministic test\n        let eph_sk = 0x1358d15019d4639393d62b97e1588c095957ce74a1c32d6ec7d62fe6705d9538;\n        let _ = OracleMock::mock(\"getRandomField\").returns(eph_sk).times(1);\n\n        let randomness = 0x0101010101010101010101010101010101010101010101010101010101010101;\n        let _ = OracleMock::mock(\"getRandomField\").returns(randomness).times(1000000);\n\n        let _ = OracleMock::mock(\"getIndexedTaggingSecretAsSender\").returns(\n            IndexedTaggingSecret::deserialize([69420, 1337]),\n        );\n        let _ = OracleMock::mock(\"incrementAppTaggingSecretIndexAsSender\").returns(());\n\n        // Encrypt the log\n        let encrypted_log = BoundedVec::from_array(AES128::encrypt_log(plaintext, recipient));\n\n        // Mock shared secret for deterministic test\n        let shared_secret = derive_ecdh_shared_secret_using_aztec_address(\n            EmbeddedCurveScalar::from_field(eph_sk),\n            recipient,\n        );\n        let _ = OracleMock::mock(\"getSharedSecret\").returns(shared_secret);\n\n        // Decrypt the log\n        let decrypted = AES128::decrypt_log(encrypted_log, recipient);\n\n        // The decryption function spits out a BoundedVec because it's designed to work with logs with unknown length\n        // at compile time. For this reason we need to convert the original input to a BoundedVec.\n        let plaintext_bvec =\n            BoundedVec::<Field, PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS>::from_array(plaintext);\n\n        // Verify decryption matches original plaintext\n        assert_eq(decrypted, plaintext_bvec, \"Decrypted bytes should match original plaintext\");\n\n        // The following is a workaround of \"struct is never constructed\" Noir compilation error (we only ever use\n        // static methods of the struct).\n        let _ = AES128 {};\n    }\n}\n"
     },
-    "125": {
+    "136": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/processing/mod.nr",
-      "source": "pub(crate) mod event_validation_request;\npub mod message_context;\npub(crate) mod note_validation_request;\npub(crate) mod log_retrieval_request;\npub(crate) mod log_retrieval_response;\npub(crate) mod pending_tagged_log;\n\nuse crate::{\n    capsules::CapsuleArray,\n    messages::{\n        discovery::{\n            partial_notes::DeliveredPendingPartialNote, private_events::MAX_EVENT_SERIALIZED_LEN,\n            private_notes::MAX_NOTE_PACKED_LEN,\n        },\n        processing::{\n            log_retrieval_request::LogRetrievalRequest,\n            log_retrieval_response::LogRetrievalResponse,\n            note_validation_request::NoteValidationRequest, pending_tagged_log::PendingTaggedLog,\n        },\n    },\n    oracle,\n};\nuse event_validation_request::EventValidationRequest;\nuse protocol_types::{\n    abis::event_selector::EventSelector, address::AztecAddress, hash::sha256_to_field,\n};\n\n// Base slot for the pending tagged log array to which the fetch_tagged_logs oracle inserts found private logs.\nglobal PENDING_TAGGED_LOG_ARRAY_BASE_SLOT: Field =\n    sha256_to_field(\"AZTEC_NR::PENDING_TAGGED_LOG_ARRAY_BASE_SLOT\".as_bytes());\n\nglobal NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\nglobal EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\nglobal LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\nglobal LOG_RETRIEVAL_RESPONSES_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::LOG_RETRIEVAL_RESPONSES_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\n/// Searches for private logs emitted by `contract_address` that might contain messages for one of the local accounts,\n/// and stores them in a `CapsuleArray` which is then returned.\npub(crate) unconstrained fn get_private_logs(\n    contract_address: AztecAddress,\n) -> CapsuleArray<PendingTaggedLog> {\n    // We will eventually perform log discovery via tagging here, but for now we simply call the `fetchTaggedLogs`\n    // oracle. This makes PXE synchronize tags, download logs and store the pending tagged logs in a capsule array.\n    oracle::message_processing::fetch_tagged_logs(PENDING_TAGGED_LOG_ARRAY_BASE_SLOT);\n\n    CapsuleArray::at(contract_address, PENDING_TAGGED_LOG_ARRAY_BASE_SLOT)\n}\n\n/// Enqueues a note for validation by PXE, so that it becomes aware of a note's existence allowing for later retrieval\n/// via `get_notes` oracle. The note will be scoped to `contract_address`, meaning other contracts will not be able to\n/// access it unless authorized.\n///\n/// In order for the note validation and insertion to occur, `validate_enqueued_notes_and_events` must be later called.\n/// For optimal performance, accumulate as many note validation requests as possible and then validate them all at the\n/// end (which results in PXE minimizing the number of network round-trips).\n///\n/// The `packed_note` is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value\n/// is typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are\n/// the inner hashes, i.e. the raw hashes returned by `NoteHash::compute_note_hash` and\n/// `NoteHash::compute_nullifier`. PXE will verify that the siloed unique note hash was inserted into the tree\n/// at `tx_hash`, and will store the nullifier to later check for nullification.\n///\n/// `recipient` is the account to which the note was sent to. Other accounts will not be able to access this note (e.g.\n/// other accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized.\npub(crate) unconstrained fn enqueue_note_for_validation(\n    contract_address: AztecAddress,\n    storage_slot: Field,\n    note_nonce: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n    note_hash: Field,\n    nullifier: Field,\n    tx_hash: Field,\n    recipient: AztecAddress,\n) {\n    // We store requests in a `CapsuleArray`, which PXE will later read from and deserialize into its version of the\n    // Noir `NoteValidationRequest`\n    CapsuleArray::at(contract_address, NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).push(\n        NoteValidationRequest {\n            contract_address,\n            storage_slot,\n            note_nonce,\n            packed_note,\n            note_hash,\n            nullifier,\n            tx_hash,\n            recipient,\n        },\n    )\n}\n\n/// Enqueues an event for validation by PXE, so that it can be efficiently validated and then inserted into the event\n/// store.\n///\n/// In order for the event validation and insertion to occur, `validate_enqueued_notes_and_events` must be later\n/// called. For optimal performance, accumulate as many event validation requests as possible and then validate them\n/// all at the end (which results in PXE minimizing the number of network round-trips).\npub(crate) unconstrained fn enqueue_event_for_validation(\n    contract_address: AztecAddress,\n    event_type_id: EventSelector,\n    serialized_event: BoundedVec<Field, MAX_EVENT_SERIALIZED_LEN>,\n    event_commitment: Field,\n    tx_hash: Field,\n    recipient: AztecAddress,\n) {\n    // We store requests in a `CapsuleArray`, which PXE will later read from and deserialize into its version of the\n    // Noir `EventValidationRequest`\n    CapsuleArray::at(contract_address, EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).push(\n        EventValidationRequest {\n            contract_address,\n            event_type_id,\n            serialized_event,\n            event_commitment,\n            tx_hash,\n            recipient,\n        },\n    )\n}\n\n/// Validates all note and event validation requests enqueued via `enqueue_note_for_validation` and\n/// `enqueue_event_for_validation`, inserting them into the note database and event store respectively, making them\n/// queryable via `get_notes` oracle and our TS API (PXE::getPrivateEvents).\n///\n/// This automatically clears both validation request queues, so no further work needs to be done by the caller.\npub(crate) unconstrained fn validate_enqueued_notes_and_events(contract_address: AztecAddress) {\n    oracle::message_processing::validate_enqueued_notes_and_events(\n        contract_address,\n        NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT,\n        EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT,\n    );\n}\n\n/// Efficiently queries the node for logs that result in the completion of all `DeliveredPendingPartialNote`s stored in\n/// a `CapsuleArray` by performing all node communication concurrently. Returns a second `CapsuleArray` with Options for\n/// the responses that correspond to the pending partial notes at the same index.\n///\n/// For example, given an array with pending partial notes `[ p1, p2, p3 ]`, where `p1` and `p3` have corresponding\n/// completion logs but `p2` does not, the returned `CapsuleArray` will have contents\n/// `[some(p1_log), none(), some(p3_log)]`.\npub(crate) unconstrained fn get_pending_partial_notes_completion_logs(\n    contract_address: AztecAddress,\n    pending_partial_notes: CapsuleArray<DeliveredPendingPartialNote>,\n) -> CapsuleArray<Option<LogRetrievalResponse>> {\n    let log_retrieval_requests =\n        CapsuleArray::at(contract_address, LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT);\n\n    // We create a LogRetrievalRequest for each PendingPartialNote in the CapsuleArray. Because we need the indices in\n    // the request array to match the indices in the partial note array, we can't use CapsuleArray::for_each, as that\n    // function has arbitrary iteration order. Instead, we manually iterate the array from the beginning and push into\n    // the requests array, which we expect to be empty.\n    let mut i = 0;\n    let pending_partial_notes_count = pending_partial_notes.len();\n    while i < pending_partial_notes_count {\n        let pending_partial_note = pending_partial_notes.get(i);\n        log_retrieval_requests.push(\n            LogRetrievalRequest {\n                contract_address,\n                unsiloed_tag: pending_partial_note.note_completion_log_tag,\n            },\n        );\n        i += 1;\n    }\n\n    oracle::message_processing::bulk_retrieve_logs(\n        contract_address,\n        LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT,\n        LOG_RETRIEVAL_RESPONSES_ARRAY_BASE_SLOT,\n    );\n\n    CapsuleArray::at(contract_address, LOG_RETRIEVAL_RESPONSES_ARRAY_BASE_SLOT)\n}\n"
+      "source": "pub(crate) mod event_validation_request;\npub mod message_context;\npub(crate) mod note_validation_request;\npub(crate) mod log_retrieval_request;\npub(crate) mod log_retrieval_response;\npub(crate) mod pending_tagged_log;\n\nuse crate::{\n    capsules::CapsuleArray,\n    event::event_selector::EventSelector,\n    messages::{\n        discovery::{\n            partial_notes::DeliveredPendingPartialNote, private_events::MAX_EVENT_SERIALIZED_LEN,\n            private_notes::MAX_NOTE_PACKED_LEN,\n        },\n        processing::{\n            log_retrieval_request::LogRetrievalRequest,\n            log_retrieval_response::LogRetrievalResponse,\n            note_validation_request::NoteValidationRequest, pending_tagged_log::PendingTaggedLog,\n        },\n    },\n    oracle,\n};\nuse event_validation_request::EventValidationRequest;\nuse protocol_types::{address::AztecAddress, hash::sha256_to_field};\n\n// Base slot for the pending tagged log array to which the fetch_tagged_logs oracle inserts found private logs.\nglobal PENDING_TAGGED_LOG_ARRAY_BASE_SLOT: Field =\n    sha256_to_field(\"AZTEC_NR::PENDING_TAGGED_LOG_ARRAY_BASE_SLOT\".as_bytes());\n\nglobal NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\nglobal EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\nglobal LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\nglobal LOG_RETRIEVAL_RESPONSES_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::LOG_RETRIEVAL_RESPONSES_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\n/// Searches for private logs emitted by `contract_address` that might contain messages for one of the local accounts,\n/// and stores them in a `CapsuleArray` which is then returned.\npub(crate) unconstrained fn get_private_logs(\n    contract_address: AztecAddress,\n) -> CapsuleArray<PendingTaggedLog> {\n    // We will eventually perform log discovery via tagging here, but for now we simply call the `fetchTaggedLogs`\n    // oracle. This makes PXE synchronize tags, download logs and store the pending tagged logs in a capsule array.\n    oracle::message_processing::fetch_tagged_logs(PENDING_TAGGED_LOG_ARRAY_BASE_SLOT);\n\n    CapsuleArray::at(contract_address, PENDING_TAGGED_LOG_ARRAY_BASE_SLOT)\n}\n\n/// Enqueues a note for validation by PXE, so that it becomes aware of a note's existence allowing for later retrieval\n/// via `get_notes` oracle. The note will be scoped to `contract_address`, meaning other contracts will not be able to\n/// access it unless authorized.\n///\n/// In order for the note validation and insertion to occur, `validate_enqueued_notes_and_events` must be later called.\n/// For optimal performance, accumulate as many note validation requests as possible and then validate them all at the\n/// end (which results in PXE minimizing the number of network round-trips).\n///\n/// The `packed_note` is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value\n/// is typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are\n/// the inner hashes, i.e. the raw hashes returned by `NoteHash::compute_note_hash` and\n/// `NoteHash::compute_nullifier`. PXE will verify that the siloed unique note hash was inserted into the tree\n/// at `tx_hash`, and will store the nullifier to later check for nullification.\n///\n/// `recipient` is the account to which the note was sent to. Other accounts will not be able to access this note (e.g.\n/// other accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized.\npub(crate) unconstrained fn enqueue_note_for_validation(\n    contract_address: AztecAddress,\n    storage_slot: Field,\n    note_nonce: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n    note_hash: Field,\n    nullifier: Field,\n    tx_hash: Field,\n    recipient: AztecAddress,\n) {\n    // We store requests in a `CapsuleArray`, which PXE will later read from and deserialize into its version of the\n    // Noir `NoteValidationRequest`\n    CapsuleArray::at(contract_address, NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).push(\n        NoteValidationRequest {\n            contract_address,\n            storage_slot,\n            note_nonce,\n            packed_note,\n            note_hash,\n            nullifier,\n            tx_hash,\n            recipient,\n        },\n    )\n}\n\n/// Enqueues an event for validation by PXE, so that it can be efficiently validated and then inserted into the event\n/// store.\n///\n/// In order for the event validation and insertion to occur, `validate_enqueued_notes_and_events` must be later\n/// called. For optimal performance, accumulate as many event validation requests as possible and then validate them\n/// all at the end (which results in PXE minimizing the number of network round-trips).\npub(crate) unconstrained fn enqueue_event_for_validation(\n    contract_address: AztecAddress,\n    event_type_id: EventSelector,\n    serialized_event: BoundedVec<Field, MAX_EVENT_SERIALIZED_LEN>,\n    event_commitment: Field,\n    tx_hash: Field,\n    recipient: AztecAddress,\n) {\n    // We store requests in a `CapsuleArray`, which PXE will later read from and deserialize into its version of the\n    // Noir `EventValidationRequest`\n    CapsuleArray::at(contract_address, EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).push(\n        EventValidationRequest {\n            contract_address,\n            event_type_id,\n            serialized_event,\n            event_commitment,\n            tx_hash,\n            recipient,\n        },\n    )\n}\n\n/// Validates all note and event validation requests enqueued via `enqueue_note_for_validation` and\n/// `enqueue_event_for_validation`, inserting them into the note database and event store respectively, making them\n/// queryable via `get_notes` oracle and our TS API (PXE::getPrivateEvents).\n///\n/// This automatically clears both validation request queues, so no further work needs to be done by the caller.\npub(crate) unconstrained fn validate_enqueued_notes_and_events(contract_address: AztecAddress) {\n    oracle::message_processing::validate_enqueued_notes_and_events(\n        contract_address,\n        NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT,\n        EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT,\n    );\n}\n\n/// Efficiently queries the node for logs that result in the completion of all `DeliveredPendingPartialNote`s stored in\n/// a `CapsuleArray` by performing all node communication concurrently. Returns a second `CapsuleArray` with Options for\n/// the responses that correspond to the pending partial notes at the same index.\n///\n/// For example, given an array with pending partial notes `[ p1, p2, p3 ]`, where `p1` and `p3` have corresponding\n/// completion logs but `p2` does not, the returned `CapsuleArray` will have contents\n/// `[some(p1_log), none(), some(p3_log)]`.\npub(crate) unconstrained fn get_pending_partial_notes_completion_logs(\n    contract_address: AztecAddress,\n    pending_partial_notes: CapsuleArray<DeliveredPendingPartialNote>,\n) -> CapsuleArray<Option<LogRetrievalResponse>> {\n    let log_retrieval_requests =\n        CapsuleArray::at(contract_address, LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT);\n\n    // We create a LogRetrievalRequest for each PendingPartialNote in the CapsuleArray. Because we need the indices in\n    // the request array to match the indices in the partial note array, we can't use CapsuleArray::for_each, as that\n    // function has arbitrary iteration order. Instead, we manually iterate the array from the beginning and push into\n    // the requests array, which we expect to be empty.\n    let mut i = 0;\n    let pending_partial_notes_count = pending_partial_notes.len();\n    while i < pending_partial_notes_count {\n        let pending_partial_note = pending_partial_notes.get(i);\n        log_retrieval_requests.push(\n            LogRetrievalRequest {\n                contract_address,\n                unsiloed_tag: pending_partial_note.note_completion_log_tag,\n            },\n        );\n        i += 1;\n    }\n\n    oracle::message_processing::bulk_retrieve_logs(\n        contract_address,\n        LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT,\n        LOG_RETRIEVAL_RESPONSES_ARRAY_BASE_SLOT,\n    );\n\n    CapsuleArray::at(contract_address, LOG_RETRIEVAL_RESPONSES_ARRAY_BASE_SLOT)\n}\n"
     },
-    "145": {
+    "157": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr",
       "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store<T, let N: u32>(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n    T: Serialize<N>,\n{\n    let serialized = value.serialize();\n    store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load<T, let N: u32>(contract_address: AztecAddress, slot: Field) -> Option<T>\nwhere\n    T: Deserialize<N>,\n{\n    let serialized_option = load_oracle::<N>(contract_address, slot, N);\n    serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n    delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {\n    copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(storeCapsule)]\nunconstrained fn store_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option<T> directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(loadCapsule)]\nunconstrained fn load_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(deleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(copyCapsule)]\nunconstrained fn copy_oracle(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {}\n\nmod test {\n    // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n    // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n    // oracles are hooked up correctly.\n\n    use crate::{\n        oracle::capsules::{copy, delete, load, store},\n        test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n    };\n    use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n    unconstrained fn setup() -> AztecAddress {\n        let env = TestEnvironment::new();\n        env.contract_address()\n    }\n\n    global SLOT: Field = 1;\n\n    #[test]\n    unconstrained fn stores_and_loads() {\n        let contract_address = setup();\n\n        let value = MockStruct::new(5, 6);\n        store(contract_address, SLOT, value);\n\n        assert_eq(load(contract_address, SLOT).unwrap(), value);\n    }\n\n    #[test]\n    unconstrained fn store_overwrites() {\n        let contract_address = setup();\n\n        let value = MockStruct::new(5, 6);\n        store(contract_address, SLOT, value);\n\n        let new_value = MockStruct::new(7, 8);\n        store(contract_address, SLOT, new_value);\n\n        assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n    }\n\n    #[test]\n    unconstrained fn loads_empty_slot() {\n        let contract_address = setup();\n\n        let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n        assert_eq(loaded_value, Option::none());\n    }\n\n    #[test]\n    unconstrained fn deletes_stored_value() {\n        let contract_address = setup();\n\n        let value = MockStruct::new(5, 6);\n        store(contract_address, SLOT, value);\n        delete(contract_address, SLOT);\n\n        let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n        assert_eq(loaded_value, Option::none());\n    }\n\n    #[test]\n    unconstrained fn deletes_empty_slot() {\n        let contract_address = setup();\n\n        delete(contract_address, SLOT);\n        let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n        assert_eq(loaded_value, Option::none());\n    }\n\n    #[test]\n    unconstrained fn copies_non_overlapping_values() {\n        let contract_address = setup();\n\n        let src = 5;\n\n        let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n        store(contract_address, src, values[0]);\n        store(contract_address, src + 1, values[1]);\n        store(contract_address, src + 2, values[2]);\n\n        let dst = 10;\n        copy(contract_address, src, dst, 3);\n\n        assert_eq(load(contract_address, dst).unwrap(), values[0]);\n        assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n        assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_src_ahead() {\n        let contract_address = setup();\n\n        let src = 1;\n\n        let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n        store(contract_address, src, values[0]);\n        store(contract_address, src + 1, values[1]);\n        store(contract_address, src + 2, values[2]);\n\n        let dst = 2;\n        copy(contract_address, src, dst, 3);\n\n        assert_eq(load(contract_address, dst).unwrap(), values[0]);\n        assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n        assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n        // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n        assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n        assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n        assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_dst_ahead() {\n        let contract_address = setup();\n\n        let src = 2;\n\n        let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n        store(contract_address, src, values[0]);\n        store(contract_address, src + 1, values[1]);\n        store(contract_address, src + 2, values[2]);\n\n        let dst = 1;\n        copy(contract_address, src, dst, 3);\n\n        assert_eq(load(contract_address, dst).unwrap(), values[0]);\n        assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n        assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n        // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n        assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n        assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n        assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n    }\n\n    #[test(should_fail_with = \"copy empty slot\")]\n    unconstrained fn cannot_copy_empty_values() {\n        let contract_address = setup();\n\n        copy(contract_address, SLOT, SLOT, 1);\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_store_other_contract() {\n        let contract_address = setup();\n        let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n        let value = MockStruct::new(5, 6);\n        store(other_contract_address, SLOT, value);\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_load_other_contract() {\n        let contract_address = setup();\n        let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n        let _: Option<MockStruct> = load(other_contract_address, SLOT);\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_delete_other_contract() {\n        let contract_address = setup();\n        let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n        delete(other_contract_address, SLOT);\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_copy_other_contract() {\n        let contract_address = setup();\n        let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n        copy(other_contract_address, SLOT, SLOT, 0);\n    }\n}\n"
     },
-    "146": {
+    "158": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",
       "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(notifyEnqueuedPublicFunctionCall)]\nunconstrained fn notify_enqueued_public_function_call_oracle(\n    _contract_address: AztecAddress,\n    _calldata_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) {}\n\nunconstrained fn notify_enqueued_public_function_call_wrapper(\n    contract_address: AztecAddress,\n    calldata_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) {\n    notify_enqueued_public_function_call_oracle(\n        contract_address,\n        calldata_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_enqueued_public_function_call(\n    contract_address: AztecAddress,\n    calldata_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) {\n    // Safety: Notifies the simulator that a public call has been enqueued, allowing it to prepare hints for the AVM to process this call.\n    unsafe {\n        notify_enqueued_public_function_call_wrapper(\n            contract_address,\n            calldata_hash,\n            side_effect_counter,\n            is_static_call,\n        )\n    }\n}\n\n#[oracle(notifySetPublicTeardownFunctionCall)]\nunconstrained fn notify_set_public_teardown_function_call_oracle(\n    _contract_address: AztecAddress,\n    _calldata_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) {}\n\nunconstrained fn notify_set_public_teardown_function_call_wrapper(\n    contract_address: AztecAddress,\n    calldata_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) {\n    notify_set_public_teardown_function_call_oracle(\n        contract_address,\n        calldata_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_set_public_teardown_function_call(\n    contract_address: AztecAddress,\n    calldata_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) {\n    // Safety: Notifies the simulator that a teardown call has been set, allowing it to prepare hints for the AVM to process this call.\n    unsafe {\n        notify_set_public_teardown_function_call_wrapper(\n            contract_address,\n            calldata_hash,\n            side_effect_counter,\n            is_static_call,\n        )\n    }\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n    notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n"
     },
-    "147": {
+    "159": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution.nr",
       "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(getContractAddress)]\nunconstrained fn get_contract_address_oracle() -> AztecAddress {}\n\n#[oracle(getBlockNumber)]\nunconstrained fn get_block_number_oracle() -> u32 {}\n\n#[oracle(getTimestamp)]\nunconstrained fn get_timestamp_oracle() -> u64 {}\n\n#[oracle(getChainId)]\nunconstrained fn get_chain_id_oracle() -> Field {}\n\n#[oracle(getVersion)]\nunconstrained fn get_version_oracle() -> Field {}\n\npub unconstrained fn get_contract_address() -> AztecAddress {\n    get_contract_address_oracle()\n}\n\npub unconstrained fn get_block_number() -> u32 {\n    get_block_number_oracle()\n}\n\npub unconstrained fn get_timestamp() -> u64 {\n    get_timestamp_oracle()\n}\n\npub unconstrained fn get_chain_id() -> Field {\n    get_chain_id_oracle()\n}\n\npub unconstrained fn get_version() -> Field {\n    get_version_oracle()\n}\n"
     },
-    "148": {
+    "160": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution_cache.nr",
       "source": "/// Stores values represented as slice in execution cache to be later obtained by its hash.\npub fn store(values: [Field], hash: Field) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call. When loading the values, however, the caller must check that the values are indeed the preimage.\n    unsafe { store_in_execution_cache_oracle_wrapper(values, hash) };\n}\n\nunconstrained fn store_in_execution_cache_oracle_wrapper(values: [Field], hash: Field) {\n    store_in_execution_cache_oracle(values, hash);\n}\n\npub unconstrained fn load<let N: u32>(hash: Field) -> [Field; N] {\n    load_from_execution_cache_oracle(hash)\n}\n\n#[oracle(storeInExecutionCache)]\nunconstrained fn store_in_execution_cache_oracle(_values: [Field], _hash: Field) {}\n\n#[oracle(loadFromExecutionCache)]\nunconstrained fn load_from_execution_cache_oracle<let N: u32>(_hash: Field) -> [Field; N] {}\n"
     },
-    "157": {
+    "169": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/message_processing.nr",
       "source": "use protocol_types::address::AztecAddress;\n\n/// Finds new private logs that may have been sent to all registered accounts in PXE in the current contract and makes\n/// them available for later processing in Noir by storing them in a capsule array.\npub unconstrained fn fetch_tagged_logs(pending_tagged_log_array_base_slot: Field) {\n    fetch_tagged_logs_oracle(pending_tagged_log_array_base_slot);\n}\n\n#[oracle(fetchTaggedLogs)]\nunconstrained fn fetch_tagged_logs_oracle(pending_tagged_log_array_base_slot: Field) {}\n\n// This must be a single oracle and not one for notes and one for events because the entire point is to validate\n// all notes and events in one go, minimizing node round-trips.\npub(crate) unconstrained fn validate_enqueued_notes_and_events(\n    contract_address: AztecAddress,\n    note_validation_requests_array_base_slot: Field,\n    event_validation_requests_array_base_slot: Field,\n) {\n    validate_enqueued_notes_and_events_oracle(\n        contract_address,\n        note_validation_requests_array_base_slot,\n        event_validation_requests_array_base_slot,\n    );\n}\n\n#[oracle(validateEnqueuedNotesAndEvents)]\nunconstrained fn validate_enqueued_notes_and_events_oracle(\n    contract_address: AztecAddress,\n    note_validation_requests_array_base_slot: Field,\n    event_validation_requests_array_base_slot: Field,\n) {}\n\npub(crate) unconstrained fn bulk_retrieve_logs(\n    contract_address: AztecAddress,\n    log_retrieval_requests_array_base_slot: Field,\n    log_retrieval_responses_array_base_slot: Field,\n) {\n    bulk_retrieve_logs_oracle(\n        contract_address,\n        log_retrieval_requests_array_base_slot,\n        log_retrieval_responses_array_base_slot,\n    );\n}\n\n#[oracle(bulkRetrieveLogs)]\nunconstrained fn bulk_retrieve_logs_oracle(\n    contract_address: AztecAddress,\n    log_retrieval_requests_array_base_slot: Field,\n    log_retrieval_responses_array_base_slot: Field,\n) {}\n"
     },
-    "162": {
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/shared_secret.nr",
-      "source": "use protocol_types::{address::aztec_address::AztecAddress, point::Point};\n\n// TODO(#12656): return an app-siloed secret + document this\n#[oracle(getSharedSecret)]\nunconstrained fn get_shared_secret_oracle(address: AztecAddress, ephPk: Point) -> Point {}\n\n/// Returns an app-siloed shared secret between `address` and someone who knows the secret key behind an\n/// ephemeral public key `ephPk`. The app-siloing means that contracts cannot retrieve secrets that belong to\n/// other contracts, and therefore cannot e.g. decrypt their messages. This is an important security consideration\n/// given that both the `address` and `ephPk` are public information.\n///\n/// The shared secret `S` is computed as:\n/// `let S =  (ivsk + h) * ephPk`\n/// where `ivsk + h` is the 'preaddress' i.e. the preimage of the address, also called the address secret.\n/// TODO(#12656): app-silo this secret\npub unconstrained fn get_shared_secret(address: AztecAddress, ephPk: Point) -> Point {\n    get_shared_secret_oracle(address, ephPk)\n}\n"
-    },
     "17": {
       "path": "std/field/bn254.nr",
       "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(x: Field) -> (Field, Field) {\n    // Here's we're taking advantage of truncating 128 bit limbs from the input field\n    // and then subtracting them from the input such the field division is equivalent to integer division.\n    let low = (x as u128) as Field;\n    let high = (x - low) / TWO_POW_128;\n\n    (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n    compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n    if x == y {\n        true\n    } else {\n        field_less_than(x, y)\n    }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n    let (alo, ahi) = a;\n    let (blo, bhi) = b;\n    // Safety: borrow is enforced to be boolean due to its type.\n    // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n    // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n    unsafe {\n        let borrow = lte_hint(alo, blo);\n\n        let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n        let rhi = ahi - bhi - (borrow as Field);\n\n        rlo.assert_max_bit_size::<128>();\n        rhi.assert_max_bit_size::<128>();\n    }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n    if is_unconstrained() {\n        compute_decomposition(x)\n    } else {\n        // Safety: decomposition is properly checked below\n        unsafe {\n            // Take hints of the decomposition\n            let (xlo, xhi) = decompose_hint(x);\n\n            // Range check the limbs\n            xlo.assert_max_bit_size::<128>();\n            xhi.assert_max_bit_size::<128>();\n\n            // Check that the decomposition is correct\n            assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n            // Assert that the decomposition of P is greater than the decomposition of x\n            assert_gt_limbs((PLO, PHI), (xlo, xhi));\n            (xlo, xhi)\n        }\n    }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n    if is_unconstrained() {\n        assert(\n            // Safety: already unconstrained\n            unsafe { field_less_than(b, a) },\n        );\n    } else {\n        // Decompose a and b\n        let a_limbs = decompose(a);\n        let b_limbs = decompose(b);\n\n        // Assert that a_limbs is greater than b_limbs\n        assert_gt_limbs(a_limbs, b_limbs)\n    }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n    assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unsafe in unconstrained\n        unsafe {\n            field_less_than(b, a)\n        }\n    } else if a == b {\n        false\n    } else {\n        // Safety: Take a hint of the comparison and verify it\n        unsafe {\n            if field_less_than(a, b) {\n                assert_gt(b, a);\n                false\n            } else {\n                assert_gt(a, b);\n                true\n            }\n        }\n    }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n    gt(b, a)\n}\n\nmod tests {\n    // TODO: Allow imports from \"super\"\n    use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n    #[test]\n    fn check_decompose() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_decompose_unconstrained() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_lte_hint() {\n        assert(lte_hint(0, 1));\n        assert(lte_hint(0, 0x100));\n        assert(lte_hint(0x100, TWO_POW_128 - 1));\n        assert(!lte_hint(0 - 1, 0));\n\n        assert(lte_hint(0, 0));\n        assert(lte_hint(0x100, 0x100));\n        assert(lte_hint(0 - 1, 0 - 1));\n    }\n\n    #[test]\n    fn check_assert_gt() {\n        assert_gt(1, 0);\n        assert_gt(0x100, 0);\n        assert_gt((0 - 1), (0 - 2));\n        assert_gt(TWO_POW_128, 0);\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    unconstrained fn check_assert_gt_unconstrained() {\n        assert_gt(1, 0);\n        assert_gt(0x100, 0);\n        assert_gt((0 - 1), (0 - 2));\n        assert_gt(TWO_POW_128, 0);\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    fn check_gt() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n    }\n\n    #[test]\n    unconstrained fn check_gt_unconstrained() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n    }\n\n    #[test]\n    fn check_plo_phi() {\n        assert_eq(PLO + PHI * TWO_POW_128, 0);\n        let p_bytes = crate::field::modulus_le_bytes();\n        let mut p_low: Field = 0;\n        let mut p_high: Field = 0;\n\n        let mut offset = 1;\n        for i in 0..16 {\n            p_low += (p_bytes[i] as Field) * offset;\n            p_high += (p_bytes[i + 16] as Field) * offset;\n            offset *= 256;\n        }\n        assert_eq(p_low, PLO);\n        assert_eq(p_high, PHI);\n    }\n}\n"
     },
+    "174": {
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/shared_secret.nr",
+      "source": "use protocol_types::{address::aztec_address::AztecAddress, point::Point};\n\n// TODO(#12656): return an app-siloed secret + document this\n#[oracle(getSharedSecret)]\nunconstrained fn get_shared_secret_oracle(address: AztecAddress, ephPk: Point) -> Point {}\n\n/// Returns an app-siloed shared secret between `address` and someone who knows the secret key behind an\n/// ephemeral public key `ephPk`. The app-siloing means that contracts cannot retrieve secrets that belong to\n/// other contracts, and therefore cannot e.g. decrypt their messages. This is an important security consideration\n/// given that both the `address` and `ephPk` are public information.\n///\n/// The shared secret `S` is computed as:\n/// `let S =  (ivsk + h) * ephPk`\n/// where `ivsk + h` is the 'preaddress' i.e. the preimage of the address, also called the address secret.\n/// TODO(#12656): app-silo this secret\npub unconstrained fn get_shared_secret(address: AztecAddress, ephPk: Point) -> Point {\n    get_shared_secret_oracle(address, ephPk)\n}\n"
+    },
     "18": {
       "path": "std/field/mod.nr",
       "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n    /// Asserts that `self` can be represented in `bit_size` bits.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n    // docs:start:assert_max_bit_size\n    pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {\n        // docs:end:assert_max_bit_size\n        static_assert(\n            BIT_SIZE < modulus_num_bits() as u32,\n            \"BIT_SIZE must be less than modulus_num_bits\",\n        );\n        __assert_max_bit_size(self, BIT_SIZE);\n    }\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n    /// This slice will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_le_bits\n    pub fn to_le_bits<let N: u32>(self: Self) -> [u1; N] {\n        // docs:end:to_le_bits\n        let bits = __to_le_bits(self);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[N - 1 - i] != p[N - 1 - i]) {\n                        assert(p[N - 1 - i] == 1);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_be_bits\n    pub fn to_be_bits<let N: u32>(self: Self) -> [u1; N] {\n        // docs:end:to_be_bits\n        let bits = __to_be_bits(self);\n\n        if !is_unconstrained() {\n            // Ensure that the decomposition does not overflow the modulus\n            let p = modulus_be_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[i] != p[i]) {\n                        assert(p[i] == 1);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_le_bytes\n    pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_le_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_le_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[N - 1 - i] != p[N - 1 - i]) {\n                        assert(bytes[N - 1 - i] < p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_be_bytes\n    pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_be_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_be_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_be_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[i] != p[i]) {\n                        assert(bytes[i] < p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        __to_le_radix(self, radix)\n    }\n\n    fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        __to_be_radix(self, radix)\n    }\n\n    // Returns self to the power of the given exponent value.\n    // Caution: we assume the exponent fits into 32 bits\n    // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n    pub fn pow_32(self, exponent: Field) -> Field {\n        let mut r: Field = 1;\n        let b: [u1; 32] = exponent.to_le_bits();\n\n        for i in 1..33 {\n            r *= r;\n            r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n        }\n        r\n    }\n\n    // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n    pub fn sgn0(self) -> u1 {\n        self as u1\n    }\n\n    pub fn lt(self, another: Field) -> bool {\n        if crate::compat::is_bn254() {\n            bn254_lt(self, another)\n        } else {\n            lt_fallback(self, another)\n        }\n    }\n\n    /// Convert a little endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n\n    /// Convert a big endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[N - 1 - i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n}\n\n#[builtin(apply_range_constraint)]\nfn __assert_max_bit_size(value: Field, bit_size: u32) {}\n\n// `_radix` must be less than 256\n#[builtin(to_le_radix)]\nfn __to_le_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n// `_radix` must be less than 256\n#[builtin(to_be_radix)]\nfn __to_be_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n/// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n/// This slice will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_le_bits)]\nfn __to_le_bits<let N: u32>(value: Field) -> [u1; N] {}\n\n/// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_be_bits)]\nfn __to_be_bits<let N: u32>(value: Field) -> [u1; N] {}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n    __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..16 {\n        high = high + (bytes32[15 - i] as Field) * v;\n        low = low + (bytes32[16 + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    // Abuse that a % p + b % p = (a + b) % p and that low < p\n    low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unconstrained context\n        unsafe {\n            field_less_than(x, y)\n        }\n    } else {\n        let x_bytes: [u8; 32] = x.to_le_bytes();\n        let y_bytes: [u8; 32] = y.to_le_bytes();\n        let mut x_is_lt = false;\n        let mut done = false;\n        for i in 0..32 {\n            if (!done) {\n                let x_byte = x_bytes[32 - 1 - i] as u8;\n                let y_byte = y_bytes[32 - 1 - i] as u8;\n                let bytes_match = x_byte == y_byte;\n                if !bytes_match {\n                    x_is_lt = x_byte < y_byte;\n                    done = true;\n                }\n            }\n        }\n        x_is_lt\n    }\n}\n\nmod tests {\n    use crate::{panic::panic, runtime};\n    use super::field_less_than;\n\n    #[test]\n    // docs:start:to_be_bits_example\n    fn test_to_be_bits() {\n        let field = 2;\n        let bits: [u1; 8] = field.to_be_bits();\n        assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n    }\n    // docs:end:to_be_bits_example\n\n    #[test]\n    // docs:start:to_le_bits_example\n    fn test_to_le_bits() {\n        let field = 2;\n        let bits: [u1; 8] = field.to_le_bits();\n        assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n    }\n    // docs:end:to_le_bits_example\n\n    #[test]\n    // docs:start:to_be_bytes_example\n    fn test_to_be_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_be_bytes();\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_bytes_example\n\n    #[test]\n    // docs:start:to_le_bytes_example\n    fn test_to_le_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_le_bytes();\n        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_bytes_example\n\n    #[test]\n    // docs:start:to_be_radix_example\n    fn test_to_be_radix() {\n        // 259, in base 256, big endian, is [1, 3].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_be_radix(256);\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_radix_example\n\n    #[test]\n    // docs:start:to_le_radix_example\n    fn test_to_le_radix() {\n        // 259, in base 256, little endian, is [3, 1].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_le_radix(256);\n        assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_radix_example\n\n    #[test(should_fail_with = \"radix must be greater than 1\")]\n    fn test_to_le_radix_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(f\"radix must be greater than 1\");\n        }\n    }\n\n    // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n    //#[test]\n    //fn test_to_le_radix_brillig_1() {\n    //    // this test should only fail in constrained mode\n    //    if runtime::is_unconstrained() {\n    //        let field = 1;\n    //        let out: [u8; 8] = field.to_le_radix(1);\n    //        crate::println(out);\n    //        let expected = [0; 8];\n    //        assert(out == expected, \"unexpected result\");\n    //    }\n    //}\n\n    #[test(should_fail_with = \"radix must be a power of 2\")]\n    fn test_to_le_radix_3() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(3);\n        } else {\n            panic(f\"radix must be a power of 2\");\n        }\n    }\n\n    #[test]\n    fn test_to_le_radix_brillig_3() {\n        // this test should only fail in constrained mode\n        if runtime::is_unconstrained() {\n            let field = 1;\n            let out: [u8; 8] = field.to_le_radix(3);\n            let mut expected = [0; 8];\n            expected[0] = 1;\n            assert(out == expected, \"unexpected result\");\n        }\n    }\n\n    #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n    fn test_to_le_radix_512() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(512);\n        } else {\n            panic(f\"radix must be less than or equal to 256\")\n        }\n    }\n\n    // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n    //#[test]\n    //fn test_to_le_radix_brillig_512() {\n    //    // this test should only fail in constrained mode\n    //    if runtime::is_unconstrained() {\n    //        let field = 1;\n    //        let out: [u8; 8] = field.to_le_radix(512);\n    //        let mut expected = [0; 8];\n    //        expected[0] = 1;\n    //        assert(out == expected, \"unexpected result\");\n    //    }\n    //}\n\n    #[test]\n    unconstrained fn test_field_less_than() {\n        assert(field_less_than(0, 1));\n        assert(field_less_than(0, 0x100));\n        assert(field_less_than(0x100, 0 - 1));\n        assert(!field_less_than(0 - 1, 0));\n    }\n}\n"
     },
-    "188": {
+    "201": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/append.nr",
       "source": "/// Appends two `BoundedVec`s together, returning one that contains all of the elements of the first one followed by all\n/// of the elements of the second one. The resulting `BoundedVec` can have any arbitrary maximum length, but it must be\n/// large enough to fit all of the elements of both the first and second vectors.\npub fn append<T, let A_LEN: u32, let B_LEN: u32, let DST_LEN: u32>(\n    a: BoundedVec<T, A_LEN>,\n    b: BoundedVec<T, B_LEN>,\n) -> BoundedVec<T, DST_LEN> {\n    let mut dst = BoundedVec::new();\n\n    dst.extend_from_bounded_vec(a);\n    dst.extend_from_bounded_vec(b);\n\n    dst\n}\n\nmod test {\n    use super::append;\n\n    #[test]\n    unconstrained fn append_empty_vecs() {\n        let a: BoundedVec<_, 3> = BoundedVec::new();\n        let b: BoundedVec<_, 14> = BoundedVec::new();\n\n        let result: BoundedVec<Field, 5> = append(a, b);\n\n        assert_eq(result.len(), 0);\n        assert_eq(result.storage(), std::mem::zeroed());\n    }\n\n    #[test]\n    unconstrained fn append_non_empty_vecs() {\n        let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n        let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n        let result: BoundedVec<Field, 8> = append(a, b);\n\n        assert_eq(result.len(), 6);\n        assert_eq(result.storage(), [1, 2, 3, 4, 5, 6, std::mem::zeroed(), std::mem::zeroed()]);\n    }\n\n    #[test(should_fail_with = \"out of bounds\")]\n    unconstrained fn append_non_empty_vecs_insufficient_max_len() {\n        let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n        let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n        let _: BoundedVec<Field, 5> = append(a, b);\n    }\n}\n"
     },
-    "191": {
+    "204": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr",
       "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must not be larger than the number\n/// of elements past `offset`.\n///\n/// Examples:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n///\n/// let bar: [Field; 5] = subarray([1, 2, 3, 4, 5], 2); // fails - we can't return 5 elements since only 3 remain\n/// ```\npub fn subarray<T, let SRC_LEN: u32, let DST_LEN: u32>(\n    src: [T; SRC_LEN],\n    offset: u32,\n) -> [T; DST_LEN] {\n    assert(offset + DST_LEN <= SRC_LEN, \"DST_LEN too large for offset\");\n\n    let mut dst: [T; DST_LEN] = std::mem::zeroed();\n    for i in 0..DST_LEN {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\nmod test {\n    use super::subarray;\n\n    #[test]\n    unconstrained fn subarray_into_empty() {\n        // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n        assert_eq(subarray::<Field, _, _>([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n    }\n\n    #[test]\n    unconstrained fn subarray_complete() {\n        assert_eq(subarray::<Field, _, _>([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n    }\n\n    #[test]\n    unconstrained fn subarray_different_end_sizes() {\n        // We implicitly select how many values to read in the size of the return array\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n    }\n\n    #[test(should_fail_with = \"DST_LEN too large for offset\")]\n    unconstrained fn subarray_offset_too_large() {\n        // With an offset of 1 we can only request up to 4 elements\n        let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_bad_return_value() {\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n    }\n}\n"
     },
-    "192": {
+    "205": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subbvec.nr",
       "source": "use crate::utils::array;\n\n/// Returns `DST_MAX_LEN` elements from a source BoundedVec, starting at `offset`. `offset` must not be larger than the\n/// original length, and `DST_LEN` must not be larger than the total number of elements past `offset` (including the\n/// zeroed elements past `len()`).\n///\n/// Only elements at the beginning of the vector can be removed: it is not possible to also remove elements at the end\n/// of the vector by passing a value for `DST_LEN` that is smaller than `len() - offset`.\n///\n/// Examples:\n/// ```\n/// let foo = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n/// assert_eq(subbvec(foo, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n///\n/// let bar: BoundedVec<_, 1> = subbvec(foo, 2); // fails - we can't return just 1 element since 3 remain\n/// let baz: BoundedVec<_, 10> = subbvec(foo, 3); // fails - we can't return 10 elements since only 7 remain\n/// ```\npub fn subbvec<T, let SRC_MAX_LEN: u32, let DST_MAX_LEN: u32>(\n    bvec: BoundedVec<T, SRC_MAX_LEN>,\n    offset: u32,\n) -> BoundedVec<T, DST_MAX_LEN> {\n    // from_parts_unchecked does not verify that the elements past len are zeroed, but that is not an issue in our case\n    // because we're constructing the new storage array as a subarray of the original one (which should have zeroed\n    // storage past len), guaranteeing correctness. This is because `subarray` does not allow extending arrays past\n    // their original length.\n    BoundedVec::from_parts_unchecked(array::subarray(bvec.storage(), offset), bvec.len() - offset)\n}\n\nmod test {\n    use super::subbvec;\n\n    #[test]\n    unconstrained fn subbvec_empty() {\n        let bvec = BoundedVec::<Field, 0>::from_array([]);\n        assert_eq(subbvec(bvec, 0), bvec);\n    }\n\n    #[test]\n    unconstrained fn subbvec_complete() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 0), bvec);\n\n        let smaller_capacity = BoundedVec::<_, 5>::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 0), smaller_capacity);\n    }\n\n    #[test]\n    unconstrained fn subbvec_partial() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        assert_eq(subbvec(bvec, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n        assert_eq(subbvec(bvec, 2), BoundedVec::<_, 3>::from_array([3, 4, 5]));\n    }\n\n    #[test]\n    unconstrained fn subbvec_into_empty() {\n        let bvec: BoundedVec<_, 10> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 5), BoundedVec::<_, 5>::from_array([]));\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subbvec_offset_past_len() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n        let _: BoundedVec<_, 1> = subbvec(bvec, 6);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subbvec_insufficient_dst_len() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // We're not providing enough space to hold all of the items inside the original BoundedVec. subbvec can cause\n        // for the capacity to reduce, but not the length (other than by len - offset).\n        let _: BoundedVec<_, 1> = subbvec(bvec, 2);\n    }\n\n    #[test(should_fail_with = \"DST_LEN too large for offset\")]\n    unconstrained fn subbvec_dst_len_causes_enlarge() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // subbvec does not supprt capacity increases\n        let _: BoundedVec<_, 11> = subbvec(bvec, 0);\n    }\n\n    #[test(should_fail_with = \"DST_LEN too large for offset\")]\n    unconstrained fn subbvec_dst_len_too_large_for_offset() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // This effectively requests a capacity increase, since there'd be just one element plus the 5 empty slots,\n        // which is less than 7.\n        let _: BoundedVec<_, 7> = subbvec(bvec, 4);\n    }\n}\n"
     },
-    "193": {
+    "206": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/comparison.nr",
       "source": "struct ComparatorEnum {\n    pub EQ: u8,\n    pub NEQ: u8,\n    pub LT: u8,\n    pub LTE: u8,\n    pub GT: u8,\n    pub GTE: u8,\n}\n\npub global Comparator: ComparatorEnum =\n    ComparatorEnum { EQ: 1, NEQ: 2, LT: 3, LTE: 4, GT: 5, GTE: 6 };\n\npub fn compare(lhs: Field, operation: u8, rhs: Field) -> bool {\n    // Values are computed ahead of time because circuits evaluate all branches\n    let is_equal = lhs == rhs;\n    let is_lt = lhs.lt(rhs);\n\n    if (operation == Comparator.EQ) {\n        is_equal\n    } else if (operation == Comparator.NEQ) {\n        !is_equal\n    } else if (operation == Comparator.LT) {\n        is_lt\n    } else if (operation == Comparator.LTE) {\n        is_lt | is_equal\n    } else if (operation == Comparator.GT) {\n        !is_lt & !is_equal\n    } else if (operation == Comparator.GTE) {\n        !is_lt\n    } else {\n        panic(f\"Invalid operation\")\n    }\n}\n\nmod test {\n    use super::Comparator;\n    use super::compare;\n\n    #[test]\n    unconstrained fn test_compare() {\n        let lhs = 10;\n        let rhs = 10;\n        assert(compare(lhs, Comparator.EQ, rhs), \"Expected lhs to be equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(compare(lhs, Comparator.NEQ, rhs), \"Expected lhs to be not equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(compare(lhs, Comparator.LT, rhs), \"Expected lhs to be less than rhs\");\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(compare(lhs, Comparator.LTE, rhs), \"Expected lhs to be less than or equal to rhs\");\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(compare(lhs, Comparator.GT, rhs), \"Expected lhs to be greater than rhs\");\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(\n            compare(lhs, Comparator.GTE, rhs),\n            \"Expected lhs to be greater than or equal to rhs\",\n        );\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(\n            compare(lhs, Comparator.GTE, rhs),\n            \"Expected lhs to be greater than or equal to rhs\",\n        );\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(!compare(lhs, Comparator.EQ, rhs), \"Expected lhs to be not equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(!compare(lhs, Comparator.NEQ, rhs), \"Expected lhs to not be not equal to rhs\");\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(!compare(lhs, Comparator.LT, rhs), \"Expected lhs to not be less than rhs\");\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(\n            !compare(lhs, Comparator.LTE, rhs),\n            \"Expected lhs to not be less than or equal to rhs\",\n        );\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(!compare(lhs, Comparator.GT, rhs), \"Expected lhs to not be greater than rhs\");\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(\n            !compare(lhs, Comparator.GTE, rhs),\n            \"Expected lhs to not be greater than or equal to rhs\",\n        );\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(\n            !compare(lhs, Comparator.GTE, rhs),\n            \"Expected lhs to not be greater than or equal to rhs\",\n        );\n    }\n}\n"
     },
-    "194": {
+    "207": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/conversion/bytes_to_fields.nr",
       "source": "use std::static_assert;\n\n// These functions are used to facilitate the conversion of log ciphertext between byte and field representations.\n//\n// `bytes_to_fields` uses fixed-size arrays since encryption contexts have compile-time size information.\n// `bytes_from_fields` uses BoundedVec for flexibility in unconstrained contexts where sizes are dynamic.\n//\n// Together they provide bidirectional conversion between bytes and fields when processing encrypted logs.\n\n/// Converts the input bytes into an array of fields. A Field is ~254 bits meaning that each field can store 31 whole\n/// bytes. Use `bytes_from_fields` to obtain the original bytes array.\n///\n/// The input bytes are chunked into chunks of 31 bytes. Each 31-byte chunk is viewed as big-endian, and is converted\n/// into a Field.\n/// For example, [1, 10, 3, ..., 0] (31 bytes) is encoded as [1 * 256^30 + 10 * 256^29 + 3 * 256^28 + ... + 0]\n/// Note: N must be a multiple of 31 bytes\npub fn bytes_to_fields<let N: u32>(bytes: [u8; N]) -> [Field; N / 31] {\n    // Assert that N is a multiple of 31\n    static_assert(N % 31 == 0, \"N must be a multiple of 31\");\n\n    let mut fields = [0; N / 31];\n\n    // Since N is a multiple of 31, we can simply process all chunks fully\n    for i in 0..N / 31 {\n        let mut field = 0;\n        for j in 0..31 {\n            // Shift the existing value left by 8 bits and add the new byte\n            field = field * 256 + bytes[i * 31 + j] as Field;\n        }\n        fields[i] = field;\n    }\n\n    fields\n}\n\n/// Converts an input BoundedVec of fields into a BoundedVec of bytes in big-endian order. Arbitrary Field arrays\n/// are not allowed: this is assumed to be an array obtained via `bytes_to_fields`, i.e. one that actually represents\n/// bytes. To convert a Field array into bytes, use `fields_to_bytes`.\n///\n/// Each input field must contain at most 31 bytes (this is constrained to be so).\n/// Each field is converted into 31 big-endian bytes, and the resulting 31-byte chunks are concatenated\n/// back together in the order of the original fields.\npub fn bytes_from_fields<let N: u32>(fields: BoundedVec<Field, N>) -> BoundedVec<u8, N * 31> {\n    let mut bytes = BoundedVec::new();\n\n    for i in 0..fields.len() {\n        let field = fields.get(i);\n\n        // We expect that the field contains at most 31 bytes of information.\n        field.assert_max_bit_size::<248>();\n\n        // Now we can safely convert the field to 31 bytes.\n        let field_as_bytes: [u8; 31] = field.to_be_bytes();\n\n        for j in 0..31 {\n            bytes.push(field_as_bytes[j]);\n        }\n    }\n\n    bytes\n}\n\nmod tests {\n    use crate::utils::array::subarray;\n    use super::{bytes_from_fields, bytes_to_fields};\n\n    #[test]\n    unconstrained fn random_bytes_to_fields_and_back(input: [u8; 93]) {\n        let fields = bytes_to_fields(input);\n\n        // At this point in production, the log flies through the system and we get a BoundedVec on the other end.\n        // So we need to convert the field array to a BoundedVec to be able to feed it to the `bytes_from_fields`\n        // function.\n        let fields_as_bounded_vec = BoundedVec::<_, 6>::from_array(fields);\n\n        let bytes_back = bytes_from_fields(fields_as_bounded_vec);\n\n        // Compare the original input with the round-tripped result\n        assert_eq(bytes_back.len(), input.len());\n        assert_eq(subarray(bytes_back.storage(), 0), input);\n    }\n\n    #[test(should_fail_with = \"N must be a multiple of 31\")]\n    unconstrained fn bytes_to_fields_input_length_not_multiple_of_31() {\n        // Try to convert 32 bytes (not a multiple of 31) to fields\n        let _fields = bytes_to_fields([0; 32]);\n    }\n\n}\n"
     },
-    "195": {
+    "208": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/conversion/fields_to_bytes.nr",
       "source": "// These functions are used to facilitate the conversion of log plaintext represented as fields into bytes and back.\n//\n// `fields_to_bytes` uses fixed-size arrays since encryption contexts have compile-time size information.\n// `fields_from_bytes` uses BoundedVec for flexibility in unconstrained contexts where sizes are dynamic.\n//\n// Together they provide bidirectional conversion between fields and bytes.\n\n/// Converts an input array of fields into a single array of bytes. Use `fields_from_bytes` to obtain the original\n/// field array.\n/// Each field is converted to a 32-byte big-endian array.\n///\n/// For example, if you have a field array [123, 456], it will be converted to a 64-byte array:\n/// [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,123,  // First field (32 bytes)\n///  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,200]  // Second field (32 bytes)\n///\n/// Since a field is ~254 bits, you'll end up with a subtle 2-bit \"gap\" at the big end, every 32 bytes. Be careful\n/// that such a gap doesn't leak information! This could happen if you for example expected the output to be\n/// indistinguishable from random bytes.\npub fn fields_to_bytes<let N: u32>(fields: [Field; N]) -> [u8; 32 * N] {\n    let mut bytes = [0; 32 * N];\n\n    for i in 0..N {\n        let field_as_bytes: [u8; 32] = fields[i].to_be_bytes();\n\n        for j in 0..32 {\n            bytes[i * 32 + j] = field_as_bytes[j];\n        }\n    }\n\n    bytes\n}\n\n/// Converts an input BoundedVec of bytes into a BoundedVec of fields. Arbitrary byte arrays are not allowed: this\n/// is assumed to be an array obtained via `fields_to_bytes`, i.e. one that actually represents fields. To convert\n/// a byte array into Fields, use `bytes_to_fields`.\n///\n/// The input bytes are chunked into chunks of 32 bytes. Each 32-byte chunk is viewed as big-endian, and is converted\n/// into a Field.\n/// For example, [1, 10, 3, ..., 0] (32 bytes) is encoded as [1 * 256^31 + 10 * 256^30 + 3 * 256^29 + ... + 0]\n/// Note 1: N must be a multiple of 32 bytes\n/// Note 2: The max value check code was taken from std::field::to_be_bytes function.\npub fn fields_from_bytes<let N: u32>(bytes: BoundedVec<u8, N>) -> BoundedVec<Field, N / 32> {\n    // Assert that input length is a multiple of 32\n    assert(bytes.len() % 32 == 0, \"Input length must be a multiple of 32\");\n\n    let mut fields = BoundedVec::new();\n\n    let p = std::field::modulus_be_bytes();\n\n    // Since input length is a multiple of 32, we can simply process all chunks fully\n    for i in 0..bytes.len() / 32 {\n        let mut field = 0;\n\n        // Process each byte in the 32-byte chunk\n        let mut ok = false;\n\n        for j in 0..32 {\n            let next_byte = bytes.get(i * 32 + j);\n            field = field * 256 + next_byte as Field;\n\n            if !ok {\n                if next_byte != p[j] {\n                    assert(next_byte < p[j], \"Value does not fit in field\");\n                    ok = true;\n                }\n            }\n        }\n        assert(ok, \"Value does not fit in field\");\n\n        fields.push(field);\n    }\n\n    fields\n}\n\nmod tests {\n    use crate::utils::array::subarray;\n    use super::{fields_from_bytes, fields_to_bytes};\n\n    #[test]\n    unconstrained fn random_fields_to_bytes_and_back(input: [Field; 3]) {\n        // Convert to bytes\n        let bytes = fields_to_bytes(input);\n\n        // At this point in production, the log flies through the system and we get a BoundedVec on the other end.\n        // So we need to convert the field array to a BoundedVec to be able to feed it to the `fields_from_bytes`\n        // function.\n        // 113 is an arbitrary max length that is larger than the input length of 96.\n        let bytes_as_bounded_vec = BoundedVec::<_, 113>::from_array(bytes);\n\n        // Convert back to fields\n        let fields_back = fields_from_bytes(bytes_as_bounded_vec);\n\n        // Compare the original input with the round-tripped result\n        assert_eq(fields_back.len(), input.len());\n        assert_eq(subarray(fields_back.storage(), 0), input);\n    }\n\n    #[test(should_fail_with = \"Input length must be a multiple of 32\")]\n    unconstrained fn to_fields_assert() {\n        // 143 is an arbitrary max length that is larger than 33\n        let input = BoundedVec::<_, 143>::from_array([\n            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n            25, 26, 27, 28, 29, 30, 31, 32, 33,\n        ]);\n\n        // This should fail since 33 is not a multiple of 32\n        let _fields = fields_from_bytes(input);\n    }\n\n    #[test]\n    unconstrained fn fields_from_bytes_max_value() {\n        let max_field_as_bytes: [u8; 32] = (-1).to_be_bytes();\n        let input = BoundedVec::<_, 32>::from_array(max_field_as_bytes);\n\n        let fields = fields_from_bytes(input);\n\n        // The result should be a largest value storable in a field (-1 since we are modulo-ing)\n        assert_eq(fields.get(0), -1);\n    }\n\n    // In this test we verify that overflow check works by taking the max allowed value, bumping a random byte\n    // and then feeding it to `fields_from_bytes` as input.\n    #[test(should_fail_with = \"Value does not fit in field\")]\n    unconstrained fn fields_from_bytes_overflow(random_value: u8) {\n        let index_of_byte_to_bump = random_value % 32;\n\n        // Obtain the byte representation of the maximum field value\n        let max_field_value_as_bytes: [u8; 32] = (-1).to_be_bytes();\n\n        let byte_to_bump = max_field_value_as_bytes[index_of_byte_to_bump as u32];\n\n        // Skip test execution if the selected byte is already at maximum value (255).\n        // This is acceptable since we are using fuzz testing to generate many test cases.\n        if byte_to_bump != 255 {\n            let mut input = BoundedVec::<_, 32>::from_array(max_field_value_as_bytes);\n\n            // Increment the selected byte to exceed the field's maximum value\n            input.set(index_of_byte_to_bump as u32, byte_to_bump + 1);\n\n            // Attempt the conversion, which should fail due to the value exceeding the field's capacity\n            let _fields = fields_from_bytes(input);\n        }\n    }\n\n}\n"
     },
-    "197": {
+    "210": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/field.nr",
       "source": "use std::option::Option;\n\nglobal KNOWN_NON_RESIDUE: Field = 5; // This is a non-residue in Noir's native Field.\n\nglobal C1: u32 = 28;\nglobal C3: Field = 40770029410420498293352137776570907027550720424234931066070132305055;\nglobal C5: Field = 19103219067921713944291392827692070036145651957329286315305642004821462161904;\n\n// Power function of two Field arguments of arbitrary size.\n// Adapted from std::field::pow_32.\npub fn pow(x: Field, y: Field) -> Field {\n    let mut r = 1 as Field;\n    let b: [u1; 254] = y.to_le_bits();\n\n    for i in 0..254 {\n        r *= r;\n        r *= (b[254 - 1 - i] as Field) * x + (1 - b[254 - 1 - i] as Field);\n    }\n\n    r\n}\n\n// Boolean indicating whether Field element is a square, i.e. whether there exists a y in Field s.t. x = y*y.\nunconstrained fn is_square(x: Field) -> bool {\n    let v = pow(x, -1 / 2);\n    v * (v - 1) == 0\n}\n\n// Tonelli-Shanks algorithm for computing the square root of a Field element.\n// Requires C1 = max{c: 2^c divides (p-1)}, where p is the order of Field\n// as well as C3 = (C2 - 1)/2, where C2 = (p-1)/(2^c1),\n// and C5 = ZETA^C2, where ZETA is a non-square element of Field.\n// These are pre-computed above as globals.\nunconstrained fn tonelli_shanks_sqrt(x: Field) -> Field {\n    let mut z = pow(x, C3);\n    let mut t = z * z * x;\n    z *= x;\n    let mut b = t;\n    let mut c = C5;\n\n    for i in 0..(C1 - 1) {\n        for _j in 1..(C1 - i - 1) {\n            b *= b;\n        }\n\n        z *= if b == 1 { 1 } else { c };\n\n        c *= c;\n\n        t *= if b == 1 { 1 } else { c };\n\n        b = t;\n    }\n\n    z\n}\n\n// NB: this doesn't return an option, because in the case of there _not_ being a square root, we still want to return a field element that allows us to then assert in the _constrained_ sqrt function that there is no sqrt.\npub unconstrained fn __sqrt(x: Field) -> (bool, Field) {\n    let is_sq = is_square(x);\n    if is_sq {\n        let sqrt = tonelli_shanks_sqrt(x);\n        (true, sqrt)\n    } else {\n        // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n        // Facts:\n        // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n        // - If x is a square, LS(x) = 1\n        // - If x is not a square, LS(x) = -1\n        // - If x = 0, LS(x) = 0.\n        //\n        // Hence:\n        // sq * sq = sq // 1 * 1 = 1\n        // non-sq * non-sq = sq // -1 * -1 = 1\n        // sq * non-sq = non-sq // -1 * 1 = -1\n        //\n        // See: https://en.wikipedia.org/wiki/Legendre_symbol\n        let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n        let not_sqrt = tonelli_shanks_sqrt(demo_x_not_square);\n        (false, not_sqrt)\n    }\n}\n\n// Returns (false, 0) if there is no square root.\n// Returns (true, sqrt) if there is a square root.\npub fn sqrt(x: Field) -> Option<Field> {\n    // Safety: if the hint returns the square root of x, then we simply square it\n    // check the result equals x. If x is not square, we return a value that\n    // enables us to prove that fact (see the `else` clause below).\n    let (is_sq, maybe_sqrt) = unsafe { __sqrt(x) };\n\n    if is_sq {\n        let sqrt = maybe_sqrt;\n        validate_sqrt_hint(x, sqrt);\n        Option::some(sqrt)\n    } else {\n        let not_sqrt_hint = maybe_sqrt;\n        validate_not_sqrt_hint(x, not_sqrt_hint);\n        Option::none()\n    }\n}\n\nfn validate_sqrt_hint(x: Field, hint: Field) {\n    assert(hint * hint == x, f\"The claimed_sqrt {hint} is not the sqrt of x {x}\");\n}\n\nfn validate_not_sqrt_hint(x: Field, hint: Field) {\n    // We need this assertion, because x = 0 would pass the other assertions in this\n    // function, and we don't want people to be able to prove that 0 is not square!\n    assert(x != 0, \"0 has a square root; you cannot claim it is not square\");\n    // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n    //\n    // Facts:\n    // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n    // - If x is a square, LS(x) = 1\n    // - If x is not a square, LS(x) = -1\n    // - If x = 0, LS(x) = 0.\n    //\n    // Hence:\n    // 1. sq * sq = sq // 1 * 1 = 1\n    // 2. non-sq * non-sq = sq // -1 * -1 = 1\n    // 3. sq * non-sq = non-sq // -1 * 1 = -1\n    //\n    // See: https://en.wikipedia.org/wiki/Legendre_symbol\n    //\n    // We want to demonstrate that this below multiplication falls under bullet-point (2):\n    let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n    // I.e. we want to demonstrate that `demo_x_not_square` has Legendre symbol 1\n    // (i.e. that it is a square), so we prove that it is square below.\n    // Why do we want to prove that it has LS 1?\n    // Well, since it was computed with a known-non-residue, its squareness implies we're\n    // in case 2 (something multiplied by a known-non-residue yielding a result which\n    // has a LS of 1), which implies that x must be a non-square. The unconstrained\n    // function gave us the sqrt of demo_x_not_square, so all we need to do is\n    // assert its squareness:\n    assert(\n        hint * hint == demo_x_not_square,\n        f\"The hint {hint} does not demonstrate that {x} is not a square\",\n    );\n}\n\n#[test]\nfn test_sqrt() {\n    let x = 9;\n    let maybe_sqrt = sqrt(x);\n    assert(maybe_sqrt.is_some());\n    let sqrt = maybe_sqrt.unwrap_unchecked();\n    assert((sqrt == 3) | (sqrt == -3));\n}\n\n#[test]\nfn test_non_square() {\n    let x = 5;\n    let maybe_sqrt = sqrt(x);\n    assert(maybe_sqrt.is_none());\n}\n\n#[test]\nunconstrained fn test_known_non_residue_is_actually_a_non_residue_in_the_field() {\n    assert(!is_square(KNOWN_NON_RESIDUE));\n}\n\n#[test]\nfn test_sqrt_0() {\n    let x = 0;\n    let sqrt = sqrt(x).unwrap();\n    assert(sqrt == 0);\n}\n\n#[test]\nfn test_sqrt_1() {\n    let x = 1;\n    let sqrt = sqrt(x).unwrap();\n    assert((sqrt == 1) | (sqrt == -1));\n}\n\n#[test(should_fail_with = \"The claimed_sqrt 0x04 is not the sqrt of x 0x09\")]\nfn test_bad_sqrt_hint_fails() {\n    validate_sqrt_hint(9, 4);\n}\n\n#[test(should_fail_with = \"The hint 0x04 does not demonstrate that 0x0a is not a square\")]\nfn test_bad_not_sqrt_hint_fails() {\n    validate_not_sqrt_hint(10, 4);\n}\n\n#[test(should_fail_with = \"0 has a square root; you cannot claim it is not square\")]\nfn test_0_not_sqrt_hint_fails() {\n    validate_not_sqrt_hint(0, 0);\n}\n\n#[test]\nunconstrained fn test_is_square() {\n    assert(is_square(25));\n}\n\n#[test]\nunconstrained fn test_is_not_square() {\n    assert(!is_square(10));\n}\n"
     },
-    "199": {
+    "212": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/point.nr",
       "source": "use crate::utils::field::sqrt;\nuse dep::protocol_types::point::Point;\n\n// I am storing the modulus minus 1 divided by 2 here because full modulus would throw \"String literal too large\" error\n// Full modulus is 21888242871839275222246405745257275088548364400416034343698204186575808495617\nglobal BN254_FR_MODULUS_DIV_2: Field =\n    10944121435919637611123202872628637544274182200208017171849102093287904247808;\n\n/// Converts a point to a byte array.\n///\n/// We don't serialize the point at infinity flag because this function is used in situations where we do not want\n/// to waste the extra byte (encrypted log).\npub fn point_to_bytes(p: Point) -> [u8; 32] {\n    // Note that there is 1 more free bit in the 32 bytes (254 bits currently occupied by the x coordinate, 1 bit for\n    // the \"sign\") so it's possible to use that last bit as an \"is_infinite\" flag if desired in the future.\n    assert(!p.is_infinite, \"Cannot serialize point at infinity as bytes.\");\n\n    let mut result: [u8; 32] = p.x.to_be_bytes();\n\n    if get_sign_of_point(p) {\n        // y is <= (modulus - 1) / 2 so we set the sign bit to 1\n        // Here we leverage that field fits into 254 bits (log2(Fr.MODULUS) < 254) and given that we serialize Fr to 32\n        // bytes and we use big-endian the 2 most significant bits are never populated. Hence we can use one of\n        // the bits as a sign bit.\n        result[0] += 128;\n    }\n\n    result\n}\n\n/**\n * Returns: true if p.y <= MOD_DIV_2, else false.\n */\npub fn get_sign_of_point(p: Point) -> bool {\n    // We store only a \"sign\" of the y coordinate because the rest can be derived from the x coordinate. To get\n    // the sign we check if the y coordinate is less or equal than the curve's order minus 1 divided by 2.\n    // Ideally we'd do `y <= MOD_DIV_2`, but there's no `lte` function, so instead we do `!(y > MOD_DIV_2)`, which is\n    // equivalent, and then rewrite that as `!(MOD_DIV_2 < y)`, since we also have no `gt` function.\n    !BN254_FR_MODULUS_DIV_2.lt(p.y)\n}\n\npub fn point_from_x_coord(x: Field) -> Point {\n    // y ^ 2 = x ^ 3 - 17\n    let rhs = x * x * x - 17;\n    let y = sqrt(rhs).unwrap();\n    Point { x, y, is_infinite: false }\n}\n\n/// Uses the x coordinate and sign flag (+/-) to reconstruct the point.\n/// The y coordinate can be derived from the x coordinate and the \"sign\" flag by solving the grumpkin curve\n/// equation for y.\n/// @param x - The x coordinate of the point\n/// @param sign - The \"sign\" of the y coordinate - determines whether y <= (Fr.MODULUS - 1) / 2\npub fn point_from_x_coord_and_sign(x: Field, sign: bool) -> Point {\n    // y ^ 2 = x ^ 3 - 17\n    let rhs = x * x * x - 17;\n    let y = sqrt(rhs).unwrap();\n\n    // If y > MOD_DIV_2 and we want positive sign (or vice versa), negate y\n    let y_is_positive = !BN254_FR_MODULUS_DIV_2.lt(y);\n    let final_y = if y_is_positive == sign { y } else { -y };\n\n    Point { x, y: final_y, is_infinite: false }\n}\n\nmod test {\n    use crate::utils::point::{point_from_x_coord_and_sign, point_to_bytes};\n    use dep::protocol_types::point::Point;\n\n    #[test]\n    unconstrained fn test_point_to_bytes_positive_sign() {\n        let p = Point {\n            x: 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73,\n            y: 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a,\n            is_infinite: false,\n        };\n\n        let compressed_point = point_to_bytes(p);\n\n        let expected_compressed_point_positive_sign = [\n            154, 244, 31, 93, 233, 100, 70, 220, 55, 118, 161, 235, 45, 152, 187, 149, 107, 122,\n            205, 153, 121, 166, 120, 84, 190, 198, 250, 124, 41, 115, 189, 115,\n        ];\n        assert_eq(expected_compressed_point_positive_sign, compressed_point);\n    }\n\n    #[test]\n    unconstrained fn test_point_to_bytes_negative_sign() {\n        let p = Point {\n            x: 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5,\n            y: 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0,\n            is_infinite: false,\n        };\n\n        let compressed_point = point_to_bytes(p);\n\n        let expected_compressed_point_negative_sign = [\n            36, 115, 113, 101, 46, 85, 221, 116, 201, 175, 141, 190, 159, 180, 73, 49, 186, 41, 169,\n            34, 153, 148, 56, 75, 215, 7, 119, 150, 193, 78, 226, 181,\n        ];\n\n        assert_eq(expected_compressed_point_negative_sign, compressed_point);\n    }\n\n    #[test]\n    unconstrained fn test_point_from_x_coord_and_sign() {\n        // Test positive y coordinate\n        let x = 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73;\n        let sign = true;\n        let p = point_from_x_coord_and_sign(x, sign);\n\n        assert_eq(p.x, x);\n        assert_eq(p.y, 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a);\n        assert_eq(p.is_infinite, false);\n\n        // Test negative y coordinate\n        let x2 = 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5;\n        let sign2 = false;\n        let p2 = point_from_x_coord_and_sign(x2, sign2);\n\n        assert_eq(p2.x, x2);\n        assert_eq(p2.y, 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0);\n        assert_eq(p2.is_infinite, false);\n    }\n}\n"
     },
-    "211": {
+    "224": {
       "path": "/home/aztec-dev/nargo/github.com/noir-lang/poseidon/v0.1.1/src/poseidon2.nr",
       "source": "use std::default::Default;\nuse std::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = crate::poseidon2_permutation(self.state, 4);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: &[] }\n    }\n}\n"
     },
-    "228": {
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/abis/event_selector.nr",
-      "source": "use crate::traits::{Deserialize, Empty, FromField, Serialize, ToField};\n\npub struct EventSelector {\n    // 1st 4-bytes (big-endian leftmost) of abi-encoding of an event.\n    // TODO(#2707): Consider making this a u64 as we already cast this to that when encoding the message. This would decrease\n    // the likelihood of collisions without any extra cost.\n    inner: u32,\n}\n\nimpl Eq for EventSelector {\n    fn eq(self, other: EventSelector) -> bool {\n        other.inner == self.inner\n    }\n}\n\nimpl Serialize<1> for EventSelector {\n    fn serialize(self: Self) -> [Field; 1] {\n        [self.inner as Field]\n    }\n}\n\nimpl Deserialize<1> for EventSelector {\n    fn deserialize(fields: [Field; 1]) -> Self {\n        Self { inner: fields[0] as u32 }\n    }\n}\n\nimpl FromField for EventSelector {\n    fn from_field(field: Field) -> Self {\n        Self { inner: field as u32 }\n    }\n}\n\nimpl ToField for EventSelector {\n    fn to_field(self) -> Field {\n        self.inner as Field\n    }\n}\n\nimpl Empty for EventSelector {\n    fn empty() -> Self {\n        Self { inner: 0 as u32 }\n    }\n}\n\nimpl EventSelector {\n    pub fn from_u32(value: u32) -> Self {\n        Self { inner: value }\n    }\n\n    pub fn from_signature<let N: u32>(signature: str<N>) -> Self {\n        let bytes = signature.as_bytes();\n        let hash = crate::hash::poseidon2_hash_bytes(bytes);\n\n        // `hash` is automatically truncated to fit within 32 bits.\n        EventSelector::from_field(hash)\n    }\n\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n}\n"
-    },
-    "290": {
+    "302": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
       "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n///   debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n///   debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n///   debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper<let M: u32, let N: u32>(\n    msg: str<M>,\n    args: [Field; N],\n) {\n    debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle<let M: u32>(_msg: str<M>, args: [Field]) {}\n"
     },
-    "291": {
+    "303": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
-      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{OrderedValue, scoped::Scoped},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE,\n        GENERATOR_INDEX__OUTER_NULLIFIER, GENERATOR_INDEX__SILOED_NOTE_HASH,\n        GENERATOR_INDEX__UNIQUE_NOTE_HASH, TWO_POW_64,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, ToField},\n    utils::{arrays::array_concat, field::{field_from_bytes, field_from_bytes_32_trunc}},\n};\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(note_nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [note_nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_nonce_and_unique_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    let note_nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    compute_unique_note_hash(note_nonce, siloed_note_hash)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        compute_nonce_and_unique_note_hash(siloed_note_hash, first_nullifier, note_index_in_tx)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog::new(fields, private_log.inner.log.length)\n    }\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n    poseidon2_hash(log)\n}\n\npub fn compute_app_secret_key(\n    master_secret_key: EmbeddedCurveScalar,\n    app_address: AztecAddress,\n    app_secret_generator: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n        app_secret_generator,\n    )\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let contract_address_bytes: [u8; 32] = contract_address.to_field().to_be_bytes();\n    let recipient_bytes: [u8; 20] = recipient.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n    let mut bytes: [u8; 148] = std::mem::zeroed();\n    for i in 0..32 {\n        bytes[i] = contract_address_bytes[i];\n        bytes[i + 32] = rollup_version_id_bytes[i];\n        // 64 - 84 are for recipient.\n        bytes[i + 84] = chain_id_bytes[i];\n        bytes[i + 116] = content_bytes[i];\n    }\n\n    for i in 0..20 {\n        bytes[64 + i] = recipient_bytes[i];\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: Scoped<L2ToL1Message>,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.inner.recipient,\n            msg.inner.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a u128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as poseidon::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n// This function is  unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n    inputs: BoundedVec<Field, N>,\n    separator: T,\n) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs.get(i));\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0x3b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0xaab2a5828156782b12a1dc6f336e2bc627eb1b9514b02d511f66296990c050);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n            AztecAddress::from_field(3),\n        ),\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let hash_from_typescript = 0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n    assert_eq(hash, hash_from_typescript);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n    let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n    let separator = 42;\n\n    // Hash using bounded vec version\n    let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n    // Hash using regular version\n    let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n    // Results should match\n    assert_eq(bounded_result, regular_result);\n}\n"
+      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{OrderedValue, scoped::Scoped},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE,\n        GENERATOR_INDEX__OUTER_NULLIFIER, GENERATOR_INDEX__SILOED_NOTE_HASH,\n        GENERATOR_INDEX__UNIQUE_NOTE_HASH, TWO_POW_64,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, ToField},\n    utils::{arrays::array_concat, field::{field_from_bytes, field_from_bytes_32_trunc}},\n};\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(note_nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [note_nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_nonce_and_unique_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    let note_nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    compute_unique_note_hash(note_nonce, siloed_note_hash)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        compute_nonce_and_unique_note_hash(siloed_note_hash, first_nullifier, note_index_in_tx)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog::new(fields, private_log.inner.log.length)\n    }\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n    poseidon2_hash(log)\n}\n\npub fn compute_app_secret_key(\n    master_secret_key: EmbeddedCurveScalar,\n    app_address: AztecAddress,\n    app_secret_generator: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n        app_secret_generator,\n    )\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let contract_address_bytes: [u8; 32] = contract_address.to_field().to_be_bytes();\n    let recipient_bytes: [u8; 20] = recipient.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n    let mut bytes: [u8; 148] = std::mem::zeroed();\n    for i in 0..32 {\n        bytes[i] = contract_address_bytes[i];\n        bytes[i + 32] = rollup_version_id_bytes[i];\n        // 64 - 84 are for recipient.\n        bytes[i + 84] = chain_id_bytes[i];\n        bytes[i + 116] = content_bytes[i];\n    }\n\n    for i in 0..20 {\n        bytes[64 + i] = recipient_bytes[i];\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: Scoped<L2ToL1Message>,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.inner.recipient,\n            msg.inner.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a u128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as poseidon::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n// This function is  unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n    inputs: BoundedVec<Field, N>,\n    separator: T,\n) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs.get(i));\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0x3b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0xaab2a5828156782b12a1dc6f336e2bc627eb1b9514b02d511f66296990c050);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n            AztecAddress::from_field(3),\n        ),\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let hash_from_typescript = 0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n    assert_eq(hash, hash_from_typescript);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n    let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n    let separator = 42;\n\n    // Hash using bounded vec version\n    let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n    // Hash using regular version\n    let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n    // Results should match\n    assert_eq(bounded_result, regular_result);\n}\n"
     },
-    "305": {
+    "317": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/meta/mod.nr",
       "source": "use super::traits::{Deserialize, Packable, Serialize};\n\n/// Returns the typed expression of a trait method implementation.\n///\n/// This helper function is preferred over directly inlining with `$typ::target_method()` in a quote,\n/// as direct inlining would result in missing import warnings in the generated code (specifically,\n/// warnings that the trait implementation is not in scope).\n///\n/// # Note\n/// A copy of this function exists in `aztec-nr/aztec/src/macros/utils.nr`. We maintain separate copies\n/// because importing it there from here would cause the `target_trait` to be interpreted in the context\n/// of this crate, making it impossible to compile code for traits from that crate (e.g. NoteType).\ncomptime fn get_trait_impl_method(\n    typ: Type,\n    target_trait: Quoted,\n    target_method: Quoted,\n) -> TypedExpr {\n    let trait_constraint = target_trait.as_trait_constraint();\n    typ\n        .get_trait_impl(trait_constraint)\n        .expect(f\"Could not find impl for {target_trait} for type {typ}\")\n        .methods()\n        .filter(|m| m.name() == target_method)[0]\n        .as_typed_expr()\n}\n\n/// Generates code that deserializes a struct, primitive type, array or string from a field array.\n///\n/// # Parameters\n/// - `name`: The name of the current field being processed, used to identify fields for replacement.\n/// - `typ`: The type of the struct or field being deserialized (e.g., a custom struct, array, or primitive).\n/// - `field_array_name`: The name of the field array containing serialized field data (e.g., `\"values\"`).\n/// - `num_already_consumed`: The number of fields already processed in previous recursion calls.\n/// - `should_unpack`: A boolean indicating whether the type should be unpacked (see description of `Packable`\n/// and `Serialize` trait for more information about the difference between packing and serialization).\n///\n/// # Returns\n/// A tuple containing:\n/// - `Quoted`: A code that deserializes a given struct, primitive type, array, or string from the field array.\n/// - `u32`: The total number of fields consumed during deserialization (used for recursion).\n///\n/// # Nested Struct Example\n/// Given the following setup:\n/// ```\n/// struct UintNote {\n///     value: u128,\n///     owner: AztecAddress,\n///     randomness: Field,\n/// }\n///\n/// struct AztecAddress {\n///     inner: Field,\n/// }\n/// ```\n///\n/// If `UintNote` is the input type, the function will generate the following deserialization code:\n/// ```\n/// UintNote {\n///     value: fields[0] as u128,\n///     owner: AztecAddress {\n///         inner: fields[1],\n///     },\n///     randomness: fields[2],\n/// }\n/// ```\n/// # Nested Struct Example with Unpacking\n/// - given the same setup as above and given that u128, AztecAddress and Field implement the `Packable` trait\n///   the result we get is:\n/// ```\n/// UintNote {\n///     value: aztec::protocol_types::traits::Packable::unpack([fields[0]]),\n///     owner: aztec::protocol_types::traits::Packable::unpack([fields[1]]),\n///     randomness: aztec::protocol_types::traits::Packable::unpack([fields[2]]),\n/// }\n/// ```\n///\n/// # Panics\n/// - If the deserialization logic encounters a type it does not support.\n/// - If an incorrect number of fields are consumed when deserializing a string.\npub comptime fn generate_deserialize_from_fields(\n    name: Quoted,\n    typ: Type,\n    field_array_name: Quoted,\n    num_already_consumed: u32,\n    should_unpack: bool,\n) -> (Quoted, u32) {\n    let mut result = quote {};\n    // Counter for the number of fields consumed\n    let mut consumed_counter: u32 = 0;\n\n    // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n    let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n    let packable_constraint = quote { Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n    if (should_unpack & typ.implements(packable_constraint)) {\n        // Unpacking is enabled and the given type implements the `Packable` trait so we call the `unpack()`\n        // method, add the resulting field array to `aux_vars` and each field to `fields`.\n        let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n        // We copy the packed fields into a new array and pass that to the unpack function in a quote\n        let mut packed_fields_quotes = &[];\n        for i in 0..packed_len {\n            let index_in_field_array = i + num_already_consumed;\n            packed_fields_quotes =\n                packed_fields_quotes.push_back(quote { $field_array_name[$index_in_field_array] });\n        }\n        let packed_fields = packed_fields_quotes.join(quote {,});\n\n        // Now we call unpack on the type\n        let unpack_method = get_trait_impl_method(typ, quote { Packable<_> }, quote { unpack });\n        result = quote { $unpack_method([ $packed_fields ]) };\n\n        consumed_counter = packed_len;\n    } else if typ.is_bool() {\n        // The field is a primitive so we just reference it in the field array\n        result = quote { $field_array_name[$num_already_consumed] != 0 };\n        consumed_counter = 1;\n    } else if typ.is_field() | typ.as_integer().is_some() {\n        // The field is a primitive so we just reference it in the field array\n        result = quote { $field_array_name[$num_already_consumed] as $typ };\n        consumed_counter = 1;\n    } else if typ.as_data_type().is_some() {\n        // The field is a struct so we iterate over each struct field and recursively call\n        // `generate_deserialize_from_fields`\n        let (nested_def, generics) = typ.as_data_type().unwrap();\n        let nested_name = nested_def.name();\n        let mut deserialized_fields_list = &[];\n\n        // Iterate over each field in the struct\n        for field in nested_def.fields(generics) {\n            let (field_name, field_type, _) = field;\n            // Recursively call `generate_deserialize_from_fields` for each field in the struct\n            let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n                field_name,\n                field_type,\n                field_array_name,\n                consumed_counter + num_already_consumed,\n                should_unpack,\n            );\n            // We increment the consumed counter by the number of fields consumed in the recursion\n            consumed_counter += num_consumed_in_recursion;\n            // We add the deserialized field to the list of deserialized fields.\n            // E.g. `value: u128 { lo: fields[0], hi: fields[1] }`\n            deserialized_fields_list =\n                deserialized_fields_list.push_back(quote { $field_name: $deserialized_field });\n        }\n\n        // We can construct the struct from the deserialized fields\n        let deserialized_fields = deserialized_fields_list.join(quote {,});\n        result = quote {\n                $nested_name {\n                    $deserialized_fields\n                }\n            };\n    } else if typ.as_array().is_some() {\n        // The field is an array so we iterate over each element and recursively call\n        // `generate_deserialize_from_fields`\n        let (element_type, array_len) = typ.as_array().unwrap();\n        let array_len = array_len.as_constant().unwrap();\n        let mut array_fields_list = &[];\n\n        // Iterate over each element in the array\n        for _ in 0..array_len {\n            // Recursively call `generate_deserialize_from_fields` for each element in the array\n            let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n                name,\n                element_type,\n                field_array_name,\n                consumed_counter + num_already_consumed,\n                should_unpack,\n            );\n            // We increment the consumed counter by the number of fields consumed in the recursion\n            consumed_counter += num_consumed_in_recursion;\n            // We add the deserialized field to the list of deserialized fields.\n            array_fields_list = array_fields_list.push_back(deserialized_field);\n        }\n\n        // We can construct the array from the deserialized fields\n        let array_fields = array_fields_list.join(quote {,});\n        result = quote { [ $array_fields ] };\n    } else if typ.as_str().is_some() {\n        // The field is a string and we expect each byte of the string to be represented as 1 field in the field\n        // array. So we iterate over the string length and deserialize each character as u8 in the recursive call\n        // to `generate_deserialize_from_fields`.\n        let length_type = typ.as_str().unwrap();\n        let str_len = length_type.as_constant().unwrap();\n        let mut byte_list = &[];\n\n        // Iterate over each character in the string\n        for _ in 0..str_len {\n            // Recursively call `generate_deserialize_from_fields` for each character in the string\n            let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n                name,\n                quote {u8}.as_type(),\n                field_array_name,\n                consumed_counter + num_already_consumed,\n                should_unpack,\n            );\n\n            // We should consume just one field in the recursion so we sanity check that\n            assert_eq(\n                num_consumed_in_recursion,\n                1,\n                \"Incorrect number of fields consumed in string deserialization\",\n            );\n\n            // We increment the consumed counter by 1 as we have consumed one field\n            consumed_counter += 1;\n\n            // We add the deserialized field to the list of deserialized fields.\n            // E.g. `fields[6] as u8`\n            byte_list = byte_list.push_back(deserialized_field);\n        }\n\n        // We construct the string from the deserialized fields\n        let bytes = byte_list.join(quote {,});\n        result = quote { [ $bytes ].as_str_unchecked() };\n    } else {\n        panic(\n            f\"Unsupported type for serialization of argument {name} and type {typ}\",\n        )\n    }\n\n    (result, consumed_counter)\n}\n\n/// Generates code that serializes a type into an array of fields. Also generates auxiliary variables if necessary\n/// for serialization. If `should_pack` is true, we check if the type implements the `Packable` trait and pack it\n/// if it does.\n///\n/// # Parameters\n/// - `name`: The base identifier (e.g., `self`, `some_var`).\n/// - `typ`: The type being serialized (e.g., a custom struct, array, or primitive type).\n/// - `should_pack`: A boolean indicating whether the type should be packed.\n///\n/// # Returns\n/// A tuple containing:\n/// - A flattened array of `Quoted` field references representing the serialized fields.\n/// - An array of `Quoted` auxiliary variables needed for serialization, such as byte arrays for strings.\n///\n/// # Examples\n///\n/// ## Struct\n/// Given the following struct:\n/// ```rust\n/// struct MockStruct {\n///     a: Field,\n///     b: Field,\n/// }\n/// ```\n///\n/// Serializing the struct:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_mock_struct }, MockStruct, false)\n/// // Returns:\n/// // ([`my_mock_struct.a`, `my_mock_struct.b`], [])\n/// ```\n///\n/// ## Nested Struct\n/// For a more complex struct:\n/// ```rust\n/// struct NestedStruct {\n///     m1: MockStruct,\n///     m2: MockStruct,\n/// }\n/// ```\n///\n/// Serialization output:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, NestedStruct, false)\n/// // Returns:\n/// // ([`self.m1.a`, `self.m1.b`, `self.m2.a`, `self.m2.b`], [])\n/// ```\n///\n/// ## Array\n/// For an array type:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_array }, [Field; 3], false)\n/// // Returns:\n/// // ([`my_array[0]`, `my_array[1]`, `my_array[2]`], [])\n/// ```\n///\n/// ## String\n/// For a string field, where each character is serialized as a `Field`:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_string }, StringType, false)\n/// // Returns:\n/// // ([`my_string_as_bytes[0] as Field`, `my_string_as_bytes[1] as Field`, ...],\n/// // [`let my_string_as_bytes = my_string.as_bytes()`])\n/// ```\n///\n/// ## Nested Struct with packing enabled\n/// - u128 has a `Packable` implementation hence it will be packed.\n///\n/// For a more complex struct:\n/// ```rust\n/// struct MyStruct {\n///     value: u128,\n///     value2: Field,\n/// }\n/// ```\n///\n/// # Panics\n/// - If the type is unsupported for serialization.\n/// - If the provided `typ` contains invalid constants or incompatible structures.\npub comptime fn generate_serialize_to_fields(\n    name: Quoted,\n    typ: Type,\n    should_pack: bool,\n) -> ([Quoted], [Quoted]) {\n    let mut fields = &[];\n    let mut aux_vars = &[];\n\n    // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n    let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n    let packable_constraint =\n        quote { crate::traits::Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n    if (should_pack & typ.implements(packable_constraint)) {\n        // Packing is enabled and the given type implements the `Packable` trait so we call the `pack()`\n        // method, add the resulting field array to `aux_vars` and each field to `fields`.\n        let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n        // We collapse the name to a one that gets tokenized as a single token (e.g. \"self.value\" -> \"self_value\").\n        let name_at_one_token = collapse_to_one_token(name);\n        let packed_struct_name = f\"{name_at_one_token}_aux_var\".quoted_contents();\n\n        // We add the individual fields to the fields array\n        let pack_method = get_trait_impl_method(\n            typ,\n            quote { crate::traits::Packable<$packed_len> },\n            quote { pack },\n        );\n        let packed_struct = quote { let $packed_struct_name = $pack_method($name) };\n        for i in 0..packed_len {\n            fields = fields.push_back(quote { $packed_struct_name[$i] });\n        }\n\n        // We add the new auxiliary variable to the aux_vars array\n        aux_vars = aux_vars.push_back(packed_struct);\n    } else if typ.is_field() {\n        // For field we just add the value to fields\n        fields = fields.push_back(name);\n    } else if typ.as_integer().is_some() | typ.is_bool() {\n        // For integer and bool we just cast to Field and add the value to fields\n        fields = fields.push_back(quote { $name as Field });\n    } else if typ.as_data_type().is_some() {\n        // For struct we pref\n        let nested_struct = typ.as_data_type().unwrap();\n        let params = nested_struct.0.fields(nested_struct.1);\n        let struct_flattened = params.map(|(param_name, param_type, _)| {\n            let maybe_prefixed_name = if name == quote {} {\n                // Triggered when the param name is of a value available in the current scope (e.g. a function\n                // argument) --> then we don't prefix the name with anything.\n                param_name\n            } else {\n                // Triggered when we want to prefix the param name with the `name` from function input. This\n                // can typically be `self` when implementing a method on a struct.\n                quote { $name.$param_name }\n            };\n            generate_serialize_to_fields(quote {$maybe_prefixed_name}, param_type, should_pack)\n        });\n        let struct_flattened_fields = struct_flattened.fold(\n            &[],\n            |acc: [Quoted], (fields, _): (_, [Quoted])| acc.append(fields),\n        );\n        let struct_flattened_aux_vars = struct_flattened.fold(\n            &[],\n            |acc: [Quoted], (_, aux_vars): ([Quoted], _)| acc.append(aux_vars),\n        );\n        fields = fields.append(struct_flattened_fields);\n        aux_vars = aux_vars.append(struct_flattened_aux_vars);\n    } else if typ.as_array().is_some() {\n        // For array we recursively call `generate_serialize_to_fields(...)` for each element\n        let (element_type, array_len) = typ.as_array().unwrap();\n        let array_len = array_len.as_constant().unwrap();\n        for i in 0..array_len {\n            let (element_fields, element_aux_vars) =\n                generate_serialize_to_fields(quote { $name[$i] }, element_type, should_pack);\n            fields = fields.append(element_fields);\n            aux_vars = aux_vars.append(element_aux_vars);\n        }\n    } else if typ.as_str().is_some() {\n        // For string we convert the value to bytes, we store the `as_bytes` in an auxiliary variables and\n        // then we add each byte to fields as a Field\n        let length_type = typ.as_str().unwrap();\n        let str_len = length_type.as_constant().unwrap();\n        let as_member = name.as_expr().unwrap().as_member_access();\n        let var_name = if as_member.is_some() {\n            as_member.unwrap().1\n        } else {\n            name\n        };\n        let as_bytes_name = f\"{var_name}_as_bytes\".quoted_contents();\n        let as_bytes = quote { let $as_bytes_name = $name.as_bytes() };\n        for i in 0..str_len {\n            fields = fields.push_back(quote { $as_bytes_name[$i] as Field });\n        }\n        aux_vars = aux_vars.push_back(as_bytes);\n    } else {\n        panic(\n            f\"Unsupported type for serialization of argument {name} and type {typ}\",\n        )\n    }\n\n    (fields, aux_vars)\n}\n\n/// From a quote that gets tokenized to a multiple tokens we collapse it to a single token by replacing all `.` with `_`.\n/// E.g. \"self.values[0]\" -> \"self_values_0_\"\ncomptime fn collapse_to_one_token(q: Quoted) -> Quoted {\n    let tokens = q.tokens();\n\n    let mut single_token = quote {};\n    for token in tokens {\n        let new_token = if ((token == quote {.}) | (token == quote {[}) | (token == quote {]})) {\n            quote {_}\n        } else {\n            token\n        };\n        single_token = f\"{single_token}{new_token}\".quoted_contents();\n    }\n    single_token\n}\n\npub comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let (fields, aux_vars) = generate_serialize_to_fields(quote { self }, typ, false);\n    let aux_vars_for_serialization = if aux_vars.len() > 0 {\n        let joint = aux_vars.join(quote {;});\n        quote { $joint; }\n    } else {\n        quote {}\n    };\n\n    let field_serializations = fields.join(quote {,});\n    let serialized_len = fields.len();\n    let serialize_trait: TraitConstraint =\n        quote { Serialize<$serialized_len> }.as_trait_constraint();\n    quote {\n        impl $serialize_trait for $typ {\n            #[inline_always]\n            fn serialize(self) -> [Field; $serialized_len] {\n                $aux_vars_for_serialization\n                [ $field_serializations ]\n            }\n        }\n    }\n}\n\npub(crate) comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let (fields, _) = generate_serialize_to_fields(quote { self }, typ, false);\n    let serialized_len = fields.len();\n    let (deserialized, _) =\n        generate_deserialize_from_fields(quote { self }, typ, quote { serialized }, 0, false);\n    quote {\n        impl Deserialize<$serialized_len> for $typ {\n            #[inline_always]\n            fn deserialize(serialized: [Field; $serialized_len]) -> Self {\n                $deserialized\n            }\n        }\n    }\n}\n\n/// Generates `Packable` implementation for a given struct and returns the packed length.\n///\n/// Note: We are having this function separate from `derive_packable` because we use this in the note macros to get\n/// the packed length of a note as well as the `Packable` implementation. We need the length to be able to register\n/// the note in the global `NOTES` map. There the length is used to generate partial note helper functions.\npub comptime fn derive_packable_and_get_packed_len(s: TypeDefinition) -> (Quoted, u32) {\n    let packing_enabled = true;\n\n    let typ = s.as_type();\n    let (fields, aux_vars) = generate_serialize_to_fields(quote { self }, typ, packing_enabled);\n    let aux_vars_for_packing = if aux_vars.len() > 0 {\n        let joint = aux_vars.join(quote {;});\n        quote { $joint; }\n    } else {\n        quote {}\n    };\n\n    let (unpacked, _) =\n        generate_deserialize_from_fields(quote { self }, typ, quote { packed }, 0, packing_enabled);\n\n    let field_packings = fields.join(quote {,});\n    let packed_len = fields.len();\n    let packable_trait: TraitConstraint = quote { Packable<$packed_len> }.as_trait_constraint();\n    (\n        quote {\n        impl $packable_trait for $typ {\n            fn pack(self) -> [Field; $packed_len] {\n                $aux_vars_for_packing\n                [ $field_packings ]\n            }\n\n            fn unpack(packed: [Field; $packed_len]) -> Self {\n                $unpacked\n            }\n        }\n    },\n        packed_len,\n    )\n}\n\npub(crate) comptime fn derive_packable(s: TypeDefinition) -> Quoted {\n    let (packable_impl, _) = derive_packable_and_get_packed_len(s);\n    packable_impl\n}\n\n#[derive(Packable, Serialize, Deserialize, Eq)]\npub struct Smol {\n    a: Field,\n    b: Field,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct HasArray {\n    a: [Field; 2],\n    b: bool,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct Fancier {\n    a: Smol,\n    b: [Field; 2],\n    c: [u8; 3],\n    d: str<16>,\n}\n\nfn main() {\n    assert(false);\n}\n\n#[test]\nfn smol_test() {\n    let smol = Smol { a: 1, b: 2 };\n    let serialized = smol.serialize();\n    assert(serialized == [1, 2], serialized);\n    let deserialized = Smol::deserialize(serialized);\n    assert(deserialized == smol);\n\n    // None of the struct members implements the `Packable` trait so the packed and serialized data should be the same\n    let packed = smol.pack();\n    assert_eq(packed, serialized, \"Packed does not match serialized\");\n}\n\n#[test]\nfn has_array_test() {\n    let has_array = HasArray { a: [1, 2], b: true };\n    let serialized = has_array.serialize();\n    assert(serialized == [1, 2, 1], serialized);\n    let deserialized = HasArray::deserialize(serialized);\n    assert(deserialized == has_array);\n}\n\n#[test]\nfn fancier_test() {\n    let fancier =\n        Fancier { a: Smol { a: 1, b: 2 }, b: [0, 1], c: [1, 2, 3], d: \"metaprogramming!\" };\n    let serialized = fancier.serialize();\n    assert(\n        serialized\n            == [\n                1, 2, 0, 1, 1, 2, 3, 0x6d, 0x65, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61,\n                0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x21,\n            ],\n        serialized,\n    );\n    let deserialized = Fancier::deserialize(serialized);\n    assert(deserialized == fancier);\n}\n"
     },
-    "308": {
+    "320": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
       "source": "use crate::constants::TWO_POW_64;\n\n// NB: This is a clone of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr\n// It exists as we sometimes need to perform custom absorption, but the stdlib version\n// has a private absorb() method (it's also designed to just be a hasher)\n// Can be removed when standalone noir poseidon lib exists: See noir#6679\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2Sponge {\n    pub cache: [Field; 3],\n    pub state: [Field; 4],\n    pub cache_size: u32,\n    pub squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2Sponge {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2Sponge::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2Sponge {\n        let mut result =\n            Poseidon2Sponge { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = std::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    pub fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    pub fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let iv: Field = (in_len as Field) * TWO_POW_64;\n        let mut sponge = Poseidon2Sponge::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n"
     },
-    "343": {
+    "355": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/traits.nr",
       "source": "use crate::meta::{derive_deserialize, derive_packable, derive_serialize};\nuse crate::utils::field::field_from_bytes;\n\n// Trait: is_empty\n//\n// The general is_empty trait checks if a data type is is empty,\n// and it defines empty for the basic data types as 0.\n//\n// If a Field is equal to zero, then it is regarded as zero.\n// We will go with this definition for now, however it can be problematic\n// if a value can actually be zero. In a future refactor, we can\n// use the optional type for safety. Doing it now would lead to a worse devex\n// and would make it harder to sync up with the cpp code.\n// Preferred over Default trait to convey intent, as default doesn't necessarily mean empty.\npub trait Empty {\n    fn empty() -> Self;\n}\n\nimpl Empty for Field {\n    #[inline_always]\n    fn empty() -> Self {\n        0\n    }\n}\n\nimpl Empty for u1 {\n    #[inline_always]\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u8 {\n    #[inline_always]\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u32 {\n    #[inline_always]\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u64 {\n    #[inline_always]\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u128 {\n    #[inline_always]\n    fn empty() -> Self {\n        0\n    }\n}\n\nimpl<T, let N: u32> Empty for [T; N]\nwhere\n    T: Empty,\n{\n    #[inline_always]\n    fn empty() -> Self {\n        [T::empty(); N]\n    }\n}\n\nimpl<T> Empty for Option<T> {\n    #[inline_always]\n    fn empty() -> Self {\n        Option::none()\n    }\n}\n\npub fn is_empty<T>(item: T) -> bool\nwhere\n    T: Empty + Eq,\n{\n    item.eq(T::empty())\n}\n\npub fn is_empty_array<T, let N: u32>(array: [T; N]) -> bool\nwhere\n    T: Empty + Eq,\n{\n    array.all(|elem| is_empty(elem))\n}\n\npub trait Hash {\n    fn hash(self) -> Field;\n}\n\npub trait ToField {\n    fn to_field(self) -> Field;\n}\n\nimpl ToField for Field {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self\n    }\n}\n\nimpl ToField for bool {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u1 {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u8 {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u32 {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u64 {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u128 {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl<let N: u32> ToField for str<N> {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        assert(N < 32, \"String doesn't fit in a field, consider using Serialize instead\");\n        field_from_bytes(self.as_bytes(), true)\n    }\n}\n\npub trait FromField {\n    fn from_field(value: Field) -> Self;\n}\n\nimpl FromField for Field {\n    #[inline_always]\n    fn from_field(value: Field) -> Self {\n        value\n    }\n}\n\nimpl FromField for bool {\n    #[inline_always]\n    fn from_field(value: Field) -> Self {\n        value != 0\n    }\n}\nimpl FromField for u1 {\n    #[inline_always]\n    fn from_field(value: Field) -> Self {\n        value as u1\n    }\n}\nimpl FromField for u8 {\n    #[inline_always]\n    fn from_field(value: Field) -> Self {\n        value as u8\n    }\n}\nimpl FromField for u32 {\n    #[inline_always]\n    fn from_field(value: Field) -> Self {\n        value as u32\n    }\n}\nimpl FromField for u64 {\n    #[inline_always]\n    fn from_field(value: Field) -> Self {\n        value as u64\n    }\n}\nimpl FromField for u128 {\n    #[inline_always]\n    fn from_field(value: Field) -> Self {\n        value as u128\n    }\n}\n\n// docs:start:serialize\n/// Trait for serializing Noir types into arrays of Fields.\n///\n/// An implementation of the Serialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait (and Deserialize) are\n/// typically used to communicate between Noir and TypeScript (via oracles and function arguments).\n///\n/// # On Following Noir's Intrinsic Serialization\n/// When calling a Noir function from TypeScript (TS), first the function arguments are serialized into an array\n/// of fields. This array is then included in the initial witness. Noir's intrinsic serialization is then used\n/// to deserialize the arguments from the witness. When the same Noir function is called from Noir this Serialize trait\n/// is used instead of the serialization in TS. For this reason we need to have a match between TS serialization,\n/// Noir's intrinsic serialization and the implementation of this trait. If there is a mismatch, the function calls\n/// fail with an arguments hash mismatch error message.\n///\n/// # Type Parameters\n/// * `N` - The length of the output Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl<let N: u32> Serialize<N> for str<N> {\n///     fn serialize(self) -> [Field; N] {\n///         let bytes = self.as_bytes();\n///         let mut fields = [0; N];\n///         for i in 0..bytes.len() {\n///             fields[i] = bytes[i] as Field;  // Each byte gets its own Field\n///         }\n///         fields\n///     }\n/// }\n/// ```\n#[derive_via(derive_serialize)]\npub trait Serialize<let N: u32> {\n    fn serialize(self) -> [Field; N];\n}\n// docs:end:serialize\n\nimpl<let N: u32> Serialize<N> for str<N> {\n    #[inline_always]\n    fn serialize(self) -> [Field; N] {\n        let bytes = self.as_bytes();\n        let mut fields = [0; N];\n        for i in 0..bytes.len() {\n            fields[i] = bytes[i] as Field;\n        }\n        fields\n    }\n}\n\n// T = type of item in BoundedVec\n// M = max length of BoundedVec\n// O = field length of T\n// O * M + 1 = total serialized length of BoundedVec<T, M> (the +1 is for length of the BoundedVec)\nimpl<T, let M: u32, let O: u32> Deserialize<O * M + 1> for BoundedVec<T, M>\nwhere\n    T: Deserialize<O>,\n{\n    #[inline_always]\n    fn deserialize(fields: [Field; O * M + 1]) -> Self {\n        let mut new_bounded_vec: BoundedVec<T, M> = BoundedVec::new();\n\n        // Length is stored in the last field as we need to match intrinsic Noir serialization and the `len` struct\n        // field is after `storage` struct field (see `bounded_vec.nr` in noir-stdlib)\n        let len = fields[O * M] as u32;\n\n        for i in 0..len {\n            let mut nested_fields = [0; O];\n            for j in 0..O {\n                nested_fields[j] = fields[i * O + j];\n            }\n\n            let item = T::deserialize(nested_fields);\n            new_bounded_vec.push(item);\n        }\n\n        new_bounded_vec\n    }\n}\n\n// This may cause issues if used as program input, because noir disallows empty arrays for program input.\n// I think this is okay because I don't foresee a unit type being used as input. But leaving this comment as a hint\n// if someone does run into this in the future.\nimpl<let N: u32> Deserialize<0> for () {\n    fn deserialize(_fields: [Field; 0]) -> Self {\n        ()\n    }\n}\n\nimpl<T, let M: u32, let O: u32> Serialize<O * M + 1> for BoundedVec<T, M>\nwhere\n    T: Serialize<O>,\n{\n    #[inline_always]\n    fn serialize(self) -> [Field; O * M + 1] {\n        let mut fields = [0; O * M + 1];\n\n        let storage = self.storage();\n\n        for i in 0..M {\n            let serialized_item = storage[i].serialize();\n\n            for j in 0..O {\n                fields[i * O + j] = serialized_item[j];\n            }\n        }\n\n        // Length is stored in the last field as we need to match intrinsic Noir serialization and the `len` struct\n        // field is after `storage` struct field (see `bounded_vec.nr` in noir-stdlib)\n        fields[O * M] = self.len() as Field;\n\n        fields\n    }\n}\n\n// docs:start:deserialize\n/// Trait for deserializing Noir types from arrays of Fields.\n///\n/// An implementation of the Deserialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait is typically used when\n/// deserializing return values from function calls in Noir. Since the same function could be called from TypeScript\n/// (TS), in which case the TS deserialization would get used, we need to have a match between the 2.\n///\n/// # Type Parameters\n/// * `N` - The length of the input Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl<let N: u32> Deserialize<N> for str<N> {\n///     fn deserialize(fields: [Field; N]) -> Self {\n///         str<N>::from(fields.map(|value| value as u8))\n///     }\n/// }\n/// ```\n#[derive_via(derive_deserialize)]\npub trait Deserialize<let N: u32> {\n    fn deserialize(fields: [Field; N]) -> Self;\n}\n// docs:end:deserialize\n\nimpl<let N: u32> Deserialize<N> for str<N> {\n    #[inline_always]\n    fn deserialize(fields: [Field; N]) -> Self {\n        str::<N>::from(fields.map(|value| value as u8))\n    }\n}\n\n/// Trait for efficiently packing and unpacking Noir types into and from arrays of Fields.\n///\n/// The `Packable` trait allows types to be serialized and deserialized with a focus on minimizing the size of\n/// the resulting Field array. This trait is used when storage efficiency is critical (e.g. when storing data\n/// in the contract's public storage).\n///\n/// # Type Parameters\n/// * `N` - The length of the Field array, known at compile time.\n#[derive_via(derive_packable)]\npub trait Packable<let N: u32> {\n    /// Packs the current value into a compact array of `Field` elements.\n    fn pack(self) -> [Field; N];\n\n    /// Unpacks a compact array of `Field` elements into the original value.\n    fn unpack(fields: [Field; N]) -> Self;\n}\n\n#[test]\nunconstrained fn bounded_vec_serialization() {\n    // Test empty BoundedVec\n    let empty_vec: BoundedVec<Field, 3> = BoundedVec::from_array([]);\n    let serialized = empty_vec.serialize();\n    let deserialized = BoundedVec::<Field, 3>::deserialize(serialized);\n    assert_eq(empty_vec, deserialized);\n    assert_eq(deserialized.len(), 0);\n\n    // Test partially filled BoundedVec\n    let partial_vec: BoundedVec<[u32; 2], 3> = BoundedVec::from_array([[1, 2]]);\n    let serialized = partial_vec.serialize();\n    let deserialized = BoundedVec::<[u32; 2], 3>::deserialize(serialized);\n    assert_eq(partial_vec, deserialized);\n    assert_eq(deserialized.len(), 1);\n    assert_eq(deserialized.get(0), [1, 2]);\n\n    // Test full BoundedVec\n    let full_vec: BoundedVec<[u32; 2], 3> = BoundedVec::from_array([[1, 2], [3, 4], [5, 6]]);\n    let serialized = full_vec.serialize();\n    let deserialized = BoundedVec::<[u32; 2], 3>::deserialize(serialized);\n    assert_eq(full_vec, deserialized);\n    assert_eq(deserialized.len(), 3);\n    assert_eq(deserialized.get(0), [1, 2]);\n    assert_eq(deserialized.get(1), [3, 4]);\n    assert_eq(deserialized.get(2), [5, 6]);\n}\n"
     },
-    "348": {
+    "361": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/type_serialization.nr",
       "source": "use crate::traits::{Deserialize, Serialize};\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize<BOOL_SERIALIZED_LEN> for bool {\n    fn serialize(self) -> [Field; BOOL_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<BOOL_SERIALIZED_LEN> for bool {\n    fn deserialize(fields: [Field; BOOL_SERIALIZED_LEN]) -> bool {\n        fields[0] != 0\n    }\n}\n\nimpl Serialize<U8_SERIALIZED_LEN> for u8 {\n    fn serialize(self) -> [Field; U8_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U8_SERIALIZED_LEN> for u8 {\n    fn deserialize(fields: [Field; U8_SERIALIZED_LEN]) -> Self {\n        fields[0] as u8\n    }\n}\n\nimpl Serialize<U16_SERIALIZED_LEN> for u16 {\n    fn serialize(self) -> [Field; U16_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U16_SERIALIZED_LEN> for u16 {\n    fn deserialize(fields: [Field; U16_SERIALIZED_LEN]) -> Self {\n        fields[0] as u16\n    }\n}\n\nimpl Serialize<U32_SERIALIZED_LEN> for u32 {\n    fn serialize(self) -> [Field; U32_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U32_SERIALIZED_LEN> for u32 {\n    fn deserialize(fields: [Field; U32_SERIALIZED_LEN]) -> Self {\n        fields[0] as u32\n    }\n}\n\nimpl Serialize<U64_SERIALIZED_LEN> for u64 {\n    fn serialize(self) -> [Field; U64_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U64_SERIALIZED_LEN> for u64 {\n    fn deserialize(fields: [Field; U64_SERIALIZED_LEN]) -> Self {\n        fields[0] as u64\n    }\n}\n\nimpl Serialize<U128_SERIALIZED_LEN> for u128 {\n    fn serialize(self) -> [Field; U128_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U128_SERIALIZED_LEN> for u128 {\n    fn deserialize(fields: [Field; U128_SERIALIZED_LEN]) -> Self {\n        fields[0] as u128\n    }\n}\n\nimpl Serialize<FIELD_SERIALIZED_LEN> for Field {\n    fn serialize(self) -> [Field; FIELD_SERIALIZED_LEN] {\n        [self]\n    }\n}\n\nimpl Deserialize<FIELD_SERIALIZED_LEN> for Field {\n    fn deserialize(fields: [Field; FIELD_SERIALIZED_LEN]) -> Self {\n        fields[0]\n    }\n}\n\nimpl Serialize<I8_SERIALIZED_LEN> for i8 {\n    fn serialize(self) -> [Field; I8_SERIALIZED_LEN] {\n        [self as u8 as Field]\n    }\n}\n\nimpl Deserialize<I8_SERIALIZED_LEN> for i8 {\n    fn deserialize(fields: [Field; I8_SERIALIZED_LEN]) -> Self {\n        fields[0] as u8 as i8\n    }\n}\n\nimpl Serialize<I16_SERIALIZED_LEN> for i16 {\n    fn serialize(self) -> [Field; I16_SERIALIZED_LEN] {\n        [self as u16 as Field]\n    }\n}\n\nimpl Deserialize<I16_SERIALIZED_LEN> for i16 {\n    fn deserialize(fields: [Field; I16_SERIALIZED_LEN]) -> Self {\n        fields[0] as u16 as i16\n    }\n}\n\nimpl Serialize<I32_SERIALIZED_LEN> for i32 {\n    fn serialize(self) -> [Field; I32_SERIALIZED_LEN] {\n        [self as u32 as Field]\n    }\n}\n\nimpl Deserialize<I32_SERIALIZED_LEN> for i32 {\n    fn deserialize(fields: [Field; I32_SERIALIZED_LEN]) -> Self {\n        fields[0] as u32 as i32\n    }\n}\n\nimpl Serialize<I64_SERIALIZED_LEN> for i64 {\n    fn serialize(self) -> [Field; I64_SERIALIZED_LEN] {\n        [self as u64 as Field]\n    }\n}\n\nimpl Deserialize<I64_SERIALIZED_LEN> for i64 {\n    fn deserialize(fields: [Field; I64_SERIALIZED_LEN]) -> Self {\n        fields[0] as u64 as i64\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]\nwhere\n    T: Serialize<M>,\n{\n    fn serialize(self) -> [Field; N * M] {\n        let mut result: [Field; N * M] = std::mem::zeroed();\n        let mut serialized: [Field; M] = std::mem::zeroed();\n        for i in 0..N {\n            serialized = self[i].serialize();\n            for j in 0..M {\n                result[i * M + j] = serialized[j];\n            }\n        }\n        result\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Deserialize<N * M> for [T; N]\nwhere\n    T: Deserialize<M>,\n{\n    fn deserialize(fields: [Field; N * M]) -> Self {\n        let mut reader = crate::utils::reader::Reader::new(fields);\n        let mut result: [T; N] = std::mem::zeroed();\n        reader.read_struct_array::<T, M, N>(Deserialize::deserialize, result)\n    }\n}\n\nimpl<T, let N: u32> Serialize<N + 1> for Option<T>\nwhere\n    T: Serialize<N>,\n{\n    fn serialize(self) -> [Field; N + 1] {\n        let mut result: [Field; N + 1] = std::mem::zeroed();\n\n        result[0] = if self.is_some() { 1 } else { 0 };\n\n        let value_serialized = self.unwrap_unchecked().serialize();\n        for i in 0..N {\n            result[1 + i] = value_serialized[i];\n        }\n\n        result\n    }\n}\n\nimpl<T, let N: u32> Deserialize<N + 1> for Option<T>\nwhere\n    T: Deserialize<N>,\n{\n    fn deserialize(fields: [Field; N + 1]) -> Self {\n        if fields[0] == 1 {\n            let mut value_serialized: [Field; N] = std::mem::zeroed();\n            for i in 0..N {\n                value_serialized[i] = fields[1 + i];\n            }\n\n            Option::some(T::deserialize(value_serialized))\n        } else {\n            Option::none()\n        }\n    }\n}\n\nmod test {\n    use crate::traits::{Deserialize, Serialize};\n\n    #[test]\n    fn u16_serialization() {\n        let a: u16 = 10;\n        assert_eq(a, u16::deserialize(a.serialize()));\n    }\n\n    #[test]\n    fn i8_serialization() {\n        let a: i8 = -10;\n        assert_eq(a, i8::deserialize(a.serialize()));\n    }\n\n    #[test]\n    fn i16_serialization() {\n        let a: i16 = -10;\n        assert_eq(a, i16::deserialize(a.serialize()));\n    }\n\n    #[test]\n    fn i32_serialization() {\n        let a: i32 = -10;\n        assert_eq(a, i32::deserialize(a.serialize()));\n    }\n\n    #[test]\n    fn i64_serialization() {\n        let a: i64 = -10;\n        assert_eq(a, i64::deserialize(a.serialize()));\n    }\n\n    #[test]\n    fn option_field_serialization() {\n        let opt_some = Option::some(5);\n        assert_eq(Option::<_>::deserialize(opt_some.serialize()), opt_some);\n\n        let opt_none = Option::none();\n        assert_eq(Option::<Field>::deserialize(opt_none.serialize()), opt_none);\n    }\n\n    #[test]\n    fn option_array_serialization() {\n        let opt_some = Option::some([2, 5]);\n        assert_eq(Option::<_>::deserialize(opt_some.serialize()), opt_some);\n\n        let opt_none = Option::none();\n        assert_eq(Option::<Field>::deserialize(opt_none.serialize()), opt_none);\n    }\n}\n"
     },
-    "366": {
+    "379": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/arrays.nr",
       "source": "pub mod assert_array_appended;\npub mod assert_array_prepended;\npub mod assert_combined_array;\npub mod assert_combined_transformed_array;\npub mod assert_exposed_sorted_transformed_value_array;\npub mod assert_sorted_array;\npub mod assert_sorted_transformed_padded_array;\npub mod assert_sorted_transformed_value_array;\npub mod assert_split_sorted_transformed_value_arrays;\npub mod assert_split_transformed_padded_arrays;\npub mod assert_split_transformed_value_arrays;\npub mod get_sorted_result;\npub mod get_sorted_tuple;\npub mod sort_by;\npub mod sort_by_counter;\n\n// Re-exports.\npub use assert_array_appended::{\n    assert_array_appended, assert_array_appended_and_scoped, assert_array_appended_reversed,\n    assert_array_appended_scoped,\n};\npub use assert_array_prepended::assert_array_prepended;\npub use assert_combined_array::{assert_combined_array, combine_arrays};\npub use assert_combined_transformed_array::{\n    assert_combined_transformed_array, combine_and_transform_arrays,\n};\npub use assert_exposed_sorted_transformed_value_array::{\n    assert_exposed_sorted_transformed_value_array,\n    get_order_hints::{get_order_hints_asc, OrderHint},\n};\npub use assert_sorted_array::assert_sorted_array;\npub use assert_sorted_transformed_padded_array::{\n    assert_sorted_transformed_i_padded_array_capped_size,\n    assert_sorted_transformed_padded_array_capped_size, validate_padded_items,\n};\npub use assert_split_sorted_transformed_value_arrays::{\n    assert_split_sorted_transformed_value_arrays_asc,\n    get_split_order_hints::{get_split_order_hints_asc, SplitOrderHints},\n};\npub use assert_split_transformed_padded_arrays::assert_split_transformed_padded_arrays;\npub use get_sorted_result::{get_sorted_result, SortedResult};\npub use sort_by_counter::sort_by_counter_asc;\n\nuse crate::traits::{Empty, is_empty};\n\npub fn subarray<let SRC_LEN: u32, let DST_LEN: u32>(\n    src: [Field; SRC_LEN],\n    offset: u32,\n) -> [Field; DST_LEN] {\n    assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n    let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n    for i in 0..DST_LEN {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\n// Helper function to convert a validated array to BoundedVec.\n// Important: Only use it for validated arrays: validate_array(array) should be true.\npub unconstrained fn array_to_bounded_vec<T, let N: u32>(array: [T; N]) -> BoundedVec<T, N>\nwhere\n    T: Empty + Eq,\n{\n    let len = array_length(array);\n    BoundedVec::from_parts_unchecked(array, len)\n}\n\n// Helper function to find the index of the first element in an array that satisfies a given predicate. If the element\n// is not found, the function returns N as the index.\npub unconstrained fn find_index_hint<T, let N: u32, Env>(\n    array: [T; N],\n    find: fn[Env](T) -> bool,\n) -> u32 {\n    let mut index = N;\n    for i in 0..N {\n        // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n        if (index == N) & find(array[i]) {\n            index = i;\n        }\n    }\n    index\n}\n\n// Routine which validates that all zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where any * is non-zero. Note that a full array of non-zero values is\n// valid.\npub fn validate_array<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    let mut seen_empty = false;\n    let mut length = 0;\n    for i in 0..N {\n        if is_empty(array[i]) {\n            seen_empty = true;\n        } else {\n            assert(seen_empty == false, \"invalid array\");\n            length += 1;\n        }\n    }\n    length\n}\n\n// Helper function to count the number of non-empty elements in a validated array.\n// Important: Only use it for validated arrays where validate_array(array) returns true,\n// which ensures that:\n// 1. All elements before the first empty element are non-empty\n// 2. All elements after and including the first empty element are empty\n// 3. The array forms a contiguous sequence of non-empty elements followed by empty elements\npub fn array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    // We get the length by checking the index of the first empty element.\n\n    // Safety: This is safe because we have validated the array (see function doc above) and the emptiness\n    // of the element and non-emptiness of the previous element is checked below.\n    let length = unsafe { find_index_hint(array, |elem: T| is_empty(elem)) };\n    if length != 0 {\n        assert(!is_empty(array[length - 1]));\n    }\n    if length != N {\n        assert(is_empty(array[length]));\n    }\n    length\n}\n\n// Returns the number of consecutive elements at the start of the array for which the predicate returns false.\n// This function ensures that any element after the first matching element (predicate returns true) also matches the predicate.\npub fn array_length_until<T, let N: u32, Env>(array: [T; N], predicate: fn[Env](T) -> bool) -> u32 {\n    let mut length = 0;\n    let mut stop = false;\n    for i in 0..N {\n        if predicate(array[i]) {\n            stop = true;\n        } else {\n            assert(\n                stop == false,\n                \"matching element found after already encountering a non-matching element\",\n            );\n            length += 1;\n        }\n    }\n    length\n}\n\npub fn array_concat<T, let N: u32, let M: u32>(array1: [T; N], array2: [T; M]) -> [T; N + M] {\n    let mut result = [array1[0]; N + M];\n    for i in 1..N {\n        result[i] = array1[i];\n    }\n    for i in 0..M {\n        result[i + N] = array2[i];\n    }\n    result\n}\n\n/// This function assumes that `array1` and `array2` contain no more than N non-empty elements between them,\n/// if this is not the case then elements from the end of `array2` will be dropped.\npub fn array_merge<T, let N: u32>(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n    T: Empty + Eq,\n{\n    // Safety: we constrain this array below\n    let result = unsafe { array_merge_helper(array1, array2) };\n    // We assume arrays have been validated. The only use cases so far are with previously validated arrays.\n    let array1_len = array_length(array1);\n    let mut add_from_left = true;\n    for i in 0..N {\n        add_from_left &= i != array1_len;\n        if add_from_left {\n            assert_eq(result[i], array1[i]);\n        } else {\n            assert_eq(result[i], array2[i - array1_len]);\n        }\n    }\n    result\n}\n\nunconstrained fn array_merge_helper<T, let N: u32>(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n    T: Empty + Eq,\n{\n    let mut result: [T; N] = [T::empty(); N];\n    let mut i = 0;\n    for elem in array1 {\n        if !is_empty(elem) {\n            result[i] = elem;\n            i += 1;\n        }\n    }\n    for elem in array2 {\n        if !is_empty(elem) {\n            result[i] = elem;\n            i += 1;\n        }\n    }\n    result\n}\n\n// Helper fn to create a subarray from a given array\npub fn array_splice<T, let N: u32, let M: u32>(array: [T; N], offset: u32) -> [T; M]\nwhere\n    T: Empty,\n{\n    assert(M + offset <= N, \"Subarray length larger than array length\");\n    let mut result: [T; M] = [T::empty(); M];\n    for i in 0..M {\n        result[i] = array[offset + i];\n    }\n    result\n}\n\npub fn check_permutation<T, let N: u32>(\n    original_array: [T; N],\n    permuted_array: [T; N],\n    original_indexes: [u32; N],\n)\nwhere\n    T: Eq + Empty,\n{\n    let mut seen_value = [false; N];\n    for i in 0..N {\n        let index = original_indexes[i];\n        let original_value = original_array[index];\n        assert(permuted_array[i].eq(original_value), \"Invalid index\");\n        assert(!seen_value[index], \"Duplicated index\");\n        seen_value[index] = true;\n    }\n}\n\n// Helper function to find the index of the last element in an array, allowing empty elements.\n// e.g. useful for removing trailing 0s from [1, 0, 2, 0, 0, 0] -> [1, 0, 2]\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn find_last_value_index<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    let mut index = N;\n    for i in 0..N {\n        let j = N - i - 1;\n        // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n        if (index == N) & !is_empty(array[j]) {\n            index = j;\n        }\n    }\n    index\n}\n\n// Routine which returns the length of an array right padded by empty elements\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\n// See smoke_validate_array_trailing for examples.\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn unsafe_padded_array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    let index = find_last_value_index(array);\n    if index == N {\n        0\n    } else {\n        index + 1\n    }\n}\n\n// Routine which validates that zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\npub fn padded_array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    // Safety: this value is constrained in the below loop.\n    let length = unsafe { unsafe_padded_array_length(array) };\n    // Check the elt just before length is non-zero:\n    if length != 0 {\n        assert(!is_empty(array[length - 1]), \"invalid right padded array\");\n    }\n    // Check all beyond length are zero:\n    let mut check_zero = false;\n    for i in 0..N {\n        check_zero |= i == length;\n        if check_zero {\n            assert(is_empty(array[i]), \"invalid right padded array\");\n        }\n    }\n    length\n}\n\n// Helper function to check if an array is padded with a given value from a given index.\n// Different to padded_array_length in that it allows the elements before the given index to be the same as the padded value.\npub fn array_padded_with<T, let N: u32>(array: [T; N], from_index: u32, padded_with: T) -> bool\nwhere\n    T: Eq,\n{\n    let mut is_valid = true;\n    let mut should_check = false;\n    for i in 0..N {\n        should_check |= i == from_index;\n        is_valid &= !should_check | (array[i] == padded_with);\n    }\n    is_valid\n}\n\n#[test]\nfn smoke_validate_array() {\n    let valid_array: [Field; 0] = [];\n    assert(validate_array(valid_array) == 0);\n\n    let valid_array = [0];\n    assert(validate_array(valid_array) == 0);\n\n    let valid_array = [3];\n    assert(validate_array(valid_array) == 1);\n\n    let valid_array = [1, 2, 3];\n    assert(validate_array(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0];\n    assert(validate_array(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0, 0];\n    assert(validate_array(valid_array) == 3);\n}\n\n#[test]\nfn smoke_validate_array_trailing() {\n    let valid_array: [Field; 0] = [];\n    assert(padded_array_length(valid_array) == 0);\n\n    let valid_array = [0];\n    assert(padded_array_length(valid_array) == 0);\n\n    let valid_array = [3];\n    assert(padded_array_length(valid_array) == 1);\n\n    let valid_array = [1, 0, 3];\n    assert(padded_array_length(valid_array) == 3);\n\n    let valid_array = [1, 0, 3, 0];\n    assert(padded_array_length(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0, 0];\n    assert(padded_array_length(valid_array) == 3);\n\n    let valid_array = [0, 0, 3, 0, 0];\n    assert(padded_array_length(valid_array) == 3);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case0() {\n    let invalid_array = [0, 1];\n    let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case1() {\n    let invalid_array = [1, 0, 0, 1, 0];\n    let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case2() {\n    let invalid_array = [0, 0, 0, 0, 1];\n    let _ = validate_array(invalid_array);\n}\n\n#[test]\nfn test_empty_array_length() {\n    assert_eq(array_length([0]), 0);\n    assert_eq(array_length([0, 0, 0]), 0);\n}\n\n#[test]\nfn test_array_length() {\n    assert_eq(array_length([123]), 1);\n    assert_eq(array_length([123, 0, 0]), 1);\n    assert_eq(array_length([123, 456]), 2);\n    assert_eq(array_length([123, 456, 0]), 2);\n}\n\n#[test]\nfn test_array_length_invalid_arrays() {\n    // Result can be misleading (but correct) for invalid arrays.\n    assert_eq(array_length([0, 0, 123]), 0);\n    assert_eq(array_length([0, 123, 0]), 0);\n    assert_eq(array_length([0, 123, 456]), 0);\n    assert_eq(array_length([123, 0, 456]), 1);\n}\n\n#[test]\nfn test_array_length_until() {\n    let array = [11, 22, 33, 44, 55];\n    assert_eq(array_length_until(array, |x| x == 55), 4);\n    assert_eq(array_length_until(array, |x| x == 56), 5);\n    assert_eq(array_length_until(array, |x| x > 40), 3);\n    assert_eq(array_length_until(array, |x| x > 10), 0);\n}\n\n#[test(should_fail_with = \"matching element found after already encountering a non-matching element\")]\nfn test_array_length_until_non_consecutive_fails() {\n    let array = [1, 1, 0, 1, 0];\n    let _ = array_length_until(array, |x| x == 0);\n}\n\n#[test(should_fail_with = \"matching element found after already encountering a non-matching element\")]\nfn test_array_length_until_first_non_matching_fails() {\n    let array = [1, 0, 0, 0, 0];\n    let _ = array_length_until(array, |x| x == 1);\n}\n\n#[test]\nunconstrained fn find_index_greater_than_min() {\n    let values = [10, 20, 30, 40];\n    let min = 22;\n    let index = find_index_hint(values, |v: Field| min.lt(v));\n    assert_eq(index, 2);\n}\n\n#[test]\nunconstrained fn find_index_not_found() {\n    let values = [10, 20, 30, 40];\n    let min = 100;\n    let index = find_index_hint(values, |v: Field| min.lt(v));\n    assert_eq(index, 4);\n}\n\n#[test]\nfn test_array_concat() {\n    let array0 = [1, 2, 3];\n    let array1 = [4, 5];\n    let concatenated = array_concat(array0, array1);\n    assert_eq(concatenated, [1, 2, 3, 4, 5]);\n}\n\n#[test]\nfn check_permutation_basic_test() {\n    let original_array = [1, 2, 3];\n    let permuted_array = [3, 1, 2];\n    let indexes = [2, 0, 1];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Duplicated index\")]\nfn check_permutation_duplicated_index() {\n    let original_array = [0, 1, 0];\n    let permuted_array = [1, 0, 0];\n    let indexes = [1, 0, 0];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Invalid index\")]\nfn check_permutation_invalid_index() {\n    let original_array = [0, 1, 2];\n    let permuted_array = [1, 0, 0];\n    let indexes = [1, 0, 2];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test]\nfn test_array_padded_with() {\n    let array = [11, 22, 33, 44, 44];\n    assert_eq(array_padded_with(array, 0, 44), false);\n    assert_eq(array_padded_with(array, 1, 44), false);\n    assert_eq(array_padded_with(array, 2, 44), false);\n    assert_eq(array_padded_with(array, 3, 44), true);\n    assert_eq(array_padded_with(array, 4, 44), true);\n    assert_eq(array_padded_with(array, 4, 33), false);\n    assert_eq(array_padded_with(array, 5, 44), true); // Index out of bounds.\n    assert_eq(array_padded_with(array, 0, 11), false);\n}\n"
     },
-    "369": {
+    "382": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
       "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() != 0\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
     },
-    "379": {
+    "392": {
       "path": "/home/aztec-dev/nargo/github.com/noir-lang/sha256/v0.1.2/src/sha256.nr",
       "source": "use std::hash::sha256_compression;\nuse std::runtime::is_unconstrained;\n\nuse constants::{\n    BLOCK_BYTE_PTR, BLOCK_SIZE, HASH, INITIAL_STATE, INT_BLOCK, INT_BLOCK_SIZE, INT_SIZE,\n    INT_SIZE_PTR, MSG_BLOCK, MSG_SIZE_PTR, STATE, TWO_POW_16, TWO_POW_24, TWO_POW_32, TWO_POW_8,\n};\n\nmod constants;\nmod tests;\n\n// Implementation of SHA-256 mapping a byte array of variable length to\n// 32 bytes.\n\n// Deprecated in favour of `sha256_var`\n// docs:start:sha256\npub fn sha256<let N: u32>(input: [u8; N]) -> HASH\n// docs:end:sha256\n{\n    digest(input)\n}\n\n// SHA-256 hash function\n#[no_predicates]\npub fn digest<let N: u32>(msg: [u8; N]) -> HASH {\n    sha256_var(msg, N as u64)\n}\n\n// Variable size SHA-256 hash\npub fn sha256_var<let N: u32>(msg: [u8; N], message_size: u64) -> HASH {\n    let message_size = message_size as u32;\n    assert(message_size <= N);\n\n    if std::runtime::is_unconstrained() {\n        // Safety: SHA256 is running as an unconstrained function.\n        unsafe {\n            __sha256_var(msg, message_size)\n        }\n    } else {\n        let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n        // Intermediate hash, starting with the canonical initial value\n        let mut h: STATE = INITIAL_STATE;\n        // Pointer into msg_block on a 64 byte scale\n        let mut msg_byte_ptr = 0;\n        let num_blocks = N / BLOCK_SIZE;\n        for i in 0..num_blocks {\n            let msg_start = BLOCK_SIZE * i;\n            let (new_msg_block, new_msg_byte_ptr) =\n                unsafe { build_msg_block(msg, message_size, msg_start) };\n\n            if msg_start < message_size {\n                msg_block = new_msg_block;\n            }\n\n            // Verify the block we are compressing was appropriately constructed\n            let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n            if msg_start < message_size {\n                msg_byte_ptr = new_msg_byte_ptr;\n            }\n\n            // If the block is filled, compress it.\n            // An un-filled block is handled after this loop.\n            if (msg_start < message_size) & (msg_byte_ptr == BLOCK_SIZE) {\n                h = sha256_compression(msg_block, h);\n            }\n        }\n\n        let modulo = N % BLOCK_SIZE;\n        // Handle setup of the final msg block.\n        // This case is only hit if the msg is less than the block size,\n        // or our message cannot be evenly split into blocks.\n        if modulo != 0 {\n            let msg_start = BLOCK_SIZE * num_blocks;\n            let (new_msg_block, new_msg_byte_ptr) =\n                unsafe { build_msg_block(msg, message_size, msg_start) };\n\n            if msg_start < message_size {\n                msg_block = new_msg_block;\n            }\n\n            let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n            if msg_start < message_size {\n                msg_byte_ptr = new_msg_byte_ptr;\n                verify_msg_block_padding(msg_block, msg_byte_ptr);\n            }\n        }\n\n        // If we had modulo == 0 then it means the last block was full,\n        // and we can reset the pointer to zero to overwrite it.\n        if msg_byte_ptr == BLOCK_SIZE {\n            msg_byte_ptr = 0;\n        }\n\n        // Pad the rest such that we have a [u32; 2] block at the end representing the length\n        // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n        // Here we rely on the fact that everything beyond the available input is set to 0.\n        let index = msg_byte_ptr / INT_SIZE;\n        msg_block[index] = set_item_byte_then_zeros(msg_block[index], msg_byte_ptr, 1 << 7);\n\n        msg_byte_ptr = msg_byte_ptr + 1;\n        let last_block = msg_block;\n\n        // If we don't have room to write the size, compress the block and reset it.\n        if msg_byte_ptr > MSG_SIZE_PTR {\n            h = sha256_compression(msg_block, h);\n            // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n            msg_byte_ptr = 0;\n        }\n\n        msg_block = unsafe { attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size) };\n\n        verify_msg_len(msg_block, last_block, msg_byte_ptr, message_size);\n\n        hash_final_block(msg_block, h)\n    }\n}\n\n// Variable size SHA-256 hash\nunconstrained fn __sha256_var<let N: u32>(msg: [u8; N], message_size: u32) -> HASH {\n    let num_full_blocks = message_size / BLOCK_SIZE;\n    // Intermediate hash, starting with the canonical initial value\n    let mut h: STATE = INITIAL_STATE;\n    // Pointer into msg_block on a 64 byte scale\n    for i in 0..num_full_blocks {\n        let (msg_block, _) = build_msg_block(msg, message_size, BLOCK_SIZE * i);\n        h = sha256_compression(msg_block, h);\n    }\n\n    // Handle setup of the final msg block.\n    // This case is only hit if the msg is less than the block size,\n    // or our message cannot be evenly split into blocks.\n    let modulo = message_size % BLOCK_SIZE;\n    let (mut msg_block, mut msg_byte_ptr): (INT_BLOCK, u32) = if modulo != 0 {\n        let msg_start = BLOCK_SIZE * num_full_blocks;\n        let (new_msg_block, new_msg_byte_ptr) = build_msg_block(msg, message_size, msg_start);\n\n        (new_msg_block, new_msg_byte_ptr)\n    } else {\n        // If we had modulo == 0 then it means the last block was full,\n        // and we can reset the pointer to zero to overwrite it.\n        ([0; INT_BLOCK_SIZE], 0)\n    };\n\n    // Pad the rest such that we have a [u32; 2] block at the end representing the length\n    // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n    // Here we rely on the fact that everything beyond the available input is set to 0.\n    let index = msg_byte_ptr / INT_SIZE;\n    msg_block[index] = set_item_byte_then_zeros(msg_block[index], msg_byte_ptr, 1 << 7);\n\n    // If we don't have room to write the size, compress the block and reset it.\n    let (h, mut msg_byte_ptr): (STATE, u32) = if msg_byte_ptr >= MSG_SIZE_PTR {\n        // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n        (sha256_compression(msg_block, h), 0)\n    } else {\n        (h, msg_byte_ptr + 1)\n    };\n    msg_block = attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size);\n\n    hash_final_block(msg_block, h)\n}\n\n// Take `BLOCK_SIZE` number of bytes from `msg` starting at `msg_start`.\n// Returns the block and the length that has been copied rather than padded with zeros.\nunconstrained fn build_msg_block<let N: u32>(\n    msg: [u8; N],\n    message_size: u32,\n    msg_start: u32,\n) -> (MSG_BLOCK, BLOCK_BYTE_PTR) {\n    let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n\n    // We insert `BLOCK_SIZE` bytes (or up to the end of the message)\n    let block_input = if message_size < msg_start {\n        // This function is sometimes called with `msg_start` past the end of the message.\n        // In this case we return an empty block and zero pointer to signal that the result should be ignored.\n        0\n    } else if message_size < msg_start + BLOCK_SIZE {\n        message_size - msg_start\n    } else {\n        BLOCK_SIZE\n    };\n\n    // Figure out the number of items in the int array that we have to pack.\n    // e.g. if the input is [0,1,2,3,4,5] then we need to pack it as 2 items: [0123, 4500]\n    let mut int_input = block_input / INT_SIZE;\n    if block_input % INT_SIZE != 0 {\n        int_input = int_input + 1;\n    };\n\n    for i in 0..int_input {\n        let mut msg_item: u32 = 0;\n        // Always construct the integer as 4 bytes, even if it means going beyond the input.\n        for j in 0..INT_SIZE {\n            let k = i * INT_SIZE + j;\n            let msg_byte = if k < block_input {\n                msg[msg_start + k]\n            } else {\n                0\n            };\n            msg_item = lshift8(msg_item, 1) + msg_byte as u32;\n        }\n        msg_block[i] = msg_item;\n    }\n\n    // Returning the index as if it was a 64 byte array.\n    // We have to project it down to 16 items and bit shifting to get a byte back if we need it.\n    (msg_block, block_input)\n}\n\n// Verify the block we are compressing was appropriately constructed by `build_msg_block`\n// and matches the input data. Returns the index of the first unset item.\n// If `message_size` is less than `msg_start` then this is called with the old non-empty block;\n// in that case we can skip verification, ie. no need to check that everything is zero.\nfn verify_msg_block<let N: u32>(\n    msg: [u8; N],\n    message_size: u32,\n    msg_block: MSG_BLOCK,\n    msg_start: u32,\n) -> BLOCK_BYTE_PTR {\n    let mut msg_byte_ptr = 0;\n    let mut msg_end = msg_start + BLOCK_SIZE;\n    if msg_end > N {\n        msg_end = N;\n    }\n    // We might have to go beyond the input to pad the fields.\n    if msg_end % INT_SIZE != 0 {\n        msg_end = msg_end + INT_SIZE - msg_end % INT_SIZE;\n    }\n\n    // Reconstructed packed item.\n    let mut msg_item: u32 = 0;\n\n    // Inclusive at the end so that we can compare the last item.\n    let mut i: u32 = 0;\n    for k in msg_start..=msg_end {\n        if k % INT_SIZE == 0 {\n            // If we consumed some input we can compare against the block.\n            if (msg_start < message_size) & (k > msg_start) {\n                assert_eq(msg_block[i], msg_item as u32);\n                i = i + 1;\n                msg_item = 0;\n            }\n        }\n        // Shift the accumulator\n        msg_item = lshift8(msg_item, 1);\n        // If we have input to consume, add it at the rightmost position.\n        if k < message_size & k < msg_end {\n            msg_item = msg_item + msg[k] as u32;\n            msg_byte_ptr = msg_byte_ptr + 1;\n        }\n    }\n\n    msg_byte_ptr\n}\n\n// Verify the block we are compressing was appropriately padded with zeros by `build_msg_block`.\n// This is only relevant for the last, potentially partially filled block.\nfn verify_msg_block_padding(msg_block: MSG_BLOCK, msg_byte_ptr: BLOCK_BYTE_PTR) {\n    // Check all the way to the end of the block.\n    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_BLOCK_SIZE);\n}\n\n// Verify that a region of ints in the message block are (partially) zeroed,\n// up to an (exclusive) maximum which can either be the end of the block\n// or just where the size is to be written.\nfn verify_msg_block_zeros(\n    msg_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n    max_int_byte_ptr: u32,\n) {\n    // This variable is used to get around the compiler under-constrained check giving a warning.\n    // We want to check against a constant zero, but if it does not come from the circuit inputs\n    // or return values the compiler check will issue a warning.\n    let zero = msg_block[0] - msg_block[0];\n\n    // First integer which is supposed to be (partially) zero.\n    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n    // Check partial zeros.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        let zeros = INT_SIZE - modulo;\n        let mask = if zeros == 3 {\n            TWO_POW_24\n        } else if zeros == 2 {\n            TWO_POW_16\n        } else {\n            TWO_POW_8\n        };\n        assert_eq(msg_block[int_byte_ptr] % mask, zero);\n        int_byte_ptr = int_byte_ptr + 1;\n    }\n\n    // Check the rest of the items.\n    for i in 0..max_int_byte_ptr {\n        if i >= int_byte_ptr {\n            assert_eq(msg_block[i], zero);\n        }\n    }\n}\n\n// Verify that up to the byte pointer the two blocks are equal.\n// At the byte pointer the new block can be partially zeroed.\nfn verify_msg_block_equals_last(\n    msg_block: MSG_BLOCK,\n    last_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n) {\n    // msg_byte_ptr is the position at which they are no longer have to be the same.\n    // First integer which is supposed to be (partially) zero contains that pointer.\n    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n    // Check partial zeros.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        // Reconstruct the partially zero item from the last block.\n        let last_field = last_block[int_byte_ptr];\n        let mut msg_item: u32 = 0;\n        // Reset to where they are still equal.\n        msg_byte_ptr = msg_byte_ptr - modulo;\n        for i in 0..INT_SIZE {\n            msg_item = lshift8(msg_item, 1);\n            if i < modulo {\n                msg_item = msg_item + get_item_byte(last_field, msg_byte_ptr) as u32;\n                msg_byte_ptr = msg_byte_ptr + 1;\n            }\n        }\n        assert_eq(msg_block[int_byte_ptr], msg_item);\n    }\n\n    for i in 0..INT_SIZE_PTR {\n        if i < int_byte_ptr {\n            assert_eq(msg_block[i], last_block[i]);\n        }\n    }\n}\n\n// Set the rightmost `zeros` number of bytes to 0.\n#[inline_always]\nfn set_item_zeros(item: u32, zeros: u8) -> u32 {\n    lshift8(rshift8(item, zeros), zeros)\n}\n\n// Replace one byte in the item with a value, and set everything after it to zero.\nfn set_item_byte_then_zeros(msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR, msg_byte: u8) -> u32 {\n    let zeros = INT_SIZE - msg_byte_ptr % INT_SIZE;\n    let zeroed_item = set_item_zeros(msg_item, zeros as u8);\n    let new_item = byte_into_item(msg_byte, msg_byte_ptr);\n    zeroed_item + new_item\n}\n\n// Get a byte of a message item according to its overall position in the `BLOCK_SIZE` space.\nfn get_item_byte(mut msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR) -> u8 {\n    // How many times do we have to shift to the right to get to the position we want?\n    let max_shifts = INT_SIZE - 1;\n    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n    msg_item = rshift8(msg_item, shifts as u8);\n    // At this point the byte we want is in the rightmost position.\n    msg_item as u8\n}\n\n// Project a byte into a position in a field based on the overall block pointer.\n// For example putting 1 into pointer 5 would be 100, because overall we would\n// have [____, 0100] with indexes [0123,4567].\n#[inline_always]\nfn byte_into_item(msg_byte: u8, msg_byte_ptr: BLOCK_BYTE_PTR) -> u32 {\n    let mut msg_item = msg_byte as u32;\n    // How many times do we have to shift to the left to get to the position we want?\n    let max_shifts = INT_SIZE - 1;\n    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n    lshift8(msg_item, shifts as u8)\n}\n\n// Construct a field out of 4 bytes.\n#[inline_always]\nfn make_item(b0: u8, b1: u8, b2: u8, b3: u8) -> u32 {\n    let mut item = b0 as u32;\n    item = lshift8(item, 1) + b1 as u32;\n    item = lshift8(item, 1) + b2 as u32;\n    item = lshift8(item, 1) + b3 as u32;\n    item\n}\n\n// Shift by 8 bits to the left between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise multiplies by 256.\n#[inline_always]\nfn lshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        // Brillig wouldn't shift 0<<4 without overflow.\n        if shifts >= 4 {\n            0\n        } else {\n            item << (8 * shifts)\n        }\n    } else {\n        // We can do a for loop up to INT_SIZE or an if-else.\n        if shifts == 0 {\n            item\n        } else if shifts == 1 {\n            item * TWO_POW_8\n        } else if shifts == 2 {\n            item * TWO_POW_16\n        } else if shifts == 3 {\n            item * TWO_POW_24\n        } else {\n            // Doesn't make sense, but it's most likely called on 0 anyway.\n            0\n        }\n    }\n}\n\n// Shift by 8 bits to the right between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise divides by 256.\nfn rshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        item >> (8 * shifts)\n    } else {\n        // Division wouldn't work on `Field`.\n        if shifts == 0 {\n            item\n        } else if shifts == 1 {\n            item / TWO_POW_8\n        } else if shifts == 2 {\n            item / TWO_POW_16\n        } else if shifts == 3 {\n            item / TWO_POW_24\n        } else {\n            0\n        }\n    }\n}\n\n// Zero out all bytes between the end of the message and where the length is appended,\n// then write the length into the last 8 bytes of the block.\nunconstrained fn attach_len_to_msg_block(\n    mut msg_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n    message_size: u32,\n) -> MSG_BLOCK {\n    // We assume that `msg_byte_ptr` is less than 57 because if not then it is reset to zero before calling this function.\n    // In any case, fill blocks up with zeros until the last 64 bits (i.e. until msg_byte_ptr = 56).\n    // There can be one item which has to be partially zeroed.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        // Index of the block in which we find the item we need to partially zero.\n        let i = msg_byte_ptr / INT_SIZE;\n        let zeros = INT_SIZE - modulo;\n        msg_block[i] = set_item_zeros(msg_block[i], zeros as u8);\n        msg_byte_ptr = msg_byte_ptr + zeros;\n    }\n\n    // The rest can be zeroed without bit shifting anything.\n    for i in (msg_byte_ptr / INT_SIZE)..INT_SIZE_PTR {\n        msg_block[i] = 0;\n    }\n\n    // Set the last two 4 byte ints as the first/second half of the 8 bytes of the length.\n    let len = 8 * message_size;\n    let len_bytes: [u8; 8] = (len as Field).to_be_bytes();\n    for i in 0..=1 {\n        let shift = i * 4;\n        msg_block[INT_SIZE_PTR + i] = make_item(\n            len_bytes[shift],\n            len_bytes[shift + 1],\n            len_bytes[shift + 2],\n            len_bytes[shift + 3],\n        );\n    }\n    msg_block\n}\n\n// Verify that the message length was correctly written by `attach_len_to_msg_block`,\n// and that everything between the byte pointer and the size pointer was zeroed,\n// and that everything before the byte pointer was untouched.\nfn verify_msg_len(\n    msg_block: MSG_BLOCK,\n    last_block: MSG_BLOCK,\n    msg_byte_ptr: BLOCK_BYTE_PTR,\n    message_size: u32,\n) {\n    // Check zeros up to the size pointer.\n    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_SIZE_PTR);\n\n    // Check that up to the pointer we match the last block.\n    verify_msg_block_equals_last(msg_block, last_block, msg_byte_ptr);\n\n    // We verify the message length was inserted correctly by reversing the byte decomposition.\n    let mut reconstructed_len: u64 = 0;\n    for i in INT_SIZE_PTR..INT_BLOCK_SIZE {\n        reconstructed_len = reconstructed_len * TWO_POW_32;\n        reconstructed_len = reconstructed_len + msg_block[i] as u64;\n    }\n    let len = 8 * message_size as u64;\n    assert_eq(reconstructed_len, len);\n}\n\n// Perform the final compression, then transform the `STATE` into `HASH`.\nfn hash_final_block(msg_block: MSG_BLOCK, mut state: STATE) -> HASH {\n    let mut out_h: HASH = [0; 32]; // Digest as sequence of bytes\n    // Hash final padded block\n    state = sha256_compression(msg_block, state);\n\n    // Return final hash as byte array\n    for j in 0..8 {\n        let h_bytes: [u8; 4] = (state[j] as Field).to_be_bytes();\n        for k in 0..4 {\n            out_h[4 * j + k] = h_bytes[k];\n        }\n    }\n\n    out_h\n}\n\nmod equivalence_test {\n\n    #[test]\n    fn test_implementations_agree(msg: [u8; 100], message_size: u64) {\n        let message_size = message_size % 100;\n        let unconstrained_sha = unsafe { super::__sha256_var(msg, message_size as u32) };\n        let sha = super::sha256_var(msg, message_size);\n        assert_eq(sha, unconstrained_sha);\n    }\n}\n"
     },
@@ -4328,45 +4336,37 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/router_contract/src/main.nr",
       "source": "mod test;\nmod utils;\n\nuse dep::aztec::macros::aztec;\n\n/// The purpose of this contract is to perform a check in public without revealing what contract enqueued the public\n/// call. This is achieved by having a private function on this contract that enqueues the public call and hence\n/// the `msg_sender` in the public call is the address of this contract.\n#[aztec]\npub contract Router {\n    use aztec::{macros::functions::{internal, private, public, view}, utils::comparison::compare};\n\n    // docs:start:check_timestamp\n    /// Asserts that the current timestamp in the enqueued public call satisfies the `operation` with respect\n    /// to the `value.\n    #[private]\n    fn check_timestamp(operation: u8, value: u64) {\n        Router::at(context.this_address())._check_timestamp(operation, value).enqueue_view(\n            &mut context,\n        );\n    }\n\n    #[public]\n    #[internal]\n    #[view]\n    fn _check_timestamp(operation: u8, value: u64) {\n        let lhs_field = context.timestamp() as Field;\n        let rhs_field = value as Field;\n        assert(compare(lhs_field, operation, rhs_field), \"Timestamp mismatch.\");\n    }\n    // docs:end:check_timestamp\n\n    /// Asserts that the current block number in the enqueued public call satisfies the `operation` with respect\n    /// to the `value.\n    #[private]\n    fn check_block_number(operation: u8, value: u32) {\n        Router::at(context.this_address())._check_block_number(operation, value).enqueue_view(\n            &mut context,\n        );\n    }\n\n    #[public]\n    #[internal]\n    #[view]\n    fn _check_block_number(operation: u8, value: u32) {\n        assert(\n            compare(context.block_number() as Field, operation, value as Field),\n            \"Block number mismatch.\",\n        );\n    }\n}\n"
     },
-    "53": {
+    "6": {
+      "path": "std/collections/bounded_vec.nr",
+      "source": "use crate::{cmp::Eq, convert::From, runtime::is_unconstrained, static_assert};\n\n/// A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it\n/// is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented\n/// via slices and thus is not subject to the same restrictions slices are (notably, nested\n/// slices - and thus nested vectors as well - are disallowed).\n///\n/// Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by\n/// pushing an additional element is also more efficient - the length only needs to be increased\n/// by one.\n///\n/// For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there\n/// is a reasonable maximum bound that can be placed on the vector.\n///\n/// Example:\n///\n/// ```noir\n/// let mut vector: BoundedVec<Field, 10> = BoundedVec::new();\n/// for i in 0..5 {\n///     vector.push(i);\n/// }\n/// assert(vector.len() == 5);\n/// assert(vector.max_len() == 10);\n/// ```\npub struct BoundedVec<T, let MaxLen: u32> {\n    storage: [T; MaxLen],\n    len: u32,\n}\n\nimpl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {\n    /// Creates a new, empty vector of length zero.\n    ///\n    /// Since this container is backed by an array internally, it still needs an initial value\n    /// to give each element. To resolve this, each element is zeroed internally. This value\n    /// is guaranteed to be inaccessible unless `get_unchecked` is used.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();\n    /// assert(empty_vector.len() == 0);\n    /// ```\n    ///\n    /// Note that whenever calling `new` the maximum length of the vector should always be specified\n    /// via a type signature:\n    ///\n    /// ```noir\n    /// fn good() -> BoundedVec<Field, 10> {\n    ///     // Ok! MaxLen is specified with a type annotation\n    ///     let v1: BoundedVec<Field, 3> = BoundedVec::new();\n    ///     let v2 = BoundedVec::new();\n    ///\n    ///     // Ok! MaxLen is known from the type of `good`'s return value\n    ///     v2\n    /// }\n    ///\n    /// fn bad() {\n    ///     // Error: Type annotation needed\n    ///     // The compiler can't infer `MaxLen` from the following code:\n    ///     let mut v3 = BoundedVec::new();\n    ///     v3.push(5);\n    /// }\n    /// ```\n    ///\n    /// This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions\n    /// but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a\n    /// constraint failure at runtime when the vec is pushed to.\n    pub fn new() -> Self {\n        let zeroed = crate::mem::zeroed();\n        BoundedVec { storage: [zeroed; MaxLen], len: 0 }\n    }\n\n    /// Retrieves an element from the vector at the given index, starting from zero.\n    ///\n    /// If the given index is equal to or greater than the length of the vector, this\n    /// will issue a constraint failure.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n    ///     let first = v.get(0);\n    ///     let last = v.get(v.len() - 1);\n    ///     assert(first != last);\n    /// }\n    /// ```\n    pub fn get(self, index: u32) -> T {\n        assert(index < self.len, \"Attempted to read past end of BoundedVec\");\n        self.get_unchecked(index)\n    }\n\n    /// Retrieves an element from the vector at the given index, starting from zero, without\n    /// performing a bounds check.\n    ///\n    /// Since this function does not perform a bounds check on length before accessing the element,\n    /// it is unsafe! Use at your own risk!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn sum_of_first_three<let N: u32>(v: BoundedVec<u32, N>) -> u32 {\n    ///     // Always ensure the length is larger than the largest\n    ///     // index passed to get_unchecked\n    ///     assert(v.len() > 2);\n    ///     let first = v.get_unchecked(0);\n    ///     let second = v.get_unchecked(1);\n    ///     let third = v.get_unchecked(2);\n    ///     first + second + third\n    /// }\n    /// ```\n    pub fn get_unchecked(self, index: u32) -> T {\n        self.storage[index]\n    }\n\n    /// Writes an element to the vector at the given index, starting from zero.\n    ///\n    /// If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n    ///     let first = v.get(0);\n    ///     assert(first != 42);\n    ///     v.set(0, 42);\n    ///     let new_first = v.get(0);\n    ///     assert(new_first == 42);\n    /// }\n    /// ```\n    pub fn set(&mut self, index: u32, value: T) {\n        assert(index < self.len, \"Attempted to write past end of BoundedVec\");\n        self.set_unchecked(index, value)\n    }\n\n    /// Writes an element to the vector at the given index, starting from zero, without performing a bounds check.\n    ///\n    /// Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn set_unchecked_example() {\n    ///     let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n    ///     vec.extend_from_array([1, 2]);\n    ///\n    ///     // Here we're safely writing within the valid range of `vec`\n    ///     // `vec` now has the value [42, 2]\n    ///     vec.set_unchecked(0, 42);\n    ///\n    ///     // We can then safely read this value back out of `vec`.\n    ///     // Notice that we use the checked version of `get` which would prevent reading unsafe values.\n    ///     assert_eq(vec.get(0), 42);\n    ///\n    ///     // We've now written past the end of `vec`.\n    ///     // As this index is still within the maximum potential length of `v`,\n    ///     // it won't cause a constraint failure.\n    ///     vec.set_unchecked(2, 42);\n    ///     println(vec);\n    ///\n    ///     // This will write past the end of the maximum potential length of `vec`,\n    ///     // it will then trigger a constraint failure.\n    ///     vec.set_unchecked(5, 42);\n    ///     println(vec);\n    /// }\n    /// ```\n    pub fn set_unchecked(&mut self, index: u32, value: T) {\n        self.storage[index] = value;\n    }\n\n    /// Pushes an element to the end of the vector. This increases the length\n    /// of the vector by one.\n    ///\n    /// Panics if the new length of the vector will be greater than the max length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n    ///\n    /// v.push(1);\n    /// v.push(2);\n    ///\n    /// // Panics with failed assertion \"push out of bounds\"\n    /// v.push(3);\n    /// ```\n    pub fn push(&mut self, elem: T) {\n        assert(self.len < MaxLen, \"push out of bounds\");\n\n        self.storage[self.len] = elem;\n        self.len += 1;\n    }\n\n    /// Returns the current length of this vector\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 4> = BoundedVec::new();\n    /// assert(v.len() == 0);\n    ///\n    /// v.push(100);\n    /// assert(v.len() == 1);\n    ///\n    /// v.push(200);\n    /// v.push(300);\n    /// v.push(400);\n    /// assert(v.len() == 4);\n    ///\n    /// let _ = v.pop();\n    /// let _ = v.pop();\n    /// assert(v.len() == 2);\n    /// ```\n    pub fn len(self) -> u32 {\n        self.len\n    }\n\n    /// Returns the maximum length of this vector. This is always\n    /// equal to the `MaxLen` parameter this vector was initialized with.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n    ///\n    /// assert(v.max_len() == 5);\n    /// v.push(10);\n    /// assert(v.max_len() == 5);\n    /// ```\n    pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u32 {\n        MaxLen\n    }\n\n    /// Returns the internal array within this vector.\n    ///\n    /// Since arrays in Noir are immutable, mutating the returned storage array will not mutate\n    /// the storage held internally by this vector.\n    ///\n    /// Note that uninitialized elements may be zeroed out!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n    ///\n    /// assert(v.storage() == [0, 0, 0, 0, 0]);\n    ///\n    /// v.push(57);\n    /// assert(v.storage() == [57, 0, 0, 0, 0]);\n    /// ```\n    pub fn storage(self) -> [T; MaxLen] {\n        self.storage\n    }\n\n    /// Pushes each element from the given array to this vector.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n    /// vec.extend_from_array([2, 4]);\n    ///\n    /// assert(vec.len == 2);\n    /// assert(vec.get(0) == 2);\n    /// assert(vec.get(1) == 4);\n    /// ```\n    pub fn extend_from_array<let Len: u32>(&mut self, array: [T; Len]) {\n        let new_len = self.len + array.len();\n        assert(new_len <= MaxLen, \"extend_from_array out of bounds\");\n        for i in 0..array.len() {\n            self.storage[self.len + i] = array[i];\n        }\n        self.len = new_len;\n    }\n\n    /// Pushes each element from the given slice to this vector.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n    /// vec.extend_from_slice(&[2, 4]);\n    ///\n    /// assert(vec.len == 2);\n    /// assert(vec.get(0) == 2);\n    /// assert(vec.get(1) == 4);\n    /// ```\n    pub fn extend_from_slice(&mut self, slice: [T]) {\n        let new_len = self.len + slice.len();\n        assert(new_len <= MaxLen, \"extend_from_slice out of bounds\");\n        for i in 0..slice.len() {\n            self.storage[self.len + i] = slice[i];\n        }\n        self.len = new_len;\n    }\n\n    /// Pushes each element from the other vector to this vector. The length of\n    /// the other vector is left unchanged.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// ```noir\n    /// let mut v1: BoundedVec<Field, 5> = BoundedVec::new();\n    /// let mut v2: BoundedVec<Field, 7> = BoundedVec::new();\n    ///\n    /// v2.extend_from_array([1, 2, 3]);\n    /// v1.extend_from_bounded_vec(v2);\n    ///\n    /// assert(v1.storage() == [1, 2, 3, 0, 0]);\n    /// assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);\n    /// ```\n    pub fn extend_from_bounded_vec<let Len: u32>(&mut self, vec: BoundedVec<T, Len>) {\n        let append_len = vec.len();\n        let new_len = self.len + append_len;\n        assert(new_len <= MaxLen, \"extend_from_bounded_vec out of bounds\");\n\n        if is_unconstrained() {\n            for i in 0..append_len {\n                self.storage[self.len + i] = vec.get_unchecked(i);\n            }\n        } else {\n            let mut exceeded_len = false;\n            for i in 0..Len {\n                exceeded_len |= i == append_len;\n                if !exceeded_len {\n                    self.storage[self.len + i] = vec.get_unchecked(i);\n                }\n            }\n        }\n        self.len = new_len;\n    }\n\n    /// Creates a new vector, populating it with values derived from an array input.\n    /// The maximum length of the vector is determined based on the type signature.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])\n    /// ```\n    pub fn from_array<let Len: u32>(array: [T; Len]) -> Self {\n        static_assert(Len <= MaxLen, \"from array out of bounds\");\n        let mut vec: BoundedVec<T, MaxLen> = BoundedVec::new();\n        vec.extend_from_array(array);\n        vec\n    }\n\n    /// Pops the element at the end of the vector. This will decrease the length\n    /// of the vector by one.\n    ///\n    /// Panics if the vector is empty.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n    /// v.push(1);\n    /// v.push(2);\n    ///\n    /// let two = v.pop();\n    /// let one = v.pop();\n    ///\n    /// assert(two == 2);\n    /// assert(one == 1);\n    ///\n    /// // error: cannot pop from an empty vector\n    /// let _ = v.pop();\n    /// ```\n    pub fn pop(&mut self) -> T {\n        assert(self.len > 0);\n        self.len -= 1;\n\n        let elem = self.storage[self.len];\n        self.storage[self.len] = crate::mem::zeroed();\n        elem\n    }\n\n    /// Returns true if the given predicate returns true for any element\n    /// in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<u32, 3> = BoundedVec::new();\n    /// v.extend_from_array([2, 4, 6]);\n    ///\n    /// let all_even = !v.any(|elem: u32| elem % 2 != 0);\n    /// assert(all_even);\n    /// ```\n    pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = false;\n        if is_unconstrained() {\n            for i in 0..self.len {\n                ret |= predicate(self.storage[i]);\n            }\n        } else {\n            let mut ret = false;\n            let mut exceeded_len = false;\n            for i in 0..MaxLen {\n                exceeded_len |= i == self.len;\n                if !exceeded_len {\n                    ret |= predicate(self.storage[i]);\n                }\n            }\n        }\n        ret\n    }\n\n    /// Creates a new vector of equal size by calling a closure on each element in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n    /// let result = vec.map(|value| value * 2);\n    ///\n    /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n    /// assert_eq(result, expected);\n    /// ```\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen> {\n        let mut ret = BoundedVec::new();\n        ret.len = self.len();\n\n        if is_unconstrained() {\n            for i in 0..self.len() {\n                ret.storage[i] = f(self.get_unchecked(i));\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i < self.len() {\n                    ret.storage[i] = f(self.get_unchecked(i));\n                }\n            }\n        }\n\n        ret\n    }\n\n    /// Creates a new vector of equal size by calling a closure on each element\n    /// in this vector, along with its index.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n    /// let result = vec.mapi(|i, value| i + value * 2);\n    ///\n    /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n    /// assert_eq(result, expected);\n    /// ```\n    pub fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> BoundedVec<U, MaxLen> {\n        let mut ret = BoundedVec::new();\n        ret.len = self.len();\n\n        if is_unconstrained() {\n            for i in 0..self.len() {\n                ret.storage[i] = f(i, self.get_unchecked(i));\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i < self.len() {\n                    ret.storage[i] = f(i, self.get_unchecked(i));\n                }\n            }\n        }\n\n        ret\n    }\n\n    /// Calls a closure on each element in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n    /// let mut result = BoundedVec::<u32, 4>::new();\n    /// vec.for_each(|value| result.push(value * 2));\n    ///\n    /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n    /// assert_eq(result, expected);\n    /// ```\n    pub fn for_each<Env>(self, f: fn[Env](T) -> ()) {\n        if is_unconstrained() {\n            for i in 0..self.len() {\n                f(self.get_unchecked(i));\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i < self.len() {\n                    f(self.get_unchecked(i));\n                }\n            }\n        }\n    }\n\n    /// Calls a closure on each element in this vector, along with its index.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n    /// let mut result = BoundedVec::<u32, 4>::new();\n    /// vec.for_eachi(|i, value| result.push(i + value * 2));\n    ///\n    /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n    /// assert_eq(result, expected);\n    /// ```\n    pub fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ()) {\n        if is_unconstrained() {\n            for i in 0..self.len() {\n                f(i, self.get_unchecked(i));\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i < self.len() {\n                    f(i, self.get_unchecked(i));\n                }\n            }\n        }\n    }\n\n    /// Creates a new BoundedVec from the given array and length.\n    /// The given length must be less than or equal to the length of the array.\n    ///\n    /// This function will zero out any elements at or past index `len` of `array`.\n    /// This incurs an extra runtime cost of O(MaxLen). If you are sure your array is\n    /// zeroed after that index, you can use `from_parts_unchecked` to remove the extra loop.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n    /// assert_eq(vec.len(), 3);\n    /// ```\n    pub fn from_parts(mut array: [T; MaxLen], len: u32) -> Self {\n        assert(len <= MaxLen);\n        let zeroed = crate::mem::zeroed();\n\n        if is_unconstrained() {\n            for i in len..MaxLen {\n                array[i] = zeroed;\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i >= len {\n                    array[i] = zeroed;\n                }\n            }\n        }\n\n        BoundedVec { storage: array, len }\n    }\n\n    /// Creates a new BoundedVec from the given array and length.\n    /// The given length must be less than or equal to the length of the array.\n    ///\n    /// This function is unsafe because it expects all elements past the `len` index\n    /// of `array` to be zeroed, but does not check for this internally. Use `from_parts`\n    /// for a safe version of this function which does zero out any indices past the\n    /// given length. Invalidating this assumption can notably cause `BoundedVec::eq`\n    /// to give incorrect results since it will check even elements past `len`.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n    /// assert_eq(vec.len(), 3);\n    ///\n    /// // invalid use!\n    /// let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n    /// let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n    ///\n    /// // both vecs have length 3 so we'd expect them to be equal, but this\n    /// // fails because elements past the length are still checked in eq\n    /// assert_eq(vec1, vec2); // fails\n    /// ```\n    pub fn from_parts_unchecked(array: [T; MaxLen], len: u32) -> Self {\n        assert(len <= MaxLen);\n        BoundedVec { storage: array, len }\n    }\n}\n\nimpl<T, let MaxLen: u32> Eq for BoundedVec<T, MaxLen>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: BoundedVec<T, MaxLen>) -> bool {\n        // TODO: https://github.com/noir-lang/noir/issues/4837\n        //\n        // We make the assumption that the user has used the proper interface for working with `BoundedVec`s\n        // rather than directly manipulating the internal fields as this can result in an inconsistent internal state.\n        if self.len == other.len {\n            self.storage == other.storage\n        } else {\n            false\n        }\n    }\n}\n\nimpl<T, let MaxLen: u32, let Len: u32> From<[T; Len]> for BoundedVec<T, MaxLen> {\n    fn from(array: [T; Len]) -> BoundedVec<T, MaxLen> {\n        BoundedVec::from_array(array)\n    }\n}\n\nmod bounded_vec_tests {\n\n    mod get {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n        fn panics_when_reading_elements_past_end_of_vec() {\n            let vec: BoundedVec<Field, 5> = BoundedVec::new();\n\n            crate::println(vec.get(0));\n        }\n    }\n\n    mod set {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn set_updates_values_properly() {\n            let mut vec = BoundedVec::from_array([0, 0, 0, 0, 0]);\n\n            vec.set(0, 42);\n            assert_eq(vec.storage, [42, 0, 0, 0, 0]);\n\n            vec.set(1, 43);\n            assert_eq(vec.storage, [42, 43, 0, 0, 0]);\n\n            vec.set(2, 44);\n            assert_eq(vec.storage, [42, 43, 44, 0, 0]);\n\n            vec.set(1, 10);\n            assert_eq(vec.storage, [42, 10, 44, 0, 0]);\n\n            vec.set(0, 0);\n            assert_eq(vec.storage, [0, 10, 44, 0, 0]);\n        }\n\n        #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n        fn panics_when_writing_elements_past_end_of_vec() {\n            let mut vec: BoundedVec<Field, 5> = BoundedVec::new();\n            vec.set(0, 42);\n\n            // Need to use println to avoid DIE removing the write operation.\n            crate::println(vec.get(0));\n        }\n    }\n\n    mod map {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn applies_function_correctly() {\n            // docs:start:bounded-vec-map-example\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.map(|value| value * 2);\n            // docs:end:bounded-vec-map-example\n            let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn applies_function_that_changes_return_type() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.map(|value| (value * 2) as Field);\n            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn does_not_apply_function_past_len() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n            let result = vec.map(|value| if value == 0 { 5 } else { value });\n            let expected = BoundedVec::from_array([5, 1]);\n\n            assert_eq(result, expected);\n            assert_eq(result.get_unchecked(2), 0);\n        }\n    }\n\n    mod mapi {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn applies_function_correctly() {\n            // docs:start:bounded-vec-mapi-example\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.mapi(|i, value| i + value * 2);\n            // docs:end:bounded-vec-mapi-example\n            let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn applies_function_that_changes_return_type() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.mapi(|i, value| (i + value * 2) as Field);\n            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 5, 8, 11]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn does_not_apply_function_past_len() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n            let result = vec.mapi(|_, value| if value == 0 { 5 } else { value });\n            let expected = BoundedVec::from_array([5, 1]);\n\n            assert_eq(result, expected);\n            assert_eq(result.get_unchecked(2), 0);\n        }\n    }\n\n    mod for_each {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        // map in terms of for_each\n        fn for_each_map<T, U, Env, let MaxLen: u32>(\n            input: BoundedVec<T, MaxLen>,\n            f: fn[Env](T) -> U,\n        ) -> BoundedVec<U, MaxLen> {\n            let mut output = BoundedVec::<U, MaxLen>::new();\n            let output_ref = &mut output;\n            input.for_each(|x| output_ref.push(f(x)));\n            output\n        }\n\n        #[test]\n        fn smoke_test() {\n            let mut acc = 0;\n            let acc_ref = &mut acc;\n            // docs:start:bounded-vec-for-each-example\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n            vec.for_each(|value| { *acc_ref += value; });\n            // docs:end:bounded-vec-for-each-example\n            assert_eq(acc, 6);\n        }\n\n        #[test]\n        fn applies_function_correctly() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = for_each_map(vec, |value| value * 2);\n            let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn applies_function_that_changes_return_type() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = for_each_map(vec, |value| (value * 2) as Field);\n            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn does_not_apply_function_past_len() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n            let result = for_each_map(vec, |value| if value == 0 { 5 } else { value });\n            let expected = BoundedVec::from_array([5, 1]);\n\n            assert_eq(result, expected);\n            assert_eq(result.get_unchecked(2), 0);\n        }\n    }\n\n    mod for_eachi {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        // mapi in terms of for_eachi\n        fn for_eachi_mapi<T, U, Env, let MaxLen: u32>(\n            input: BoundedVec<T, MaxLen>,\n            f: fn[Env](u32, T) -> U,\n        ) -> BoundedVec<U, MaxLen> {\n            let mut output = BoundedVec::<U, MaxLen>::new();\n            let output_ref = &mut output;\n            input.for_eachi(|i, x| output_ref.push(f(i, x)));\n            output\n        }\n\n        #[test]\n        fn smoke_test() {\n            let mut acc = 0;\n            let acc_ref = &mut acc;\n            // docs:start:bounded-vec-for-eachi-example\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n            vec.for_eachi(|i, value| { *acc_ref += i * value; });\n            // docs:end:bounded-vec-for-eachi-example\n\n            // 0 * 1 + 1 * 2 + 2 * 3\n            assert_eq(acc, 8);\n        }\n\n        #[test]\n        fn applies_function_correctly() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = for_eachi_mapi(vec, |i, value| i + value * 2);\n            let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn applies_function_that_changes_return_type() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = for_eachi_mapi(vec, |i, value| (i + value * 2) as Field);\n            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 5, 8, 11]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn does_not_apply_function_past_len() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n            let result = for_eachi_mapi(vec, |_, value| if value == 0 { 5 } else { value });\n            let expected = BoundedVec::from_array([5, 1]);\n\n            assert_eq(result, expected);\n            assert_eq(result.get_unchecked(2), 0);\n        }\n    }\n\n    mod from_array {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn empty() {\n            let empty_array: [Field; 0] = [];\n            let bounded_vec = BoundedVec::from_array([]);\n\n            assert_eq(bounded_vec.max_len(), 0);\n            assert_eq(bounded_vec.len(), 0);\n            assert_eq(bounded_vec.storage(), empty_array);\n        }\n\n        #[test]\n        fn equal_len() {\n            let array = [1, 2, 3];\n            let bounded_vec = BoundedVec::from_array(array);\n\n            assert_eq(bounded_vec.max_len(), 3);\n            assert_eq(bounded_vec.len(), 3);\n            assert_eq(bounded_vec.storage(), array);\n        }\n\n        #[test]\n        fn max_len_greater_then_array_len() {\n            let array = [1, 2, 3];\n            let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array(array);\n\n            assert_eq(bounded_vec.max_len(), 10);\n            assert_eq(bounded_vec.len(), 3);\n            assert_eq(bounded_vec.get(0), 1);\n            assert_eq(bounded_vec.get(1), 2);\n            assert_eq(bounded_vec.get(2), 3);\n        }\n\n        #[test(should_fail_with = \"from array out of bounds\")]\n        fn max_len_lower_then_array_len() {\n            let _: BoundedVec<Field, 2> = BoundedVec::from_array([0; 3]);\n        }\n    }\n\n    mod trait_from {\n        use crate::collections::bounded_vec::BoundedVec;\n        use crate::convert::From;\n\n        #[test]\n        fn simple() {\n            let array = [1, 2];\n            let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from(array);\n\n            assert_eq(bounded_vec.max_len(), 10);\n            assert_eq(bounded_vec.len(), 2);\n            assert_eq(bounded_vec.get(0), 1);\n            assert_eq(bounded_vec.get(1), 2);\n        }\n    }\n\n    mod trait_eq {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn empty_equality() {\n            let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n            let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n\n            assert_eq(bounded_vec1, bounded_vec2);\n        }\n\n        #[test]\n        fn inequality() {\n            let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n            let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n            bounded_vec1.push(1);\n            bounded_vec2.push(2);\n\n            assert(bounded_vec1 != bounded_vec2);\n        }\n    }\n\n    mod from_parts {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn from_parts() {\n            // docs:start:from-parts\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n            assert_eq(vec.len(), 3);\n\n            // Any elements past the given length are zeroed out, so these\n            // two BoundedVecs will be completely equal\n            let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 1], 3);\n            let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 2], 3);\n            assert_eq(vec1, vec2);\n            // docs:end:from-parts\n        }\n\n        #[test]\n        fn from_parts_unchecked() {\n            // docs:start:from-parts-unchecked\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n            assert_eq(vec.len(), 3);\n\n            // invalid use!\n            let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n            let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n\n            // both vecs have length 3 so we'd expect them to be equal, but this\n            // fails because elements past the length are still checked in eq\n            assert(vec1 != vec2);\n            // docs:end:from-parts-unchecked\n        }\n    }\n}\n"
+    },
+    "62": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/capsules/mod.nr",
       "source": "use crate::oracle::capsules;\nuse protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// A dynamically sized array backed by PXE's non-volatile database (called capsules). Values are persisted until\n/// deleted, so they can be e.g. stored during simulation of a transaction and later retrieved during witness\n/// generation. All values are scoped per contract address, so external contracts cannot access them.\npub struct CapsuleArray<T> {\n    contract_address: AztecAddress,\n    /// The base slot is where the array length is stored in capsules. Array elements are stored in consecutive slots\n    /// after the base slot. For example, with base slot 5: the length is at slot 5, the first element (index 0) is at\n    /// slot 6, the second element (index 1) is at slot 7, and so on.\n    base_slot: Field,\n}\n\nimpl<T> CapsuleArray<T> {\n    /// Returns a CapsuleArray connected to a contract's capsules at a base slot. Array elements are stored in\n    /// contiguous slots following the base slot, so there should be sufficient space between array base slots to\n    /// accommodate elements. A reasonable strategy is to make the base slot a hash of a unique value.\n    pub unconstrained fn at(contract_address: AztecAddress, base_slot: Field) -> Self {\n        Self { contract_address, base_slot }\n    }\n\n    /// Returns the number of elements stored in the array.\n    pub unconstrained fn len(self) -> u32 {\n        // An uninitialized array defaults to a length of 0.\n        capsules::load(self.contract_address, self.base_slot).unwrap_or(0) as u32\n    }\n\n    /// Stores a value at the end of the array.\n    pub unconstrained fn push<let N: u32>(self, value: T)\n    where\n        T: Serialize<N>,\n    {\n        let current_length = self.len();\n\n        // The slot corresponding to the index `current_length` is the first slot immediately after the end of the\n        // array, which is where we want to place the new value.\n        capsules::store(self.contract_address, self.slot_at(current_length), value);\n\n        // Then we simply update the length.\n        let new_length = current_length + 1;\n        capsules::store(self.contract_address, self.base_slot, new_length);\n    }\n\n    /// Retrieves the value stored in the array at `index`. Throws if the index is out of bounds.\n    pub unconstrained fn get<let N: u32>(self, index: u32) -> T\n    where\n        T: Deserialize<N>,\n    {\n        assert(index < self.len(), \"Attempted to read past the length of a CapsuleArray\");\n\n        capsules::load(self.contract_address, self.slot_at(index)).unwrap()\n    }\n\n    /// Deletes the value stored in the array at `index`. Throws if the index is out of bounds.\n    pub unconstrained fn remove(self, index: u32) {\n        let current_length = self.len();\n        assert(index < current_length, \"Attempted to delete past the length of a CapsuleArray\");\n\n        // In order to be able to remove elements at arbitrary indices, we need to shift the entire contents of the\n        // array past the removed element one slot backward so that we don't end up with a gap and preserve the\n        // contiguous slots. We can skip this when deleting the last element however.\n        if index != current_length - 1 {\n            // The source and destination regions overlap, but `copy` supports this.\n            capsules::copy(\n                self.contract_address,\n                self.slot_at(index + 1),\n                self.slot_at(index),\n                current_length - index - 1,\n            );\n        }\n\n        // We can now delete the last element (which has either been copied to the slot immediately before it, or was\n        // the element we meant to delete in the first place) and update the length.\n        capsules::delete(self.contract_address, self.slot_at(current_length - 1));\n        capsules::store(self.contract_address, self.base_slot, current_length - 1);\n    }\n\n    /// Iterates over the entire array, calling the callback with all values and their array index. The order in which\n    /// values are processed is arbitrary.\n    ///\n    /// It is safe to delete the current element (and only the current element) from inside the callback via `remove`:\n    /// ```noir\n    /// array.for_each(|index, value| {\n    ///   if some_condition(value) {\n    ///     array.remove(index); // safe only for this index\n    ///   }\n    /// }\n    /// ```\n    ///\n    /// If all elements in the array need to iterated over and then removed, then using `for_each` results in optimal\n    /// efficiency.\n    ///\n    /// It is **not** safe to push new elements into the array from inside the callback.\n    pub unconstrained fn for_each<Env, let N: u32>(self, f: unconstrained fn[Env](u32, T) -> ())\n    where\n        T: Deserialize<N>,\n    {\n        // Iterating over all elements is simple, but we want to do it in such a way that a) deleting the current\n        // element is safe to do, and b) deleting *all* elements is optimally efficient. This is because CapsuleArrays\n        // are typically used to hold pending tasks, so iterating them while clearing completed tasks (sometimes\n        // unconditionally, resulting in a full clear) is a very common access pattern.\n        //\n        // The way we achieve this is by iterating backwards: each element can always be deleted since it won't change\n        // any preceding (lower) indices, and if every element is deleted then every element will (in turn) be the last\n        // element. This results in an optimal full clear since `remove` will be able to skip the `capsules::copy` call\n        // to shift any elements past the deleted one (because there will be none).\n        let mut i = self.len();\n        while i > 0 {\n            i -= 1;\n            f(i, self.get(i));\n        }\n    }\n\n    unconstrained fn slot_at(self, index: u32) -> Field {\n        // Elements are stored immediately after the base slot, so we add 1 to it to compute the slot for the first\n        // element.\n        self.base_slot + 1 + index as Field\n    }\n}\n\nmod test {\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use super::CapsuleArray;\n    use protocol_types::address::AztecAddress;\n\n    global SLOT: Field = 1230;\n\n    unconstrained fn setup() -> AztecAddress {\n        TestEnvironment::new().utility().this_address()\n    }\n\n    #[test]\n    unconstrained fn empty_array() {\n        let contract_address = setup();\n\n        let array: CapsuleArray<Field> = CapsuleArray::at(contract_address, SLOT);\n        assert_eq(array.len(), 0);\n    }\n\n    #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n    unconstrained fn empty_array_read() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n        let _: Field = array.get(0);\n    }\n\n    #[test]\n    unconstrained fn array_push() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n        array.push(5);\n\n        assert_eq(array.len(), 1);\n        assert_eq(array.get(0), 5);\n    }\n\n    #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n    unconstrained fn read_past_len() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n        array.push(5);\n\n        let _ = array.get(1);\n    }\n\n    #[test]\n    unconstrained fn array_remove_last() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n\n        array.push(5);\n        array.remove(0);\n\n        assert_eq(array.len(), 0);\n    }\n\n    #[test]\n    unconstrained fn array_remove_some() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n\n        array.push(7);\n        array.push(8);\n        array.push(9);\n\n        assert_eq(array.len(), 3);\n        assert_eq(array.get(0), 7);\n        assert_eq(array.get(1), 8);\n        assert_eq(array.get(2), 9);\n\n        array.remove(1);\n\n        assert_eq(array.len(), 2);\n        assert_eq(array.get(0), 7);\n        assert_eq(array.get(1), 9);\n    }\n\n    #[test]\n    unconstrained fn array_remove_all() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n\n        array.push(7);\n        array.push(8);\n        array.push(9);\n\n        array.remove(1);\n        array.remove(1);\n        array.remove(0);\n\n        assert_eq(array.len(), 0);\n    }\n\n    #[test]\n    unconstrained fn for_each_called_with_all_elements() {\n        let contract_address = setup();\n        let array = CapsuleArray::at(contract_address, SLOT);\n\n        array.push(4);\n        array.push(5);\n        array.push(6);\n\n        // We store all values that we were called with and check that all (value, index) tuples are present. Note that\n        // we do not care about the order in which each tuple was passed to the closure.\n        let called_with = &mut BoundedVec::<(u32, Field), 3>::new();\n        array.for_each(|index, value| { called_with.push((index, value)); });\n\n        assert_eq(called_with.len(), 3);\n        assert(called_with.any(|(index, value)| (index == 0) & (value == 4)));\n        assert(called_with.any(|(index, value)| (index == 1) & (value == 5)));\n        assert(called_with.any(|(index, value)| (index == 2) & (value == 6)));\n    }\n\n    #[test]\n    unconstrained fn for_each_remove_some() {\n        let contract_address = setup();\n        let array = CapsuleArray::at(contract_address, SLOT);\n\n        array.push(4);\n        array.push(5);\n        array.push(6);\n\n        array.for_each(|index, _| {\n            if index == 1 {\n                array.remove(index);\n            }\n        });\n\n        assert_eq(array.len(), 2);\n        assert_eq(array.get(0), 4);\n        assert_eq(array.get(1), 6);\n    }\n\n    #[test]\n    unconstrained fn for_each_remove_all() {\n        let contract_address = setup();\n        let array = CapsuleArray::at(contract_address, SLOT);\n\n        array.push(4);\n        array.push(5);\n        array.push(6);\n\n        array.for_each(|index, _| { array.remove(index); });\n\n        assert_eq(array.len(), 0);\n    }\n\n    // TODO: uncomment this test once OracleMock::count is implemented in the stdlib.\n    // #[test]\n    // unconstrained fn for_each_remove_all_no_copy() {\n    //     let contract_address = setup();\n    //     let array = CapsuleArray::at(contract_address, SLOT);\n\n    //     array.push(4);\n    //     array.push(5);\n    //     array.push(6);\n\n    //     // We test that the copyCapsule was never called, which is the expensive operation we want to avoid.\n    //     let mock = OracleMock::mock(\"copyCapsule\");\n\n    //     array.for_each(|index, _| {\n    //         array.remove(index);\n    //     });\n\n    //     assert_eq(mock.count(), 0);\n    // }\n}\n"
     },
-    "54": {
+    "63": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr",
       "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector,\n    address::AztecAddress,\n    traits::{Deserialize, ToField},\n};\n\nuse crate::context::{\n    gas::GasOpts, private_context::PrivateContext, public_context::PublicContext,\n    returns_hash::ReturnsHash,\n};\nuse crate::hash::{hash_args, hash_calldata};\nuse crate::oracle::execution_cache;\nuse crate::test::helpers::cheatcodes;\n\npub trait CallInterface<let N: u32> {\n    fn get_args(self) -> [Field];\n    fn get_selector(self) -> FunctionSelector;\n    fn get_name(self) -> str<N>;\n    fn get_contract_address(self) -> AztecAddress;\n    fn get_is_static(self) -> bool;\n}\n\n// PrivateCallInterface\n\npub struct PrivateCallInterface<let M: u32, T, let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<M>,\n    args_hash: Field,\n    args: [Field],\n    return_type: T,\n    is_static: bool,\n}\n\nimpl<let M: u32, T, let N: u32> PrivateCallInterface<M, T, N>\nwhere\n    T: Deserialize<N>,\n{\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<M>,\n        args: [Field],\n        is_static: bool,\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self {\n            target_contract,\n            selector,\n            name,\n            args_hash,\n            args,\n            return_type: std::mem::zeroed(),\n            is_static,\n        }\n    }\n\n    pub fn call(self, context: &mut PrivateContext) -> T {\n        execution_cache::store(self.args, self.args_hash);\n        let returns_hash = context.call_private_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            false,\n        );\n        let returns: T = returns_hash.get_preimage();\n        returns\n    }\n\n    pub fn view(self, context: &mut PrivateContext) -> T {\n        execution_cache::store(self.args, self.args_hash);\n        let returns_hash = context.call_private_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns_hash.get_preimage()\n    }\n}\n\nimpl<let M: u32, T, let N: u32> CallInterface<M> for PrivateCallInterface<M, T, N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<M> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PrivateVoidCallInterface\n\npub struct PrivateVoidCallInterface<let M: u32, T, let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<M>,\n    args_hash: Field,\n    args: [Field],\n    return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n    is_static: bool,\n}\n\nimpl<let M: u32, T, let N: u32> PrivateVoidCallInterface<M, T, N>\nwhere\n    T: Deserialize<N>,\n{\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<M>,\n        args: [Field],\n        is_static: bool,\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self {\n            target_contract,\n            selector,\n            name,\n            args_hash,\n            args,\n            return_type: std::mem::zeroed(),\n            is_static,\n        }\n    }\n\n    pub fn call(self, context: &mut PrivateContext) {\n        execution_cache::store(self.args, self.args_hash);\n        context\n            .call_private_function_with_args_hash(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                false,\n            )\n            .assert_empty();\n    }\n\n    pub fn view(self, context: &mut PrivateContext) {\n        execution_cache::store(self.args, self.args_hash);\n        context\n            .call_private_function_with_args_hash(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let M: u32, T, let N: u32> CallInterface<M> for PrivateVoidCallInterface<M, T, N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<M> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PrivateStaticCallInterface\n\npub struct PrivateStaticCallInterface<let M: u32, T, let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<M>,\n    args_hash: Field,\n    args: [Field],\n    return_type: T,\n    is_static: bool,\n}\n\nimpl<let M: u32, T, let N: u32> PrivateStaticCallInterface<M, T, N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<M>,\n        args: [Field],\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self {\n            target_contract,\n            selector,\n            name,\n            args_hash,\n            args,\n            return_type: std::mem::zeroed(),\n            is_static: true,\n        }\n    }\n\n    pub fn view(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<N>,\n    {\n        execution_cache::store(self.args, self.args_hash);\n        let returns = context.call_private_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.get_preimage()\n    }\n}\n\nimpl<let M: u32, T, let N: u32> CallInterface<M> for PrivateStaticCallInterface<M, T, N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<M> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PrivateStaticVoidCallInterface\n\npub struct PrivateStaticVoidCallInterface<let M: u32, T, let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<M>,\n    args_hash: Field,\n    args: [Field],\n    return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n    is_static: bool,\n}\n\nimpl<let M: u32, T, let N: u32> PrivateStaticVoidCallInterface<M, T, N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<M>,\n        args: [Field],\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self {\n            target_contract,\n            selector,\n            name,\n            args_hash,\n            args,\n            return_type: std::mem::zeroed(),\n            is_static: true,\n        }\n    }\n\n    pub fn view(self, context: &mut PrivateContext) {\n        execution_cache::store(self.args, self.args_hash);\n        context\n            .call_private_function_with_args_hash(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let M: u32, T, let N: u32> CallInterface<M> for PrivateStaticVoidCallInterface<M, T, N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<M> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PublicCallInterface\n\npub struct PublicCallInterface<let M: u32, T, let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<M>,\n    args: [Field],\n    gas_opts: GasOpts,\n    return_type: T,\n    is_static: bool,\n}\n\nimpl<let M: u32, T, let N: u32> PublicCallInterface<M, T, N>\nwhere\n    T: Deserialize<N>,\n{\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<M>,\n        args: [Field],\n        is_static: bool,\n    ) -> Self {\n        Self {\n            target_contract,\n            selector,\n            name,\n            args,\n            gas_opts: GasOpts::default(),\n            return_type: std::mem::zeroed(),\n            is_static,\n        }\n    }\n\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call(self, context: &mut PublicContext) -> T {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<N>())\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) -> T {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<N>())\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let M: u32, T, let N: u32> CallInterface<M> for PublicCallInterface<M, T, N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<M> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PublicVoidCallInterface\n\npub struct PublicVoidCallInterface<let M: u32, T, let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<M>,\n    args: [Field],\n    return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let M: u32, T, let N: u32> PublicVoidCallInterface<M, T, N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<M>,\n        args: [Field],\n        is_static: bool,\n    ) -> Self {\n        Self {\n            target_contract,\n            selector,\n            name,\n            args,\n            return_type: std::mem::zeroed(),\n            is_static,\n            gas_opts: GasOpts::default(),\n        }\n    }\n\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call(self, context: &mut PublicContext) {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            true,\n        )\n    }\n\n    pub fn set_as_teardown(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.set_public_teardown_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            false,\n        )\n    }\n}\n\nimpl<let M: u32, T, let N: u32> CallInterface<M> for PublicVoidCallInterface<M, T, N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<M> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PublicStaticCallInterface\n\npub struct PublicStaticCallInterface<let M: u32, T, let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<M>,\n    args: [Field],\n    return_type: T,\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let M: u32, T, let N: u32> PublicStaticCallInterface<M, T, N>\nwhere\n    T: Deserialize<N>,\n{\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<M>,\n        args: [Field],\n    ) -> Self {\n        Self {\n            target_contract,\n            selector,\n            name,\n            args,\n            return_type: std::mem::zeroed(),\n            is_static: true,\n            gas_opts: GasOpts::default(),\n        }\n    }\n\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) -> T {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<N>())\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let M: u32, T, let N: u32> CallInterface<M> for PublicStaticCallInterface<M, T, N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<M> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PublicStaticVoidCallInterface\n\npub struct PublicStaticVoidCallInterface<let M: u32, T, let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<M>,\n    args: [Field],\n    return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let M: u32, T, let N: u32> PublicStaticVoidCallInterface<M, T, N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<M>,\n        args: [Field],\n    ) -> Self {\n        Self {\n            target_contract,\n            selector,\n            name,\n            args,\n            return_type: std::mem::zeroed(),\n            is_static: true,\n            gas_opts: GasOpts::default(),\n        }\n    }\n\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let M: u32, T, let N: u32> CallInterface<M> for PublicStaticVoidCallInterface<M, T, N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<M> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// UtilityCallInterface\n\npub struct UtilityCallInterface<let M: u32, T, let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<M>,\n    args_hash: Field,\n    args: [Field],\n    return_type: T,\n}\n\nimpl<let M: u32, T, let N: u32> CallInterface<M> for UtilityCallInterface<M, T, N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<M> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        false\n    }\n}\n\nimpl<let M: u32, T, let N: u32> UtilityCallInterface<M, T, N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<M>,\n        args: [Field],\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self { target_contract, selector, name, args_hash, args, return_type: std::mem::zeroed() }\n    }\n\n    pub fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    pub fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    pub fn get_name(self) -> str<M> {\n        self.name\n    }\n\n    pub fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n}\n\n// UtilityVoidCallInterface\n\npub struct UtilityVoidCallInterface<let M: u32, T, let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<M>,\n    args_hash: Field,\n    args: [Field],\n    return_type: T,\n}\n\nimpl<let M: u32, T, let N: u32> CallInterface<M> for UtilityVoidCallInterface<M, T, N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<M> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        false\n    }\n}\n\nimpl<let M: u32, T, let N: u32> UtilityVoidCallInterface<M, T, N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<M>,\n        args: [Field],\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self { target_contract, selector, name, args_hash, args, return_type: std::mem::zeroed() }\n    }\n\n    pub fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    pub fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    pub fn get_name(self) -> str<M> {\n        self.name\n    }\n\n    pub fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n}\n\npub trait TXEPublicCallInterface<T, let N: u32> {\n    unconstrained fn call_with_txe(self, from: AztecAddress) -> (T, Field);\n}\n\nimpl<let M: u32, T, let N: u32> TXEPublicCallInterface<T, N> for PublicCallInterface<M, T, N>\nwhere\n    T: Deserialize<N>,\n{\n    unconstrained fn call_with_txe(self, from: AztecAddress) -> (T, Field) {\n        let (returns_hash, tx_hash) = cheatcodes::public_call_new_flow(\n            from,\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.is_static,\n        );\n\n        let returns = ReturnsHash::new(returns_hash).get_preimage();\n\n        (returns, tx_hash)\n    }\n}\n\nimpl<let M: u32, T, let N: u32> TXEPublicCallInterface<T, N> for PublicVoidCallInterface<M, T, N>\nwhere\n    T: Deserialize<N>,\n{\n    unconstrained fn call_with_txe(self, from: AztecAddress) -> (T, Field) {\n        let (returns_hash, tx_hash) = cheatcodes::public_call_new_flow(\n            from,\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.is_static,\n        );\n\n        let returns = ReturnsHash::new(returns_hash).get_preimage_and_assert_empty();\n\n        (returns, tx_hash)\n    }\n}\n\nimpl<let M: u32, T, let N: u32> TXEPublicCallInterface<T, N> for PublicStaticCallInterface<M, T, N>\nwhere\n    T: Deserialize<N>,\n{\n    unconstrained fn call_with_txe(self, from: AztecAddress) -> (T, Field) {\n        let (returns_hash, tx_hash) = cheatcodes::public_call_new_flow(\n            from,\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.is_static,\n        );\n\n        let returns = ReturnsHash::new(returns_hash).get_preimage();\n\n        (returns, tx_hash)\n    }\n}\n\nimpl<let M: u32, T, let N: u32> TXEPublicCallInterface<T, N> for PublicStaticVoidCallInterface<M, T, N>\nwhere\n    T: Deserialize<N>,\n{\n    unconstrained fn call_with_txe(self, from: AztecAddress) -> (T, Field) {\n        let (returns_hash, tx_hash) = cheatcodes::public_call_new_flow(\n            from,\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.is_static,\n        );\n\n        let returns = ReturnsHash::new(returns_hash).get_preimage_and_assert_empty();\n\n        (returns, tx_hash)\n    }\n}\n\npub trait TXEPrivateCallInterface<T, let N: u32> {\n    unconstrained fn call_with_txe(self, from: AztecAddress) -> (T, Field);\n}\n\nimpl<let M: u32, T, let N: u32> TXEPrivateCallInterface<T, N> for PrivateCallInterface<M, T, N>\nwhere\n    T: Deserialize<N>,\n{\n    unconstrained fn call_with_txe(self, from: AztecAddress) -> (T, Field) {\n        let args = self.get_args();\n        let args_hash = hash_args(args);\n\n        let (_end_side_effect_counter, returns_hash, tx_hash) = cheatcodes::private_call_new_flow(\n            from,\n            self.get_contract_address(),\n            self.get_selector(),\n            args,\n            args_hash,\n            self.get_is_static(),\n        );\n\n        let returns: T = ReturnsHash::new(returns_hash).get_preimage();\n\n        (returns, tx_hash)\n    }\n}\n\nimpl<let M: u32, T, let N: u32> TXEPrivateCallInterface<T, N> for PrivateVoidCallInterface<M, T, N>\nwhere\n    T: Deserialize<N>,\n{\n    unconstrained fn call_with_txe(self, from: AztecAddress) -> (T, Field) {\n        let args = self.get_args();\n        let args_hash = hash_args(args);\n        execution_cache::store(args, args_hash);\n\n        let (_end_side_effect_counter, returns_hash, tx_hash) = cheatcodes::private_call_new_flow(\n            from,\n            self.get_contract_address(),\n            self.get_selector(),\n            args,\n            args_hash,\n            self.get_is_static(),\n        );\n\n        let returns = ReturnsHash::new(returns_hash).get_preimage_and_assert_empty();\n\n        (returns, tx_hash)\n    }\n}\n\nimpl<let M: u32, T, let N: u32> TXEPrivateCallInterface<T, N> for PrivateStaticCallInterface<M, T, N>\nwhere\n    T: Deserialize<N>,\n{\n    unconstrained fn call_with_txe(self, from: AztecAddress) -> (T, Field) {\n        let args = self.get_args();\n        let args_hash = hash_args(args);\n        execution_cache::store(args, args_hash);\n\n        let (_, returns_hash, tx_hash) = cheatcodes::private_call_new_flow(\n            from,\n            self.get_contract_address(),\n            self.get_selector(),\n            args,\n            args_hash,\n            self.get_is_static(),\n        );\n\n        let returns = ReturnsHash::new(returns_hash).get_preimage();\n\n        (returns, tx_hash)\n    }\n}\n\nimpl<let M: u32, T, let N: u32> TXEPrivateCallInterface<T, N> for PrivateStaticVoidCallInterface<M, T, N>\nwhere\n    T: Deserialize<N>,\n{\n    unconstrained fn call_with_txe(self, from: AztecAddress) -> (T, Field) {\n        let args = self.get_args();\n        let args_hash = hash_args(args);\n        execution_cache::store(args, args_hash);\n\n        let (_, returns_hash, tx_hash) = cheatcodes::private_call_new_flow(\n            from,\n            self.get_contract_address(),\n            self.get_selector(),\n            args,\n            args_hash,\n            self.get_is_static(),\n        );\n\n        let returns = ReturnsHash::new(returns_hash).get_preimage_and_assert_empty();\n\n        (returns, tx_hash)\n    }\n}\n\npub trait TXEUtilityCallInterface<T, let N: u32> {\n    unconstrained fn call_with_txe(self) -> T;\n}\n\nimpl<let M: u32, T, let N: u32> TXEUtilityCallInterface<T, N> for UtilityCallInterface<M, T, N>\nwhere\n    T: Deserialize<N>,\n{\n    unconstrained fn call_with_txe(self) -> T {\n        let args = self.get_args();\n        let args_hash = hash_args(args);\n        execution_cache::store(args, args_hash);\n\n        let returns_hash = crate::oracle::simulate_utility_function::simulate_utility_function(\n            self.get_contract_address(),\n            self.get_selector(),\n            args_hash,\n        );\n\n        let returns: T = ReturnsHash::new(returns_hash).get_preimage();\n        returns\n    }\n}\n\nimpl<let M: u32, T, let N: u32> TXEUtilityCallInterface<T, N> for UtilityVoidCallInterface<M, T, N>\nwhere\n    T: Deserialize<N>,\n{\n    unconstrained fn call_with_txe(self) -> T {\n        let args = self.get_args();\n        let args_hash = hash_args(args);\n        execution_cache::store(args, args_hash);\n\n        let returns_hash = crate::oracle::simulate_utility_function::simulate_utility_function(\n            self.get_contract_address(),\n            self.get_selector(),\n            args_hash,\n        );\n\n        let returns = ReturnsHash::new(returns_hash).get_preimage_and_assert_empty();\n        returns\n    }\n}\n"
     },
-    "6": {
-      "path": "std/collections/bounded_vec.nr",
-      "source": "use crate::{cmp::Eq, convert::From, runtime::is_unconstrained, static_assert};\n\n/// A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it\n/// is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented\n/// via slices and thus is not subject to the same restrictions slices are (notably, nested\n/// slices - and thus nested vectors as well - are disallowed).\n///\n/// Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by\n/// pushing an additional element is also more efficient - the length only needs to be increased\n/// by one.\n///\n/// For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there\n/// is a reasonable maximum bound that can be placed on the vector.\n///\n/// Example:\n///\n/// ```noir\n/// let mut vector: BoundedVec<Field, 10> = BoundedVec::new();\n/// for i in 0..5 {\n///     vector.push(i);\n/// }\n/// assert(vector.len() == 5);\n/// assert(vector.max_len() == 10);\n/// ```\npub struct BoundedVec<T, let MaxLen: u32> {\n    storage: [T; MaxLen],\n    len: u32,\n}\n\nimpl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {\n    /// Creates a new, empty vector of length zero.\n    ///\n    /// Since this container is backed by an array internally, it still needs an initial value\n    /// to give each element. To resolve this, each element is zeroed internally. This value\n    /// is guaranteed to be inaccessible unless `get_unchecked` is used.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();\n    /// assert(empty_vector.len() == 0);\n    /// ```\n    ///\n    /// Note that whenever calling `new` the maximum length of the vector should always be specified\n    /// via a type signature:\n    ///\n    /// ```noir\n    /// fn good() -> BoundedVec<Field, 10> {\n    ///     // Ok! MaxLen is specified with a type annotation\n    ///     let v1: BoundedVec<Field, 3> = BoundedVec::new();\n    ///     let v2 = BoundedVec::new();\n    ///\n    ///     // Ok! MaxLen is known from the type of `good`'s return value\n    ///     v2\n    /// }\n    ///\n    /// fn bad() {\n    ///     // Error: Type annotation needed\n    ///     // The compiler can't infer `MaxLen` from the following code:\n    ///     let mut v3 = BoundedVec::new();\n    ///     v3.push(5);\n    /// }\n    /// ```\n    ///\n    /// This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions\n    /// but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a\n    /// constraint failure at runtime when the vec is pushed to.\n    pub fn new() -> Self {\n        let zeroed = crate::mem::zeroed();\n        BoundedVec { storage: [zeroed; MaxLen], len: 0 }\n    }\n\n    /// Retrieves an element from the vector at the given index, starting from zero.\n    ///\n    /// If the given index is equal to or greater than the length of the vector, this\n    /// will issue a constraint failure.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n    ///     let first = v.get(0);\n    ///     let last = v.get(v.len() - 1);\n    ///     assert(first != last);\n    /// }\n    /// ```\n    pub fn get(self, index: u32) -> T {\n        assert(index < self.len, \"Attempted to read past end of BoundedVec\");\n        self.get_unchecked(index)\n    }\n\n    /// Retrieves an element from the vector at the given index, starting from zero, without\n    /// performing a bounds check.\n    ///\n    /// Since this function does not perform a bounds check on length before accessing the element,\n    /// it is unsafe! Use at your own risk!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn sum_of_first_three<let N: u32>(v: BoundedVec<u32, N>) -> u32 {\n    ///     // Always ensure the length is larger than the largest\n    ///     // index passed to get_unchecked\n    ///     assert(v.len() > 2);\n    ///     let first = v.get_unchecked(0);\n    ///     let second = v.get_unchecked(1);\n    ///     let third = v.get_unchecked(2);\n    ///     first + second + third\n    /// }\n    /// ```\n    pub fn get_unchecked(self, index: u32) -> T {\n        self.storage[index]\n    }\n\n    /// Writes an element to the vector at the given index, starting from zero.\n    ///\n    /// If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n    ///     let first = v.get(0);\n    ///     assert(first != 42);\n    ///     v.set(0, 42);\n    ///     let new_first = v.get(0);\n    ///     assert(new_first == 42);\n    /// }\n    /// ```\n    pub fn set(&mut self, index: u32, value: T) {\n        assert(index < self.len, \"Attempted to write past end of BoundedVec\");\n        self.set_unchecked(index, value)\n    }\n\n    /// Writes an element to the vector at the given index, starting from zero, without performing a bounds check.\n    ///\n    /// Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn set_unchecked_example() {\n    ///     let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n    ///     vec.extend_from_array([1, 2]);\n    ///\n    ///     // Here we're safely writing within the valid range of `vec`\n    ///     // `vec` now has the value [42, 2]\n    ///     vec.set_unchecked(0, 42);\n    ///\n    ///     // We can then safely read this value back out of `vec`.\n    ///     // Notice that we use the checked version of `get` which would prevent reading unsafe values.\n    ///     assert_eq(vec.get(0), 42);\n    ///\n    ///     // We've now written past the end of `vec`.\n    ///     // As this index is still within the maximum potential length of `v`,\n    ///     // it won't cause a constraint failure.\n    ///     vec.set_unchecked(2, 42);\n    ///     println(vec);\n    ///\n    ///     // This will write past the end of the maximum potential length of `vec`,\n    ///     // it will then trigger a constraint failure.\n    ///     vec.set_unchecked(5, 42);\n    ///     println(vec);\n    /// }\n    /// ```\n    pub fn set_unchecked(&mut self, index: u32, value: T) {\n        self.storage[index] = value;\n    }\n\n    /// Pushes an element to the end of the vector. This increases the length\n    /// of the vector by one.\n    ///\n    /// Panics if the new length of the vector will be greater than the max length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n    ///\n    /// v.push(1);\n    /// v.push(2);\n    ///\n    /// // Panics with failed assertion \"push out of bounds\"\n    /// v.push(3);\n    /// ```\n    pub fn push(&mut self, elem: T) {\n        assert(self.len < MaxLen, \"push out of bounds\");\n\n        self.storage[self.len] = elem;\n        self.len += 1;\n    }\n\n    /// Returns the current length of this vector\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 4> = BoundedVec::new();\n    /// assert(v.len() == 0);\n    ///\n    /// v.push(100);\n    /// assert(v.len() == 1);\n    ///\n    /// v.push(200);\n    /// v.push(300);\n    /// v.push(400);\n    /// assert(v.len() == 4);\n    ///\n    /// let _ = v.pop();\n    /// let _ = v.pop();\n    /// assert(v.len() == 2);\n    /// ```\n    pub fn len(self) -> u32 {\n        self.len\n    }\n\n    /// Returns the maximum length of this vector. This is always\n    /// equal to the `MaxLen` parameter this vector was initialized with.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n    ///\n    /// assert(v.max_len() == 5);\n    /// v.push(10);\n    /// assert(v.max_len() == 5);\n    /// ```\n    pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u32 {\n        MaxLen\n    }\n\n    /// Returns the internal array within this vector.\n    ///\n    /// Since arrays in Noir are immutable, mutating the returned storage array will not mutate\n    /// the storage held internally by this vector.\n    ///\n    /// Note that uninitialized elements may be zeroed out!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n    ///\n    /// assert(v.storage() == [0, 0, 0, 0, 0]);\n    ///\n    /// v.push(57);\n    /// assert(v.storage() == [57, 0, 0, 0, 0]);\n    /// ```\n    pub fn storage(self) -> [T; MaxLen] {\n        self.storage\n    }\n\n    /// Pushes each element from the given array to this vector.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n    /// vec.extend_from_array([2, 4]);\n    ///\n    /// assert(vec.len == 2);\n    /// assert(vec.get(0) == 2);\n    /// assert(vec.get(1) == 4);\n    /// ```\n    pub fn extend_from_array<let Len: u32>(&mut self, array: [T; Len]) {\n        let new_len = self.len + array.len();\n        assert(new_len <= MaxLen, \"extend_from_array out of bounds\");\n        for i in 0..array.len() {\n            self.storage[self.len + i] = array[i];\n        }\n        self.len = new_len;\n    }\n\n    /// Pushes each element from the given slice to this vector.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n    /// vec.extend_from_slice(&[2, 4]);\n    ///\n    /// assert(vec.len == 2);\n    /// assert(vec.get(0) == 2);\n    /// assert(vec.get(1) == 4);\n    /// ```\n    pub fn extend_from_slice(&mut self, slice: [T]) {\n        let new_len = self.len + slice.len();\n        assert(new_len <= MaxLen, \"extend_from_slice out of bounds\");\n        for i in 0..slice.len() {\n            self.storage[self.len + i] = slice[i];\n        }\n        self.len = new_len;\n    }\n\n    /// Pushes each element from the other vector to this vector. The length of\n    /// the other vector is left unchanged.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// ```noir\n    /// let mut v1: BoundedVec<Field, 5> = BoundedVec::new();\n    /// let mut v2: BoundedVec<Field, 7> = BoundedVec::new();\n    ///\n    /// v2.extend_from_array([1, 2, 3]);\n    /// v1.extend_from_bounded_vec(v2);\n    ///\n    /// assert(v1.storage() == [1, 2, 3, 0, 0]);\n    /// assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);\n    /// ```\n    pub fn extend_from_bounded_vec<let Len: u32>(&mut self, vec: BoundedVec<T, Len>) {\n        let append_len = vec.len();\n        let new_len = self.len + append_len;\n        assert(new_len <= MaxLen, \"extend_from_bounded_vec out of bounds\");\n\n        if is_unconstrained() {\n            for i in 0..append_len {\n                self.storage[self.len + i] = vec.get_unchecked(i);\n            }\n        } else {\n            let mut exceeded_len = false;\n            for i in 0..Len {\n                exceeded_len |= i == append_len;\n                if !exceeded_len {\n                    self.storage[self.len + i] = vec.get_unchecked(i);\n                }\n            }\n        }\n        self.len = new_len;\n    }\n\n    /// Creates a new vector, populating it with values derived from an array input.\n    /// The maximum length of the vector is determined based on the type signature.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])\n    /// ```\n    pub fn from_array<let Len: u32>(array: [T; Len]) -> Self {\n        static_assert(Len <= MaxLen, \"from array out of bounds\");\n        let mut vec: BoundedVec<T, MaxLen> = BoundedVec::new();\n        vec.extend_from_array(array);\n        vec\n    }\n\n    /// Pops the element at the end of the vector. This will decrease the length\n    /// of the vector by one.\n    ///\n    /// Panics if the vector is empty.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n    /// v.push(1);\n    /// v.push(2);\n    ///\n    /// let two = v.pop();\n    /// let one = v.pop();\n    ///\n    /// assert(two == 2);\n    /// assert(one == 1);\n    ///\n    /// // error: cannot pop from an empty vector\n    /// let _ = v.pop();\n    /// ```\n    pub fn pop(&mut self) -> T {\n        assert(self.len > 0);\n        self.len -= 1;\n\n        let elem = self.storage[self.len];\n        self.storage[self.len] = crate::mem::zeroed();\n        elem\n    }\n\n    /// Returns true if the given predicate returns true for any element\n    /// in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<u32, 3> = BoundedVec::new();\n    /// v.extend_from_array([2, 4, 6]);\n    ///\n    /// let all_even = !v.any(|elem: u32| elem % 2 != 0);\n    /// assert(all_even);\n    /// ```\n    pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = false;\n        if is_unconstrained() {\n            for i in 0..self.len {\n                ret |= predicate(self.storage[i]);\n            }\n        } else {\n            let mut ret = false;\n            let mut exceeded_len = false;\n            for i in 0..MaxLen {\n                exceeded_len |= i == self.len;\n                if !exceeded_len {\n                    ret |= predicate(self.storage[i]);\n                }\n            }\n        }\n        ret\n    }\n\n    /// Creates a new vector of equal size by calling a closure on each element in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n    /// let result = vec.map(|value| value * 2);\n    ///\n    /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n    /// assert_eq(result, expected);\n    /// ```\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen> {\n        let mut ret = BoundedVec::new();\n        ret.len = self.len();\n\n        if is_unconstrained() {\n            for i in 0..self.len() {\n                ret.storage[i] = f(self.get_unchecked(i));\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i < self.len() {\n                    ret.storage[i] = f(self.get_unchecked(i));\n                }\n            }\n        }\n\n        ret\n    }\n\n    /// Creates a new vector of equal size by calling a closure on each element\n    /// in this vector, along with its index.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n    /// let result = vec.mapi(|i, value| i + value * 2);\n    ///\n    /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n    /// assert_eq(result, expected);\n    /// ```\n    pub fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> BoundedVec<U, MaxLen> {\n        let mut ret = BoundedVec::new();\n        ret.len = self.len();\n\n        if is_unconstrained() {\n            for i in 0..self.len() {\n                ret.storage[i] = f(i, self.get_unchecked(i));\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i < self.len() {\n                    ret.storage[i] = f(i, self.get_unchecked(i));\n                }\n            }\n        }\n\n        ret\n    }\n\n    /// Calls a closure on each element in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n    /// let mut result = BoundedVec::<u32, 4>::new();\n    /// vec.for_each(|value| result.push(value * 2));\n    ///\n    /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n    /// assert_eq(result, expected);\n    /// ```\n    pub fn for_each<Env>(self, f: fn[Env](T) -> ()) {\n        if is_unconstrained() {\n            for i in 0..self.len() {\n                f(self.get_unchecked(i));\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i < self.len() {\n                    f(self.get_unchecked(i));\n                }\n            }\n        }\n    }\n\n    /// Calls a closure on each element in this vector, along with its index.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n    /// let mut result = BoundedVec::<u32, 4>::new();\n    /// vec.for_eachi(|i, value| result.push(i + value * 2));\n    ///\n    /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n    /// assert_eq(result, expected);\n    /// ```\n    pub fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ()) {\n        if is_unconstrained() {\n            for i in 0..self.len() {\n                f(i, self.get_unchecked(i));\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i < self.len() {\n                    f(i, self.get_unchecked(i));\n                }\n            }\n        }\n    }\n\n    /// Creates a new BoundedVec from the given array and length.\n    /// The given length must be less than or equal to the length of the array.\n    ///\n    /// This function will zero out any elements at or past index `len` of `array`.\n    /// This incurs an extra runtime cost of O(MaxLen). If you are sure your array is\n    /// zeroed after that index, you can use `from_parts_unchecked` to remove the extra loop.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n    /// assert_eq(vec.len(), 3);\n    /// ```\n    pub fn from_parts(mut array: [T; MaxLen], len: u32) -> Self {\n        assert(len <= MaxLen);\n        let zeroed = crate::mem::zeroed();\n\n        if is_unconstrained() {\n            for i in len..MaxLen {\n                array[i] = zeroed;\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i >= len {\n                    array[i] = zeroed;\n                }\n            }\n        }\n\n        BoundedVec { storage: array, len }\n    }\n\n    /// Creates a new BoundedVec from the given array and length.\n    /// The given length must be less than or equal to the length of the array.\n    ///\n    /// This function is unsafe because it expects all elements past the `len` index\n    /// of `array` to be zeroed, but does not check for this internally. Use `from_parts`\n    /// for a safe version of this function which does zero out any indices past the\n    /// given length. Invalidating this assumption can notably cause `BoundedVec::eq`\n    /// to give incorrect results since it will check even elements past `len`.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n    /// assert_eq(vec.len(), 3);\n    ///\n    /// // invalid use!\n    /// let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n    /// let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n    ///\n    /// // both vecs have length 3 so we'd expect them to be equal, but this\n    /// // fails because elements past the length are still checked in eq\n    /// assert_eq(vec1, vec2); // fails\n    /// ```\n    pub fn from_parts_unchecked(array: [T; MaxLen], len: u32) -> Self {\n        assert(len <= MaxLen);\n        BoundedVec { storage: array, len }\n    }\n}\n\nimpl<T, let MaxLen: u32> Eq for BoundedVec<T, MaxLen>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: BoundedVec<T, MaxLen>) -> bool {\n        // TODO: https://github.com/noir-lang/noir/issues/4837\n        //\n        // We make the assumption that the user has used the proper interface for working with `BoundedVec`s\n        // rather than directly manipulating the internal fields as this can result in an inconsistent internal state.\n        if self.len == other.len {\n            self.storage == other.storage\n        } else {\n            false\n        }\n    }\n}\n\nimpl<T, let MaxLen: u32, let Len: u32> From<[T; Len]> for BoundedVec<T, MaxLen> {\n    fn from(array: [T; Len]) -> BoundedVec<T, MaxLen> {\n        BoundedVec::from_array(array)\n    }\n}\n\nmod bounded_vec_tests {\n\n    mod get {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n        fn panics_when_reading_elements_past_end_of_vec() {\n            let vec: BoundedVec<Field, 5> = BoundedVec::new();\n\n            crate::println(vec.get(0));\n        }\n    }\n\n    mod set {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn set_updates_values_properly() {\n            let mut vec = BoundedVec::from_array([0, 0, 0, 0, 0]);\n\n            vec.set(0, 42);\n            assert_eq(vec.storage, [42, 0, 0, 0, 0]);\n\n            vec.set(1, 43);\n            assert_eq(vec.storage, [42, 43, 0, 0, 0]);\n\n            vec.set(2, 44);\n            assert_eq(vec.storage, [42, 43, 44, 0, 0]);\n\n            vec.set(1, 10);\n            assert_eq(vec.storage, [42, 10, 44, 0, 0]);\n\n            vec.set(0, 0);\n            assert_eq(vec.storage, [0, 10, 44, 0, 0]);\n        }\n\n        #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n        fn panics_when_writing_elements_past_end_of_vec() {\n            let mut vec: BoundedVec<Field, 5> = BoundedVec::new();\n            vec.set(0, 42);\n\n            // Need to use println to avoid DIE removing the write operation.\n            crate::println(vec.get(0));\n        }\n    }\n\n    mod map {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn applies_function_correctly() {\n            // docs:start:bounded-vec-map-example\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.map(|value| value * 2);\n            // docs:end:bounded-vec-map-example\n            let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn applies_function_that_changes_return_type() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.map(|value| (value * 2) as Field);\n            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn does_not_apply_function_past_len() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n            let result = vec.map(|value| if value == 0 { 5 } else { value });\n            let expected = BoundedVec::from_array([5, 1]);\n\n            assert_eq(result, expected);\n            assert_eq(result.get_unchecked(2), 0);\n        }\n    }\n\n    mod mapi {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn applies_function_correctly() {\n            // docs:start:bounded-vec-mapi-example\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.mapi(|i, value| i + value * 2);\n            // docs:end:bounded-vec-mapi-example\n            let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn applies_function_that_changes_return_type() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.mapi(|i, value| (i + value * 2) as Field);\n            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 5, 8, 11]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn does_not_apply_function_past_len() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n            let result = vec.mapi(|_, value| if value == 0 { 5 } else { value });\n            let expected = BoundedVec::from_array([5, 1]);\n\n            assert_eq(result, expected);\n            assert_eq(result.get_unchecked(2), 0);\n        }\n    }\n\n    mod for_each {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        // map in terms of for_each\n        fn for_each_map<T, U, Env, let MaxLen: u32>(\n            input: BoundedVec<T, MaxLen>,\n            f: fn[Env](T) -> U,\n        ) -> BoundedVec<U, MaxLen> {\n            let mut output = BoundedVec::<U, MaxLen>::new();\n            let output_ref = &mut output;\n            input.for_each(|x| output_ref.push(f(x)));\n            output\n        }\n\n        #[test]\n        fn smoke_test() {\n            let mut acc = 0;\n            let acc_ref = &mut acc;\n            // docs:start:bounded-vec-for-each-example\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n            vec.for_each(|value| { *acc_ref += value; });\n            // docs:end:bounded-vec-for-each-example\n            assert_eq(acc, 6);\n        }\n\n        #[test]\n        fn applies_function_correctly() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = for_each_map(vec, |value| value * 2);\n            let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn applies_function_that_changes_return_type() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = for_each_map(vec, |value| (value * 2) as Field);\n            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn does_not_apply_function_past_len() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n            let result = for_each_map(vec, |value| if value == 0 { 5 } else { value });\n            let expected = BoundedVec::from_array([5, 1]);\n\n            assert_eq(result, expected);\n            assert_eq(result.get_unchecked(2), 0);\n        }\n    }\n\n    mod for_eachi {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        // mapi in terms of for_eachi\n        fn for_eachi_mapi<T, U, Env, let MaxLen: u32>(\n            input: BoundedVec<T, MaxLen>,\n            f: fn[Env](u32, T) -> U,\n        ) -> BoundedVec<U, MaxLen> {\n            let mut output = BoundedVec::<U, MaxLen>::new();\n            let output_ref = &mut output;\n            input.for_eachi(|i, x| output_ref.push(f(i, x)));\n            output\n        }\n\n        #[test]\n        fn smoke_test() {\n            let mut acc = 0;\n            let acc_ref = &mut acc;\n            // docs:start:bounded-vec-for-eachi-example\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n            vec.for_eachi(|i, value| { *acc_ref += i * value; });\n            // docs:end:bounded-vec-for-eachi-example\n\n            // 0 * 1 + 1 * 2 + 2 * 3\n            assert_eq(acc, 8);\n        }\n\n        #[test]\n        fn applies_function_correctly() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = for_eachi_mapi(vec, |i, value| i + value * 2);\n            let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn applies_function_that_changes_return_type() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = for_eachi_mapi(vec, |i, value| (i + value * 2) as Field);\n            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 5, 8, 11]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn does_not_apply_function_past_len() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n            let result = for_eachi_mapi(vec, |_, value| if value == 0 { 5 } else { value });\n            let expected = BoundedVec::from_array([5, 1]);\n\n            assert_eq(result, expected);\n            assert_eq(result.get_unchecked(2), 0);\n        }\n    }\n\n    mod from_array {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn empty() {\n            let empty_array: [Field; 0] = [];\n            let bounded_vec = BoundedVec::from_array([]);\n\n            assert_eq(bounded_vec.max_len(), 0);\n            assert_eq(bounded_vec.len(), 0);\n            assert_eq(bounded_vec.storage(), empty_array);\n        }\n\n        #[test]\n        fn equal_len() {\n            let array = [1, 2, 3];\n            let bounded_vec = BoundedVec::from_array(array);\n\n            assert_eq(bounded_vec.max_len(), 3);\n            assert_eq(bounded_vec.len(), 3);\n            assert_eq(bounded_vec.storage(), array);\n        }\n\n        #[test]\n        fn max_len_greater_then_array_len() {\n            let array = [1, 2, 3];\n            let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array(array);\n\n            assert_eq(bounded_vec.max_len(), 10);\n            assert_eq(bounded_vec.len(), 3);\n            assert_eq(bounded_vec.get(0), 1);\n            assert_eq(bounded_vec.get(1), 2);\n            assert_eq(bounded_vec.get(2), 3);\n        }\n\n        #[test(should_fail_with = \"from array out of bounds\")]\n        fn max_len_lower_then_array_len() {\n            let _: BoundedVec<Field, 2> = BoundedVec::from_array([0; 3]);\n        }\n    }\n\n    mod trait_from {\n        use crate::collections::bounded_vec::BoundedVec;\n        use crate::convert::From;\n\n        #[test]\n        fn simple() {\n            let array = [1, 2];\n            let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from(array);\n\n            assert_eq(bounded_vec.max_len(), 10);\n            assert_eq(bounded_vec.len(), 2);\n            assert_eq(bounded_vec.get(0), 1);\n            assert_eq(bounded_vec.get(1), 2);\n        }\n    }\n\n    mod trait_eq {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn empty_equality() {\n            let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n            let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n\n            assert_eq(bounded_vec1, bounded_vec2);\n        }\n\n        #[test]\n        fn inequality() {\n            let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n            let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n            bounded_vec1.push(1);\n            bounded_vec2.push(2);\n\n            assert(bounded_vec1 != bounded_vec2);\n        }\n    }\n\n    mod from_parts {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn from_parts() {\n            // docs:start:from-parts\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n            assert_eq(vec.len(), 3);\n\n            // Any elements past the given length are zeroed out, so these\n            // two BoundedVecs will be completely equal\n            let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 1], 3);\n            let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 2], 3);\n            assert_eq(vec1, vec2);\n            // docs:end:from-parts\n        }\n\n        #[test]\n        fn from_parts_unchecked() {\n            // docs:start:from-parts-unchecked\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n            assert_eq(vec.len(), 3);\n\n            // invalid use!\n            let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n            let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n\n            // both vecs have length 3 so we'd expect them to be equal, but this\n            // fails because elements past the length are still checked in eq\n            assert(vec1 != vec2);\n            // docs:end:from-parts-unchecked\n        }\n    }\n}\n"
-    },
-    "61": {
+    "70": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
-      "source": "use crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n    hash::{ArgsHasher, hash_args_array, hash_calldata_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            notify_enqueued_public_function_call, notify_set_min_revertible_side_effect_counter,\n            notify_set_public_teardown_function_call,\n        },\n        execution_cache,\n        key_validation_request::get_key_validation_request,\n        notes::{notify_created_nullifier, notify_nullified_note},\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        gas_settings::GasSettings,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::{PrivateLog, PrivateLogData},\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::{Empty, Hash, ToField},\n    utils::arrays::array_concat,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<Counted<L2ToL1Message>, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<Counted<LogHash>, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn gas_settings(self) -> GasSettings {\n        self.inputs.tx_context.gas_settings\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        let nullifier_counter = self.next_counter();\n        notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: nullifier_counter,\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        self.return_hash = returns_hasher.hash();\n        execution_cache::store(returns_hasher.fields, self.return_hash);\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request = self.last_key_validation_requests[key_index as u32].unwrap_or(\n            KeyValidationRequest::empty(),\n        );\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n\n            // Safety: Kernels verify that the key validation request is valid and below we verify that a request\n            // for the correct public key has been received.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index as u32],\n                },\n            );\n            self.last_key_validation_requests[key_index as u32] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content };\n        self.l2_to_l1_msgs.push(message.count(self.next_counter()));\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS], length: u32) {\n        let counter = self.next_counter();\n        let private_log =\n            PrivateLogData { log: PrivateLog::new(log, length), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        length: u32,\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log =\n            PrivateLogData { log: PrivateLog::new(log, length), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args, args_hash);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args, args_hash);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n        // execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n        // the number of side effects that took place), along with the hash of the return values. We validate these\n        // by requesting a private kernel iteration in which the return values are constrained to hash\n        // to `returns_hash` and the side effects counter to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n    }\n\n    pub fn call_public_function_with_calldata_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        calldata_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n        notify_enqueued_public_function_call(\n            contract_address,\n            calldata_hash,\n            counter,\n            is_static_call,\n        );\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            is_static_call,\n            calldata_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.set_public_teardown_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn set_public_teardown_function_with_calldata_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        calldata_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n        notify_set_public_teardown_function_call(\n            contract_address,\n            calldata_hash,\n            counter,\n            is_static_call,\n        );\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            is_static_call,\n            calldata_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
+      "source": "use crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n    hash::{ArgsHasher, hash_args_array, hash_calldata_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            notify_enqueued_public_function_call, notify_set_min_revertible_side_effect_counter,\n            notify_set_public_teardown_function_call,\n        },\n        execution_cache,\n        key_validation_request::get_key_validation_request,\n        notes::{notify_created_nullifier, notify_nullified_note},\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        gas_settings::GasSettings,\n        include_by_timestamp::IncludeByTimestamp,\n        log_hash::LogHash,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::{PrivateLog, PrivateLogData},\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::{Empty, Hash, ToField},\n    utils::arrays::array_concat,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub include_by_timestamp: IncludeByTimestamp,\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<Counted<L2ToL1Message>, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<Counted<LogHash>, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            include_by_timestamp: IncludeByTimestamp::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn gas_settings(self) -> GasSettings {\n        self.inputs.tx_context.gas_settings\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        let nullifier_counter = self.next_counter();\n        notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: nullifier_counter,\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        self.return_hash = returns_hasher.hash();\n        execution_cache::store(returns_hasher.fields, self.return_hash);\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            include_by_timestamp: self.include_by_timestamp,\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:include-by-timestamp\n    pub fn set_include_by_timestamp(&mut self, include_by_timestamp: u64) {\n        // docs:end:include-by-timestamp\n        self.include_by_timestamp =\n            IncludeByTimestamp::min_with_u64(self.include_by_timestamp, include_by_timestamp);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request = self.last_key_validation_requests[key_index as u32].unwrap_or(\n            KeyValidationRequest::empty(),\n        );\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n\n            // Safety: Kernels verify that the key validation request is valid and below we verify that a request\n            // for the correct public key has been received.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index as u32],\n                },\n            );\n            self.last_key_validation_requests[key_index as u32] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content };\n        self.l2_to_l1_msgs.push(message.count(self.next_counter()));\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS], length: u32) {\n        let counter = self.next_counter();\n        let private_log =\n            PrivateLogData { log: PrivateLog::new(log, length), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        length: u32,\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log =\n            PrivateLogData { log: PrivateLog::new(log, length), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args, args_hash);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args, args_hash);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n        // execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n        // the number of side effects that took place), along with the hash of the return values. We validate these\n        // by requesting a private kernel iteration in which the return values are constrained to hash\n        // to `returns_hash` and the side effects counter to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n    }\n\n    pub fn call_public_function_with_calldata_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        calldata_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n        notify_enqueued_public_function_call(\n            contract_address,\n            calldata_hash,\n            counter,\n            is_static_call,\n        );\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            is_static_call,\n            calldata_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.set_public_teardown_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn set_public_teardown_function_with_calldata_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        calldata_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n        notify_set_public_teardown_function_call(\n            contract_address,\n            calldata_hash,\n            counter,\n            is_static_call,\n        );\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            is_static_call,\n            calldata_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            include_by_timestamp: IncludeByTimestamp::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"
     },
-    "62": {
+    "71": {
       "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_U32_VALUE;\nuse dep::protocol_types::traits::{Empty, FromField, Packable, Serialize, ToField};\n\npub struct PublicContext {\n    pub args_hash: Option<Field>,\n    pub compute_args_hash: fn() -> Field,\n}\n\nimpl PublicContext {\n    pub fn new(compute_args_hash: fn() -> Field) -> Self {\n        PublicContext { args_hash: Option::none(), compute_args_hash }\n    }\n\n    pub fn emit_public_log<T, let N: u32>(_self: &mut Self, log: T)\n    where\n        T: Serialize<N>,\n    {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_public_log(Serialize::serialize(log).as_slice()) };\n    }\n\n    pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { note_hash_exists(note_hash, leaf_index) } == 1\n    }\n\n    pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { l1_to_l2_msg_exists(msg_hash, msg_leaf_index) } == 1\n    }\n\n    pub fn nullifier_exists(_self: Self, unsiloed_nullifier: Field, address: AztecAddress) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { nullifier_exists(unsiloed_nullifier, address.to_field()) } == 1\n    }\n\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        let secret_hash = compute_secret_hash(secret);\n        let message_hash = compute_l1_to_l2_message_hash(\n            sender,\n            self.chain_id(),\n            /*recipient=*/\n            self.this_address(),\n            self.version(),\n            content,\n            secret_hash,\n            leaf_index,\n        );\n        let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n        assert(\n            !self.nullifier_exists(nullifier, self.this_address()),\n            \"L1-to-L2 message is already nullified\",\n        );\n        assert(\n            self.l1_to_l2_msg_exists(message_hash, leaf_index),\n            \"Tried to consume nonexistent L1-to-L2 message\",\n        );\n\n        self.push_nullifier(nullifier);\n    }\n\n    pub fn message_portal(_self: &mut Self, recipient: EthAddress, content: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { send_l2_to_l1_msg(recipient, content) };\n    }\n\n    pub unconstrained fn call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let calldata = args.push_front(function_selector.to_field());\n\n        call(\n            gas_opts.l2_gas.unwrap_or(MAX_U32_VALUE),\n            gas_opts.da_gas.unwrap_or(MAX_U32_VALUE),\n            contract_address,\n            calldata,\n        );\n        // Use success_copy to determine whether the call succeeded\n        let success = success_copy();\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub unconstrained fn static_call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let calldata = args.push_front(function_selector.to_field());\n\n        call_static(\n            gas_opts.l2_gas.unwrap_or(MAX_U32_VALUE),\n            gas_opts.da_gas.unwrap_or(MAX_U32_VALUE),\n            contract_address,\n            calldata,\n        );\n        // Use success_copy to determine whether the call succeeded\n        let success = success_copy();\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub fn push_note_hash(_self: &mut Self, note_hash: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_note_hash(note_hash) };\n    }\n    pub fn push_nullifier(_self: &mut Self, nullifier: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_nullifier(nullifier) };\n    }\n\n    pub fn this_address(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            address()\n        }\n    }\n    pub fn msg_sender(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            sender()\n        }\n    }\n    pub fn selector(_self: Self) -> FunctionSelector {\n        // The selector is the first element of the calldata when calling a public function through dispatch.\n        // Safety: AVM opcodes are constrained by the AVM itself\n        let raw_selector: [Field; 1] = unsafe { calldata_copy(0, 1) };\n        FunctionSelector::from_field(raw_selector[0])\n    }\n    pub fn get_args_hash(mut self) -> Field {\n        if !self.args_hash.is_some() {\n            self.args_hash = Option::some((self.compute_args_hash)());\n        }\n\n        self.args_hash.unwrap_unchecked()\n    }\n    pub fn transaction_fee(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            transaction_fee()\n        }\n    }\n\n    pub fn chain_id(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            chain_id()\n        }\n    }\n    pub fn version(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            version()\n        }\n    }\n    pub fn block_number(_self: Self) -> u32 {\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) -> u128 {\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) -> u128 {\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) -> u32 {\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) -> u32 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            da_gas_left()\n        }\n    }\n    pub fn is_static_call(_self: Self) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { is_static_call() } == 1\n    }\n\n    pub fn raw_storage_read<let N: u32>(_self: Self, storage_slot: Field) -> [Field; N] {\n        let mut out = [0; N];\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            out[i] = unsafe { storage_read(storage_slot + i as Field) };\n        }\n        out\n    }\n\n    pub fn storage_read<T, let N: u32>(self, storage_slot: Field) -> T\n    where\n        T: Packable<N>,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n\n    pub fn raw_storage_write<let N: u32>(_self: Self, storage_slot: Field, values: [Field; N]) {\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            unsafe { storage_write(storage_slot + i as Field, values[i]) };\n        }\n    }\n\n    pub fn storage_write<T, let N: u32>(self, storage_slot: Field, value: T)\n    where\n        T: Packable<N>,\n    {\n        self.raw_storage_write(storage_slot, value.pack());\n    }\n}\n\n// Unconstrained opcode wrappers (do not use directly).\nunconstrained fn address() -> AztecAddress {\n    address_opcode()\n}\nunconstrained fn sender() -> AztecAddress {\n    sender_opcode()\n}\nunconstrained fn transaction_fee() -> Field {\n    transaction_fee_opcode()\n}\nunconstrained fn chain_id() -> Field {\n    chain_id_opcode()\n}\nunconstrained fn version() -> Field {\n    version_opcode()\n}\nunconstrained fn block_number() -> u32 {\n    block_number_opcode()\n}\nunconstrained fn timestamp() -> u64 {\n    timestamp_opcode()\n}\nunconstrained fn fee_per_l2_gas() -> u128 {\n    fee_per_l2_gas_opcode()\n}\nunconstrained fn fee_per_da_gas() -> u128 {\n    fee_per_da_gas_opcode()\n}\nunconstrained fn l2_gas_left() -> u32 {\n    l2_gas_left_opcode()\n}\nunconstrained fn da_gas_left() -> u32 {\n    da_gas_left_opcode()\n}\nunconstrained fn is_static_call() -> Field {\n    is_static_call_opcode()\n}\nunconstrained fn note_hash_exists(note_hash: Field, leaf_index: Field) -> u1 {\n    note_hash_exists_opcode(note_hash, leaf_index)\n}\nunconstrained fn emit_note_hash(note_hash: Field) {\n    emit_note_hash_opcode(note_hash)\n}\nunconstrained fn nullifier_exists(nullifier: Field, address: Field) -> u1 {\n    nullifier_exists_opcode(nullifier, address)\n}\nunconstrained fn emit_nullifier(nullifier: Field) {\n    emit_nullifier_opcode(nullifier)\n}\nunconstrained fn emit_public_log(message: [Field]) {\n    emit_public_log_opcode(message)\n}\nunconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: Field) -> u1 {\n    l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\nunconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n    send_l2_to_l1_msg_opcode(recipient, content)\n}\nunconstrained fn call(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    args: [Field],\n) {\n    call_opcode(l2_gas_allocation, da_gas_allocation, address, args)\n}\n\nunconstrained fn call_static(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    args: [Field],\n) {\n    call_static_opcode(l2_gas_allocation, da_gas_allocation, address, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n    calldata_copy_opcode(cdoffset, copy_size)\n}\n\n// `success_copy` is placed immediately after the CALL opcode to get the success value\nunconstrained fn success_copy() -> bool {\n    success_copy_opcode()\n}\n\nunconstrained fn returndata_size() -> u32 {\n    returndata_size_opcode()\n}\n\nunconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n    returndata_copy_opcode(rdoffset, copy_size)\n}\n\npub unconstrained fn avm_return(returndata: [Field]) {\n    return_opcode(returndata)\n}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\nunconstrained fn avm_revert(revertdata: [Field]) {\n    revert_opcode(revertdata)\n}\n\nunconstrained fn storage_read(storage_slot: Field) -> Field {\n    storage_read_opcode(storage_slot)\n}\n\nunconstrained fn storage_write(storage_slot: Field, value: Field) {\n    storage_write_opcode(storage_slot, value);\n}\n\nimpl Empty for PublicContext {\n    fn empty() -> Self {\n        PublicContext::new(|| 0)\n    }\n}\n\n// AVM oracles (opcodes) follow, do not use directly.\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> u32 {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeFeePerL2Gas)]\nunconstrained fn fee_per_l2_gas_opcode() -> u128 {}\n\n#[oracle(avmOpcodeFeePerDaGas)]\nunconstrained fn fee_per_da_gas_opcode() -> u128 {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> u32 {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> u32 {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> Field {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(nullifier: Field, address: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n// TODO(#11124): rename unencrypted to public in avm\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    args: [Field],\n) {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\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"
     },
-    "64": {
+    "73": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/utility_context.nr",
       "source": "use crate::oracle::{\n    execution::{get_block_number, get_chain_id, get_contract_address, get_timestamp, get_version},\n    storage::storage_read,\n};\nuse dep::protocol_types::{address::AztecAddress, traits::Packable};\n\npub struct UtilityContext {\n    block_number: u32,\n    timestamp: u64,\n    contract_address: AztecAddress,\n    version: Field,\n    chain_id: Field,\n}\n\nimpl UtilityContext {\n    pub unconstrained fn new() -> Self {\n        // We could call these oracles on the getters instead of at creation, which makes sense given that they might\n        // not even be accessed. However any performance gains are minimal, and we'd rather fail early if a user\n        // incorrectly attempts to create a UtilityContext in an environment in which these oracles are not\n        // available.\n        let block_number = get_block_number();\n        let timestamp = get_timestamp();\n        let contract_address = get_contract_address();\n        let version = get_version();\n        let chain_id = get_chain_id();\n        Self { block_number, timestamp, contract_address, version, chain_id }\n    }\n\n    pub unconstrained fn at(contract_address: AztecAddress) -> Self {\n        let block_number = get_block_number();\n        let timestamp = get_timestamp();\n        let chain_id = get_chain_id();\n        let version = get_version();\n        Self { block_number, timestamp, contract_address, version, chain_id }\n    }\n\n    pub unconstrained fn at_historical(contract_address: AztecAddress, block_number: u32) -> Self {\n        let timestamp = get_timestamp();\n        let chain_id = get_chain_id();\n        let version = get_version();\n        Self { block_number, timestamp, contract_address, version, chain_id }\n    }\n\n    pub fn block_number(self) -> u32 {\n        self.block_number\n    }\n\n    pub fn timestamp(self) -> u64 {\n        self.timestamp\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.contract_address\n    }\n\n    pub fn version(self) -> Field {\n        self.version\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.chain_id\n    }\n\n    pub unconstrained fn raw_storage_read<let N: u32>(\n        self: Self,\n        storage_slot: Field,\n    ) -> [Field; N] {\n        storage_read(self.this_address(), storage_slot, self.block_number())\n    }\n\n    pub unconstrained fn storage_read<T, let N: u32>(self, storage_slot: Field) -> T\n    where\n        T: Packable<N>,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n}\n"
     },
-    "68": {
+    "76": {
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/event/event_selector.nr",
+      "source": "use dep::protocol_types::{\n    hash::poseidon2_hash_bytes,\n    traits::{Deserialize, Empty, FromField, Serialize, ToField},\n};\n\npub struct EventSelector {\n    // 1st 4-bytes (big-endian leftmost) of abi-encoding of an event.\n    // TODO(#2707): Consider making this a u64 as we already cast this to that when encoding the message. This would decrease\n    // the likelihood of collisions without any extra cost.\n    inner: u32,\n}\n\nimpl Eq for EventSelector {\n    fn eq(self, other: EventSelector) -> bool {\n        other.inner == self.inner\n    }\n}\n\nimpl Serialize<1> for EventSelector {\n    fn serialize(self: Self) -> [Field; 1] {\n        [self.inner as Field]\n    }\n}\n\nimpl Deserialize<1> for EventSelector {\n    fn deserialize(fields: [Field; 1]) -> Self {\n        Self { inner: fields[0] as u32 }\n    }\n}\n\nimpl FromField for EventSelector {\n    fn from_field(field: Field) -> Self {\n        Self { inner: field as u32 }\n    }\n}\n\nimpl ToField for EventSelector {\n    fn to_field(self) -> Field {\n        self.inner as Field\n    }\n}\n\nimpl Empty for EventSelector {\n    fn empty() -> Self {\n        Self { inner: 0 as u32 }\n    }\n}\n\nimpl EventSelector {\n    pub fn from_u32(value: u32) -> Self {\n        Self { inner: value }\n    }\n\n    pub fn from_signature<let N: u32>(signature: str<N>) -> Self {\n        let bytes = signature.as_bytes();\n        let hash = poseidon2_hash_bytes(bytes);\n\n        // `hash` is automatically truncated to fit within 32 bits.\n        EventSelector::from_field(hash)\n    }\n\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n}\n"
+    },
+    "78": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/hash.nr",
       "source": "use dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__PUBLIC_BYTECODE, GENERATOR_INDEX__PUBLIC_CALLDATA,\n        GENERATOR_INDEX__SECRET_HASH, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS,\n    },\n    hash::{\n        poseidon2_hash_subarray, poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice,\n        sha256_to_field,\n    },\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\n// Computes the hash of input arguments or return values for private functions, or for authwit creation.\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\n// Same as `hash_args_array`, but takes a slice instead of an array.\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// Computes the hash of calldata for public functions.\npub fn hash_calldata_array<let N: u32>(calldata: [Field; N]) -> Field {\n    if calldata.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(calldata, GENERATOR_INDEX__PUBLIC_CALLDATA)\n    }\n}\n\n// Same as `hash_calldata_array`, but takes a slice instead of an array.\npub fn hash_calldata(calldata: [Field]) -> Field {\n    if calldata.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(calldata, GENERATOR_INDEX__PUBLIC_CALLDATA)\n    }\n}\n\n/**\n * Computes the public bytecode commitment for a contract class.\n * The commitment is `hash([separator, ...bytecode])` where bytecode omits the length prefix present\n * in `packed_bytecode`.\n *\n * @param packed_bytecode - The packed bytecode of the contract class. 0th word is the length in bytes.\n *    packed_bytecode is mutable so that we can avoid copying the array to construct one starting with\n *    separator instead of length.\n * @returns The public bytecode commitment.\n */\npub fn compute_public_bytecode_commitment(\n    mut packed_public_bytecode: [Field; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS],\n) -> Field {\n    // First field element contains the length of the bytecode\n    let bytecode_length_in_bytes: u32 = packed_public_bytecode[0] as u32;\n    let bytecode_length_in_fields: u32 =\n        (bytecode_length_in_bytes / 31) + (bytecode_length_in_bytes % 31 != 0) as u32;\n    // Don't allow empty public bytecode.\n    // AVM doesn't handle execution of contracts that exist with empty bytecode.\n    assert(bytecode_length_in_fields != 0);\n    assert(bytecode_length_in_fields < MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);\n\n    // Packed_bytecode's 0th entry is the length. Replace it with separator before hashing.\n    let separator = GENERATOR_INDEX__PUBLIC_BYTECODE.to_field();\n    packed_public_bytecode[0] = separator;\n    // +1 to length to account for the separator\n    let nonzero_length = bytecode_length_in_fields + 1;\n\n    poseidon2_hash_subarray(packed_public_bytecode, nonzero_length)\n    // NOTE: we use poseidon2_hash_subarray here because we want to hash the bytecode only up to\n    // its nonzero length. We do NOT want to include a `1` at the end to indicate \"variable length\",\n    // and we want to enforce that all trailing elements are zero.\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"
-    },
-    "89": {
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/aztec.nr",
-      "source": "use crate::{\n    macros::{\n        dispatch::generate_public_dispatch,\n        functions::{stub_registry, utils::check_each_fn_macroified},\n        notes::{generate_note_export, NOTES},\n        storage::STORAGE_LAYOUT_NAME,\n        utils::{get_trait_impl_method, module_has_storage},\n    },\n    messages::discovery::private_notes::MAX_NOTE_PACKED_LEN,\n};\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `sync_private_state` utility function.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n    let interface = generate_contract_interface(m);\n\n    // Functions that don't have #[private], #[public], #[utility], #[contract_library_method], or #[test] are not\n    // allowed in contracts.\n    check_each_fn_macroified(m);\n\n    let contract_library_method_compute_note_hash_and_nullifier =\n        generate_contract_library_method_compute_note_hash_and_nullifier();\n    let note_exports = generate_note_exports();\n    let public_dispatch = generate_public_dispatch(m);\n    let sync_private_state = generate_sync_private_state();\n    let process_message = generate_process_message();\n\n    quote {\n        $note_exports\n        $interface\n        $contract_library_method_compute_note_hash_and_nullifier\n        $public_dispatch\n        $sync_private_state\n        $process_message\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::messages::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n    let notes = NOTES.entries();\n\n    if notes.len() > 0 {\n        let max_note_packed_len = notes.fold(\n            0,\n            |acc, (_, (_, len, _, _)): (Type, (TypeDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n                if len > acc {\n                    len\n                } else {\n                    acc\n                }\n            },\n        );\n\n        if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n            panic(\n                f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n            );\n        }\n\n        // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n        // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n        // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n        // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n        let mut if_note_type_id_match_statements_list = &[];\n        for i in 0..notes.len() {\n            let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n            let get_note_type_id = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteType },\n                quote { get_id },\n            );\n            let unpack = get_trait_impl_method(\n                typ,\n                quote { crate::protocol_types::traits::Packable<_> },\n                quote { unpack },\n            );\n\n            let compute_note_hash = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_note_hash },\n            );\n\n            let compute_nullifier_unconstrained = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_nullifier_unconstrained },\n            );\n\n            let if_or_else_if = if i == 0 {\n                quote { if }\n            } else {\n                quote { else if }\n            };\n\n            if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n                quote {\n                    $if_or_else_if note_type_id == $get_note_type_id() {\n                        // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n                        // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n                        // unpack function on it.\n                        let expected_len = $packed_note_length;\n                        let actual_len = packed_note.len();\n                        assert(\n                            actual_len == expected_len,\n                            f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n                        );\n\n                        let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n                        let note_hash = $compute_note_hash(note, storage_slot);\n    \n                        // The message discovery process finds settled notes, that is, notes that were created in prior\n                        // transactions and are therefore already part of the note hash tree. We therefore compute the\n                        // nullification note hash by treating the note as a settled note with the provided note 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(note_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::messages::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 `note_nonce`.\n            ///\n            /// The signature of this function notably matches the `aztec::messages::discovery::ComputeNoteHashAndNullifier` type,\n            /// and so it can be used to call functions from that module such as `discover_new_messages`, \n            /// `do_process_log` and `attempt_note_discovery`.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                packed_note: BoundedVec<Field, aztec::messages::discovery::private_notes::MAX_NOTE_PACKED_LEN>,\n                storage_slot: Field,\n                note_type_id: Field,\n                contract_address: aztec::protocol_types::address::AztecAddress,\n                note_nonce: Field,\n            ) -> Option<aztec::messages::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::messages::discovery::private_notes::MAX_NOTE_PACKED_LEN>,\n                _storage_slot: Field,\n                _note_type_id: Field,\n                _contract_address: aztec::protocol_types::address::AztecAddress,\n                _nonce: Field,\n            ) -> Option<aztec::messages::discovery::NoteHashAndNullifier> {\n                panic(f\"This contract does not use private notes\")\n            }\n        }\n    }\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n    let notes = NOTES.values();\n    // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n    // generating partial note helper functions.\n    notes\n        .map(|(s, _, note_type_id, fields): (TypeDefinition, u32, Field, [(Quoted, u32, bool)])| {\n            generate_note_export(s, note_type_id, fields)\n        })\n        .join(quote {})\n}\n\ncomptime fn generate_sync_private_state() -> Quoted {\n    // We obtain the `utility` function on the next line instead of directly doing\n    // `#[aztec::macros::functions::utility]` in the returned quote because the latter would result in the function\n    // attribute having the full path in the ABI. This is undesirable because we use the information in the ABI only\n    // to determine whether a function is `private`, `public`, or `utility`.\n    let utility = crate::macros::functions::utility;\n\n    // All we need to do here is trigger message discovery, but this is already done by the #[utility] macro - we don't\n    // need to do anything extra.\n    quote {\n        #[$utility]\n        unconstrained fn sync_private_state() {\n        }\n    }\n}\n\ncomptime fn generate_process_message() -> Quoted {\n    // We obtain the `utility` function on the next line instead of directly doing\n    // `#[aztec::macros::functions::utility]` in the returned quote because the latter would result in the function\n    // attribute having the full path in the ABI. This is undesirable because we use the information in the ABI only\n    // to determine whether a function is `private`, `public`, or `utility`.\n    let utility = crate::macros::functions::utility;\n\n    // TODO(#15012): Here we use PRIVATE_LOG_CIPHERTEXT_LEN for message ciphertext length. Fix message vs log naming.\n    quote {\n        #[$utility]\n        unconstrained fn process_message(\n            message_ciphertext: BoundedVec<Field, aztec::protocol_types::constants::PRIVATE_LOG_CIPHERTEXT_LEN>,\n            message_context: aztec::messages::processing::message_context::MessageContext,\n        ) {\n            aztec::messages::discovery::process_message::do_process_message(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\n                message_ciphertext,\n                message_context,\n            );\n        }\n    }\n}\n"
-    },
-    "90": {
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/dispatch.nr",
-      "source": "use super::utils::{compute_fn_selector, size_in_fields};\nuse poseidon::poseidon2::Poseidon2Hasher;\nuse std::{collections::umap::UHashMap, hash::BuildHasherDefault, panic};\n\n/// Returns an `fn public_dispatch(...)` function for the given module that's assumed to be an Aztec contract.\npub comptime fn generate_public_dispatch(m: Module) -> Quoted {\n    let functions = m.functions();\n    let functions =\n        functions.filter(|function: FunctionDefinition| function.has_named_attribute(\"public\"));\n\n    let unit = get_type::<()>();\n\n    let seen_selectors =\n        &mut UHashMap::<Field, Quoted, BuildHasherDefault<Poseidon2Hasher>>::default();\n\n    let ifs = functions.map(|function: FunctionDefinition| {\n        let parameters = function.parameters();\n        let return_type = function.return_type();\n\n        let selector: Field = compute_fn_selector(function);\n        let fn_name = function.name();\n\n        // Since function selectors are computed as the first 4 bytes of the hash of the function signature,\n        // it's possible to have collisions. With the following check, we ensure it doesn't happen within\n        // the same contract.\n        if seen_selectors.contains_key(selector) {\n            let existing_fn = seen_selectors.get(selector).unwrap();\n            panic(\n                f\"Public function selector collision detected between functions '{fn_name}' and '{existing_fn}'\",\n            );\n        }\n        seen_selectors.insert(selector, fn_name);\n\n        let mut parameters_size = 0;\n        for param in parameters {\n            parameters_size += size_in_fields(param.1);\n        }\n\n        let initial_read = if parameters.len() == 0 {\n            quote {}\n        } else {\n            // The initial calldata_copy offset is 1 to skip the Field selector\n            // The expected calldata is the serialization of\n            // - FunctionSelector: the selector of the function intended to dispatch\n            // - Parameters: the parameters of the function intended to dispatch\n            // That is, exactly what is expected for a call to the target function,\n            // but with a selector added at the beginning.\n            quote {\n                let input_calldata: [Field; $parameters_size] = dep::aztec::context::public_context::calldata_copy(1, $parameters_size);\n                let mut reader = dep::aztec::protocol_types::utils::reader::Reader::new(input_calldata);\n            }\n        };\n\n        let parameter_index: &mut u32 = &mut 0;\n        let reads = parameters.map(|param: (Quoted, Type)| {\n            let parameter_index_value = *parameter_index;\n            let param_name = f\"arg{parameter_index_value}\".quoted_contents();\n            let param_type = param.1;\n            let read = quote {\n                let $param_name: $param_type = reader.read_struct(dep::aztec::protocol_types::traits::Deserialize::deserialize);\n            };\n            *parameter_index += 1;\n            quote { $read }\n        });\n        let read = reads.join(quote { });\n\n        let mut args = &[];\n        for parameter_index in 0..parameters.len() {\n            let param_name = f\"arg{parameter_index}\".quoted_contents();\n            args = args.push_back(quote { $param_name });\n        }\n\n        let args = args.join(quote { , });\n        // name of the function is assigned just before the call so debug metadata doesn't span most of this macro when figuring out where the call comes from.\n        let name = function.name();\n        let call = quote { $name($args) };\n\n        let return_code = if return_type == unit {\n            quote {\n                $call;\n                // Force early return.\n                dep::aztec::context::public_context::avm_return([]);\n            }\n        } else {\n            quote {\n                let return_value = dep::aztec::protocol_types::traits::Serialize::serialize($call);\n                dep::aztec::context::public_context::avm_return(return_value.as_slice());\n            }\n        };\n\n        let if_ = quote {\n            if selector == $selector {\n                $initial_read\n                $read\n                $return_code\n            }\n        };\n        if_\n    });\n\n    if ifs.len() == 0 {\n        // No dispatch function if there are no public functions\n        quote {}\n    } else {\n        let ifs = ifs.push_back(quote { panic(f\"Unknown selector {selector}\") });\n        let dispatch = ifs.join(quote {  });\n\n        let body = quote {\n            // We mark this as public because our whole system depends on public\n            // functions having this attribute. However, the public MACRO will\n            // handle the public_dispatch function specially and do nothing.\n            #[public]\n            pub unconstrained fn public_dispatch(selector: Field) {\n                $dispatch\n            }\n        };\n\n        body\n    }\n}\n\ncomptime fn get_type<T>() -> Type {\n    let t: T = std::mem::zeroed();\n    std::meta::type_of(t)\n}\n"
-    },
-    "97": {
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr",
-      "source": "use crate::macros::{\n    functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n    notes::NOTES,\n    utils::{\n        add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_contract_library_method,\n        is_fn_initializer, is_fn_internal, is_fn_private, is_fn_public, is_fn_test, is_fn_utility,\n        is_fn_view, modify_fn_body, module_has_initializer, module_has_storage,\n    },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n    // Private Kernel Circuit.\n    // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n    // about the execution context (e.g. the caller).\n    let original_params = f.parameters();\n    f.set_parameters(&[(\n        quote { inputs },\n        quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n    )]\n        .append(original_params));\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    // TODO: Optimize args_hasher for small number of arguments\n    let args_hasher_name = quote { args_hasher };\n    let args_hasher = original_params.fold(\n        quote {\n            let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n        },\n        |args_hasher, param: (Quoted, Type)| {\n            let (name, typ) = param;\n            let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n            quote {\n                $args_hasher\n                $appended_arg\n            }\n        },\n    );\n\n    let context_creation = quote {\n        let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    // All private functions perform message discovery, since they may need to access notes. This is slightly\n    // inefficient and could be improved by only doing it once we actually attempt to read any. Note that the message\n    // discovery call syncs private events as well. We do not sync those here if there are no notes because we don't\n    // have an API that would access events from private functions.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n    // circuit expects.\n    let return_value_var_name = quote { macro__returned__values };\n\n    let return_value_type = f.return_type();\n    let return_value = if body.len() == 0 {\n        quote {}\n    } else if return_value_type != type_of(()) {\n        // The original return value is passed to a second args hasher which the context receives.\n        let (body_without_return, last_body_expr) = body.pop_back();\n        let return_value = last_body_expr.quoted();\n        let return_value_assignment =\n            quote { let $return_value_var_name: $return_value_type = $return_value; };\n        let return_hasher_name = quote { return_hasher };\n        let return_value_into_hasher =\n            add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n        body = body_without_return;\n\n        quote {\n            let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n            $return_value_assignment\n            $return_value_into_hasher\n            context.set_return_hash($return_hasher_name);\n        }\n    } else {\n        let (body_without_return, last_body_expr) = body.pop_back();\n        if !last_body_expr.has_semicolon()\n            & last_body_expr.as_for().is_none()\n            & last_body_expr.as_assert().is_none()\n            & last_body_expr.as_for_range().is_none()\n            & last_body_expr.as_assert_eq().is_none()\n            & last_body_expr.as_let().is_none() {\n            let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n            body = body_without_return.push_back(\n                quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n            );\n        }\n        quote {}\n    };\n\n    let context_finish = quote { context.finish() };\n\n    let to_prepend = quote {\n        $args_hasher\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n        $message_discovery_call\n    };\n\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $context_finish\n    };\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n    f.set_return_type(\n        quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n            .as_type(),\n    );\n    f.set_return_data();\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Public functions undergo a lot of transformations from their Aztec.nr form.\n    let original_params = f.parameters();\n    let args_len = original_params\n        .map(|(name, typ): (Quoted, Type)| {\n            generate_serialize_to_fields(name, typ, false).0.len()\n        })\n        .fold(0, |acc: u32, val: u32| acc + val);\n\n    // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n    let context_creation = quote {\n        let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n        // We start from 1 because we skip the selector for the dispatch function.\n        let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n        dep::aztec::hash::hash_args_array(serialized_args)\n        });\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n        // referenced. We instead ignore 'unused variable' warnings for it.\n        quote {\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n    };\n\n    let to_append = quote {\n        $mark_as_initialized\n    };\n\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n\n    // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n    // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n    // bytecode.\n    f.set_unconstrained(true);\n    f.set_return_public(true);\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_utility(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // Check if function is marked as unconstrained\n    if !f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[utility] but not marked as unconstrained, add unconstrained keyword\",\n        );\n    }\n\n    // Create utility context\n    let context_creation =\n        quote { let mut context = dep::aztec::context::utility_context::UtilityContext::new(); };\n    let module_has_storage = module_has_storage(f.module());\n\n    // Initialize Storage if module has storage\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(context);\n        }\n    } else {\n        quote {}\n    };\n\n    // All utility functions perform message discovery, since they may need to access private notes that would be\n    // found during this process or they may be used to sync private events from TypeScript\n    // (`sync_private_state` function gets invoked by PXE::getPrivateEvents function).\n    let message_discovery_call = create_message_discovery_call();\n\n    // Inject context creation, storage initialization, and message discovery call at the beginning of the function\n    // body.\n    let to_prepend = quote {\n        $context_creation\n        $storage_init\n        $message_discovery_call\n    };\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, quote {});\n    f.set_body(modified_body);\n\n    f.set_return_public(true);\n\n    fn_abi\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called internally\";\n    quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called statically\";\n    if is_fn_private(f) {\n        // Here `context` is of type context::PrivateContext\n        quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n    } else {\n        // Here `context` is of type context::PublicContext\n        quote { assert(context.is_static_call(), $assertion_message); }\n    }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\n/// Injects a call to `aztec::messages::discovery::discover_new_messages`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_message_discovery_call() -> Quoted {\n    quote {\n        /// Safety: message discovery returns nothing and is performed solely for its side-effects. It is therefore\n        /// always safe to call.\n        unsafe {\n            dep::aztec::messages::discovery::discover_new_messages(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\n            );\n        };\n    }\n}\n\n/// Checks if each function in the module is marked with either #[private], #[public], #[utility],\n/// #[contract_library_method], or #[test]. Non-macroified functions are not allowed in contracts.\npub(crate) comptime fn check_each_fn_macroified(m: Module) {\n    for f in m.functions() {\n        let name = f.name();\n        if !is_fn_private(f)\n            & !is_fn_public(f)\n            & !is_fn_utility(f)\n            & !is_fn_contract_library_method(f)\n            & !is_fn_test(f) {\n            panic(\n                f\"Function {name} must be marked as either #[private], #[public], #[utility], #[contract_library_method], or #[test]\",\n            );\n        }\n    }\n}\n"
     }
   }
 }