@aztec/protocol-contracts 0.69.0-devnet → 0.69.1-devnet

package/artifacts/ContractInstanceDeployer.json

@@ -1,8 +1,118 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.1+74f0a50ed44e5712",
+  "noir_version": "1.0.0-beta.1+c8a30535ada215cb",
   "name": "ContractInstanceDeployer",
   "functions": [
+    {
+      "name": "compute_note_hash_and_optionally_a_nullifier",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "16541607464495309456": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 16
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [
+          {
+            "name": "contract_address",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "nonce",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "storage_slot",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "note_type_id",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "compute_nullifier",
+            "type": {
+              "kind": "boolean"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "serialized_note",
+            "type": {
+              "kind": "array",
+              "length": 0,
+              "type": {
+                "kind": "field"
+              }
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": {
+          "abi_type": {
+            "kind": "array",
+            "length": 4,
+            "type": {
+              "kind": "field"
+            }
+          },
+          "visibility": "public"
+        }
+      },
+      "bytecode": "H4sIAAAAAAAA/9VZ227aQBBdsI2xiQmFP4jUt1ayCdc3pF7yHSiBL+gH+KEv7VeXFTv2YTypkJipykjRGs/6zNkz4931pufONjz99cJ1HNqB6xr12YW2vM0qRazSkmfvTnj274RndCc8Y0WePYGnb+l9S9z5nUvd+X3sOPFhn+gI/O5vQCzo79Bmoe2DXzExVSYMVgt/Uy5eM3dpyvyfs4CZ2uAvCX9og18S7y91i49jobhRaF/qVssXeMZbEa6xiAmXfH3wfWW+CHzfmA9r+DvzYd0TJ9JtAGNRrKuNdV5obCmMrfdO61yrHd4jrXNnWqMV5TxjfDh/4lNQn7rlM2C+GHwZ8yXgI/19+wT9eO5T6PcZ7vOajFy3hslPOUetLWoqNsA/2ULSneckri9jow91j0HPJ6aPxVqB+ljo7/WZvcOfrr2ltWssYnqiRqTZEPszXwa+uL6Mk4ffMcRBLOKRsP6fwu/H0A7gGXp+IsQfsPgXvIV7qBHHioR71N+/kx/D9cid6+cn9XfdeUpvU71aSHO2Hv66wc9s+B8JP7fBXxH+yAa/2cs8mODPS8IvbPhvCX9sUz/NXvLRhv+B8Ccm+IsDrbsfXGvN/BCup3Bfb+6uqmv2RBg/Z1yt9kRTxofrg+uv980ErhPBx3M4E+LMhDgSVqaI9aCI9fifjnGoiDVSxBorYmnmMVXE0tQrV8QqFLE0615TL8qjtE/ztgtteaNJ+zRF/Erap2l+u5PWVF+xoCGOL2H9fzCdRyY8qzmtOfSuUwyMXRjFvna9pviFwId454LvlkPZw3Jz3G6W29OWrFrNt00+C8aV38NvIpyPsb+09kv7PkWtS+m7fwy6eovBVzBfAj7iKH33j434X6M/xp8IPr7+X5vLqeuuhyM2bjzj2qmMuT3/k87mjeev5bXvJsXPXXe+/lfni6gP30vnAteJ4OP7k1yIkwtx7hGLn9Gjhr6uSae4bv1auVxv2n9w0VyUuMtzf8fiJ6z/r/Abx0btLXP+cb2vjs/74365f3tbvO6nDN9bH3T6A/vRhmkVHwAA",
+      "debug_symbols": "tdfRioQgFAbgd/HaC49aZq+yLIOVDYJYWC0s0buvDbO7w8zl8N8EJ06fIf7I2dngu+16CWmcFtZ+7CxOvVvDlEq1H5x1OcQYrpfH10ycD6tu/cvs0lkuq8sra5XkzKeBtVqUr8cQPWtrefCXRvPbaMxfYyWPT86sRsEVCq5RsEHBDQq2IJiEgMkEkyVMVjBZw+QKJtcw2cDkBibDMkiwDBIsgwTLIMEySLAMEiyD9F4Grbo3lm19oQ2ObnC0hdFS4GjC0RJHKxytcXSFo3FplLg0SlwaJSiNR6m+XA6ui/4+M41b6h9GqPV79k/T1Jyn3g9b9udc9T9SnYdYaa717RYvBZX/I2XKImWhHw==",
+      "brillig_names": [
+        "compute_note_hash_and_optionally_a_nullifier"
+      ]
+    },
+    {
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [],
+        "return_type": null
+      },
+      "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
+      "debug_symbols": "nZJLCoMwFEX38sYOzMdftiJFokYJhERiLBRx741iiy1OksmDG+65k5wVetEuYyP1YGZg9QrKdNxJo31atwRaK5WSY3N9hnQ/CB39eeJ6j7Pj1gEjOAGhe2A09fQglQCW4+2RAMKBfRLYp4H9LKyPb/criqqTqCjNvwwi5ICyGCiPgYoYqIyAyO3HV1lafqAMF7/Q5uOTW8lbJU6xhkV3F8/caxJ/yk3WdKJfrNjlu3jnb42KBGM/66ff",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
     {
       "name": "deploy",
       "is_unconstrained": false,
@@ -11,6 +121,10 @@
       ],
       "abi": {
         "error_types": {
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
@@ -1803,126 +1917,18 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "7V3bbuM4DP2XPOdBJCWSml9ZLAa9ZAYBirboZYFF0X9fO60UJ1HtFZzOyFP2oagTij48x5IoSk1eVteby+ef37e3P+4eV9/+elnd3F1dPG3vbrurlxXo7rXH+4vb/vLx6eLhafUNOLr1anN73f0pzr2uVz+2N5vVN8bX9YkxKum7MSrvjZUKxhQgvhtTiDhuDOyBEg72yNkcvZbsKTsHIt1bc8nYISdjJ2Fo/Pd6BdF4KfGCzngp8gLGS5EXNF6KvJDxUuTFGy9FXoLxUuSFjZciL2K8FHmxfLfMi+W7RV7I8t0yL5bvlnmxfLfMi+W7ZV688VLkxfLdMi+W75Z5aTzfDW7PC/spXkQzjepwFi+N57u/jZfG893fxYufn+96F8K7sXcRsrHA7gbw2TcoZmAUUtAe3ThBiDFJhQRTbJ5pCDs11pDHUg3BTTwCij5b44CTsjWFDITYhXG6ATE954BxECL5gjUzJBwuDmzfni4ybZrVxps2zWoT5mojGTiKnzA+13TyRbRh06ZZbcS0Oa82sNeGDvguaQN7112CFw6se3XU1GlYnWj5wKQ6TC6rozC1XszLFlQZuCYouXaIyTX4ASFCvTrBmToNqwOmTsPqWIWgZXWsRtCyOt7UaVidYOo0rA6bOg2rI6ZOw+qoqdOwOlYraFgdtlpBy+pYraBldaxW0LI6VitoWR1v+zsNq2NnClpWx04VnFmd6DLfjulAnZ5vOynwa/kur+dr7kDddnfuQYEn+ht6n2d6r5KtQUrGIOlUCYLuOyfoDntsGjv6hANxQDyUJPUs6QGPA9PYhymu7TA197fhWYf6MKHpMCnmQ+Ye/dGTKNg09oDZOLCOSwTskkbAGI4Dpa8SqP9zApWQJzkRntFDg3Fywgn/QZzEkJMh0BmciHFywskZ8iwX/Z4TmeDE+8yg737GOSHJ0EmBhsY99tg0do0pR6R4gl3dgrHDgrHjgrHTgrH7BWMPC8bOC8YuC8be9rw6jv3M8ypP1TrB5ZJEV8GCcewBsuuA4I+wR7dg7LBg7Lhg7NQ0dvScsTMfY/cLxh4WjJ0XjF2axs65th4EJiYyYUqBCuvxRBb1qwTa9oytkAPVgHMCBdf2/F4XaUzFDRGAk0jbzgbOGWnbucPHke7At508TID3ba9S8u4zaZAT8I0vy8fBl/MHybt5pDjxMUeMLkXKCPs7SLEUjR2gVF5GP1jzvX0qUvcotQaoOHn7znHSgKb+3100VdQVh5+R9S5BcdL0JFlkijx+A8DIuTNilLkxg2sLUndx+bC9udn+/H7wrSCu/wXFwaObtyAPT3SwfVkQyKV7y+Bw5dtOJ4TPdc/z3VPq4eLjsXs5g3vMiRAdu9fPdR/nu899T6Icuf/gS0LO5h5mu9d8pEr98ZPzwVdW1LlPu3ca+Ng9zXefxws9Jcef0X086lbdBYwMDZCPfHV/6v/rMeDzRifwxIa4uvyxiOrkcKuzu8DetHyAIualWNSTmaJ8vmC8Cdc3kfomWt8kVjcpb1WON4H6JljfhOqb1Kuv9eprvfpar77Wq6/16sd69WO9+uXycczHJ+Lg9ERqQvVNfH2TUN+E65tIfROtbPLaXf5z8bC9uLzZ9Elc/+7z7VXK6brLp3/v0zsp67t/uLvaXD8/bPr8b5D69Q8FyppwP+TvXgprcnmo7QViXAvusu3uoqverLtlWwelg/Mf",
+      "bytecode": "H4sIAAAAAAAA/+2dBZzcxNvHc7d3115LqQOlpYbU22R9q1fq7q57K3V39IAWaKFQoLgUaYu7u7u7u7s7lPf30A2dy2Wv0Jsc/f158/l8b7PJ3OT7TCYTm01yjK3DZp9hTPZtHc8BvsxnLmjqmGZ/quP5Lumqu0yr4TKtpsu02i7TdgNFjmlNXNI1dZnWzGVac5dpLVymtXOJ13SZFnCZFnaZFsl8qoP9vSjzGTDDwWAq4k9ZAStu+mPF0ZAZDBWHo1bUCkVDSX80EEhFg9FIrDgWMWNWMJCy0qFYIG1uHfbybcvLrNDgT3jp2XiHPS3LOUXc6oA8xVXKYUtmvKWxbbyVMt44k8b+vyb43hQ0A81926bbg89RBmbFBqu1xrya+PStm7211SHT9LL82mjMq6nG8tuHpPzaasyrmcby21dj+bm1DXsrbcM+yvi+ynhzR9uwH763AC1Bq0poG9ppzGs/jeumNUndbq8xrxYay68NSfl10JhXS43l19bjtqG10ga0UcbbKuOtHG1DO3xvDzoAsxLaBlNjXu00rhuLpG5bGvNqr7H8/CTl59eYVweN5RfwuG2wlDbAr4wHlHHT0TYE8T0EwiBSCW1DQGNeQY3rJkpSt4Ma8wppLL8YSfmFNOYV1lh+HT1uG6JKGxBTxjsq4xFH29AJ3zuDLqBrJbQNYY15ddK4brqR1O2Ixrw6ayy/Io/rdjelDhcp412U8a6Out0d3/cHPUBPl7qdq3ndtDD0lWcvfeVpqdd/Jd+mjnLQfV21t0fbkm7PPjvu6XdO2N71X/Wab29leh9Hne2L7/1AfzAgU2fzHPXVbSjSU96Wfb+gvHI3KzZYrQwP6keese1mkMeFFPAi73AoXByJpwNeFnzfStowzYoNVi8ST5++vEx14x6YOWoY5LzrOdCl9da9Fxuo8ahgsEd7scF/Yy9mVmywBpHsxYZo87SKvfQcuuOeQecEt73tkCx3W1sr40Mde9th+D4cjAAjfaXz0xm75BEx9J8N6MxrmMbtfpTHZwOjlHU9XBkfoYyPdKzr0fg+BowF41zOBnSv8/E7XgaBv1MGQ7IcXY5Wpo93lMEEfJ8IJvm29rjxugymaKsHgaCXnlN33DNp/o11NUW9o6Osq7bK+FTHuorjezFIgCTZ3d64xrYkRXJlRufd3mKN5Zf+D97tTWgsv2ke78tSStuQVsanKeNJR9swHd9ngJlgFtnd3uka183s/+Dd3hkay2/Of/Bu70yN5TfX47ZhttIGzFHG5yrjsxxtwzx8nw8WgIVkd3vnaVw3i/6Dd3vnayy/xf/Bu70LNJbfEo/bhkVKG7BYGV+ijC90tA1L8X0ZWA5WkN3tXapx3Rzg8bo5QFkHy5Tx5cr4Cse6ORDfDwIHg0Mq4dz8UH1lkHYrg0OVWA9UxieUc32iBN8PA4eDI3zb7n7lGmXvSrmViVmxwSrRWC9yFc+VmQ1rlfOCvswocUxblZmmDro3zBKNG9PKv59XYjt5Was0roC8TLnpuG26PW/Dw0q5UnNjZQ9HOiujTMjZTsXTWVm242ptL5gjNVbio3zaKoOplulRf2Njrqj7Ko3loLNMj/4HZbq9ZallerTSaFZVylMtU7Nig7Wl/Pz8ibQVCKUiITMcD4aS4YA/6Y+YyWAobUHYHwuiaNKJYDQZ9QfS/og/sUWv3591zG7Y7B2JvVddlRlfjc814JjMnjTfcG8MdTdYx3h05qB5HfvVsjg2U4nWOhtFmfG7Y9rav9FQmhUbShXijm6IqfTW4ViNG/Vaj1au7m4MOmM+TsnLigb8/khA0kWTOHtP4pjG708WB82EGU/4U7GgFUsH/cFAIpkoRp5xK22m44lYOrrVSzbEAqNyDmeP8+jI4Xifh8LH+/Tnu05jZfAq7nXKbkxTvq6uOhqAdT79+Z6gubLajbXk69zr6W6s22ssh9Ua6+qJmk+nKqvhOtGjhuskn4fCJ3nQcK3fyRsuiXu9Rw2XPejeWNUbzRUt0zUa18/JpBvryR5trKf4PBQ+xYON9dSdfGOVuE8l21hX+3bOxvQ0zZW+MLO+T1PO49co4+sz9VWQow17egdl3H4u1OlIewY4M/M/dt6rs+S9Vsl7e2nOwufZ4ByfN9vm+kwd1X10uUHzaatuP6/iPlfj9mMoQ65mz7Uat83zNMes+9KEbJ8614tskxs8qDvnV9Klnop6mhrzumAnrzvS9mu8BGfJtnK+B3VnI8llwsEa251NGteLegVD8m1qlL4bbmTmNTLcBz0ewYA3+YbTHuWb8ibfSNCjfP0elYPlUb4e1QevyjcY86gcvKpnZOXrWT3zqHy9qr/hkDf5Br1abx75RkyPfBMe5evRfijiVbvj0XoLe1TPAnFv8vV7VM8ixR7l+2f/lZqG++BcRjQUxYFoLBIOhBPpSCgUT0WKkykzkPaHI4mUacVDftx8thJ+KxEIR/3xeBp/wgFL97GxFLLO629ybrXR4+uPOuO389N9jaulB7HrdmxF4NiawLENgWNbAsf2BI4dCBwtAkc/gWOQwFHjL6NM3dcHIx7FrDEv176n2i9AbtJ4AXKzRxcgN2cuQJZXDjpueOtyjxreVALdMedojDlGEnOuxpg7ksTs0xhzp0qK2azYYHXWWH7dPbqZpHvn08Xg8OxK4tmNxLOIxLM7ief+JJ49SDx7knj2IvHsTeLZh8SzL4lnPxLP/iSeA0g8B5J4DiLxHEziOYTEcyiJ5zASz+EkniNIPEeSeI4i8RxN4jmGxHMsiec4Es/xJJ4TSDwnknhOIvGcTOI5hcRzKolnnMSzmMQzQeKZJPFMkXimSTynkXhOJ/GcQeI5k8RzFonnbBLPOSSec0k855F4zifxXEDiuZDEcxGJ52ISzyUknktJPJeReC4n8VxB4nkAieeBJJ4HkXgeTOJ5CInnoSSeJSSeh5F4Hk7ieQSJ50oSz1UknkeSeB5F4nk0iedqEs81JJ7HkHgeS+K5lsTzOBLP40k815F4nkDieSKJ50kknutJPE8m8TyFxPNUEs/TSDxPJ/E8g8TzTBLPs0g8zybxPIfEcwOJ57kknueReJ5P4nkBiedGEs9NJJ6bSTwvJPG8iMTzYhLPS0g8LyXxvIzE83ISzytIPK8k8byKxPNqEs9rSDyvJfG8jsTzehLPG0g8byTxvInE82YSz1tIPG8l8byNxPN2Es87SDzvJPG8i8TzbhLPe0g87yXxvI/E834SzwdIPB8k8XyIxPNhEs9HSDwfJfF8jMTzcRLPJ0g8nyTxfIrE82kSz2dIPJ8l8XyOxPN5Es8XSDxfJPF8icTzZRLPV0g8XyXxfI3E83USzzdIPN8k8XyLxPNtEs93SDzfJfF8j8TzfRLPD0g8PyTx/IjE82MSz09IPD8l8fyMxPNzEs8vSDy/JPH8isTza82euQ6/ir5nVzJdrfF95Bcgr40+/eX4jUfrO1ez57ca181gkncgf2dweH5P4vkDieePJJ4/kXj+TOL5C4nnrySev5F4/k7iuYXE8w8ST8mQwTOHxDOXxNNH4plH4plP4llA4lmFxLMqiWchiWc1Es/qJJ67kHjWIPHclcSzJolnLRLP2iSedUg865J41iPxrE/iuRuJ5+4knnuQeDYg8dyTxLMhiWcjEs+9SDwbk3g2IfFsSuLZzCNP3X0OcjTG3Jxk3eydU/HyS6X/HFJeeu6jwTMajwWRNOVlHfJpjHnfStpuzIoN1n45+sqvL0nfkhYk66alxnXTy8cRcyuNMQ8kqY+tSfY3bUg825J4tiPxbE/i2YHE0yTxtEg8/SSeARLPIIlniMQzTOIZIfGMknjGSDw7knh2IvHsTOLZhcSzK4lnNxLPIhLP7iSe+5N49iDx7Eni2YvEszeJZx8Sz74knv1IPPuTeA4g8RxI4jmIxHMwiecQEs+hJJ7DSDyHk3iOIPEcSeI5isRzNInnGBLPsSSe40g8x5N4TiDxnEjiOYnEczKJ5xQSz6kknnESz2ISzwSJZ5LEM0XimSbxnEbiOZ3EcwaJ50wSz1kknrNJPOeQeM4l8ZxH4jmfxHMBiedCEs9FJJ6LSTyXkHguJfFcRuK5nMRzBYnnASSeB5J4HkTieTCJ5yEknoeSeJaQeB5G4nk4iecRJJ4rSTxXkXgeSeJ5FInn0SSeq0k815B4HkPieSyJ51oSz+NIPI8n8VxH4nkCieeJJJ4nkXiuJ/E8mcTzFBLPU0k8TyPxPJ3E8wwSzzNJPM8i8TybxPMcEs8NJJ7nknieR+J5PonnBSSeG0k8N5F4bibxvJDE8yISz4tJPC8h8byUxPMyEs/LSTyvIPG8ksTzKhLPq0k8ryHxvJbE8zoSz+sVT/tZ4aHieHGoOOYPBVOBYCpsJgNmKBIPxQKhRMKKB8PJYCyajEZCfr+ViibDsaAZSYZiyVKeuQ7Pij6H/BuNMd9Asm5uzNFXfl6um5YaY77Jo3WjO+ZWGmO+mSTm1hpjvoUk5jYaY76VJOa2GmO+jSTm9hpjvp0k5g4aY76DJGZLY8x3ksTs1xjzXSQxBzXGfDdJzCGNMd+jOWbdx8aSR8SDMtTpeC/JecZ9JJ73k3g+QOL5YCW1a2bFBushjefBm0jeZ/YwSR16hMTzURLPx0g8HyfxfILE80kSz6dIPJ8m8XyGxPNZEs/nSDyfJ/F8gcTzRRLPl0g8XybxfIXE81USz9dIPF8n8XyDxPNNEs+3SDzfJvF8h8TzXRLP90g83yfx/IDE80MSz49IPD8m8fyExPNTEs/PSDw/J/H8gsTzSxLPr0g8vybx/IbE81sSz+9IPL8n8fyBxPNHEs+fSDx/JvH8hcTzVxLP30g8fyfx3ELi+QeJp3SuYvDMIfHMJfH0kXjmkXjmk3gWkHhWIfGsSuJZSOJZjcSzOonnLiSeNUg8dyXxrEniWYvEszaJZx0Sz7oknvVIPOuTeO5G4rk7ieceJJ4NSDz3JPFsSOLZiMRzLxLPxiSeTUg8m5J4NiPxbE7iuTeJ5z4knvuSeO5H4tmCxLMliWcrEs/WJJ5tSDzbkni2I/FsT+LZgcTTJPG0SDz9JJ4BEs8giWeIxDNM4hkh8YySeMZIPDuSeHYi8exM4tmFxLMriWc3Es8iEs/uJJ77k3j2IPHsSeLZi8SzN4lnHxLPviSe/Ug8+5N4DiDxHEjiOYjEczCJ5xASz6EknsNIPIeTeI4g8RxJ4jmKxHM0iecYEs+xJJ7jSDzHk3hOIPGcSOI5icRzMonnFBLPqSSecRLPYhLPBIlnksQzReKZJvGcRuI5ncRzBonnTBLPWSSes0k855B4ziXxnEfiOZ/EcwGJ50ISz0UknotJPJeQeC4l8VxG4rmcxHMFiecBJJ4HkngeROJ5MInnISSeh5J4lpB4HkbieTiJ5xEknitJPFeReB5J4nkUiefRJJ6rSTzXkHgeQ+J5LInnWhLP40g8jyfxXEfieQKJ54kknieReK4n8TyZxPMUEs9TSTxPI/E8ncTzDBLPM0k8zyLxPJvE8xwSzw0knueSeJ5H4nk+iecFJJ4bSTw3kXhuJvG8kMTzIhLPi0k8LyHxvJTE8zISz8tJPK8g8bySxPMqEs+rSTyvIfG8lsTzOhLP60k8byDxvJHE8yYSz5tJPG8h8byVxPM2Es/bSTzvIPG8k8TzLhLPu0k87yHxvJfE8z4Sz/tJPB8g8XyQxPMhEs+HSTwfIfF8lMTzMRLPx0k8nyDxfJLE8ykSz6dJPJ8h8XyWxPM5Es/nSTxfIPF8kcTzJRLPl0k8XyHxfJXE8zUSz9dJPN8g8XyTxPMtEs+3STzfIfF8l8TzPRLP90k8PyDx/JDE8yMSz49JPD8h8fyUxPMzEs/PSTy/IPH8ksTzKxLPr0k8vyHx/JbE8zsSz+9JPH8g8fzRI89ch2fADAeDqYg/ZQWsuOmPFUdDZjBUHI5aUSsUDSX90UAgFQ1GI7HiWMSMWcFAykqHYoF0Ju8WGmP+qZJiNis2WD/n6iu/zT6O9Zynsfx+Ianb+Rpj/pUk5gKNMf9GEnMVjTH/ThJzVY0xbyGJuVBjzH+QxFxNY8wGyb6qusaYc0hi3kVjzLkkMdfQGLOPJOZdNcacRxJzTY0x55PEXEtjzAUkMdfWGHMVkpjraIy5KknMdTXGXEgScz2NMVcjibm+xpirk8S8m8aYdyGJeXeNMdcgiXkPjTHvShJzA40x1ySJeU+NMdciibmhxphrk8TcSGPMdUhi3ktjzHVJYm6sMeZ6JDE30RhzfZKYm2qMeTeSmJtpjHl3kpiba4x5D5KY99YYcwOSmPfRGPOeJDHvqzHmhiQx76cx5kYaY0ZWf/bxeT8TcBTEQEfQCXQGXUBX0C0TQ3ewP+gBeoJeoDfoA/qCfqA/GAAGgkFgMBgChoJhYDgYAUaCUWA0GAPGgnFgPJgAJoJJYDKYAqaCOCgGCZAEKZAG08B0MAPMBLPAbDAHzAXzwHywACwEi8BisAQsBcvAcrACHAAOBAeBg8Eh4FBQAg4Dh4MjwEqwChwJjgJHg9VgDTgGHAvWguPA8WAdOAGcCE4C68HJ4BRwKjgNnA7OAGeCs8DZ4BywAZwLzgPngwvARrAJbAYXgovAxeAScCm4DFwOrgBXgqvA1eAacC24DlwPbgA3gpvAzeAWcCu4DdwO7gB3grvA3eAecC+4D9wPHgAPgofAw+AR8Ch4DDwOngBPgqfA0+AZ8Cx4DjwPXgAvgpfAy+AV8Cp4DbwO3gBvgrfA2+Ad8C54D7wPPgAfgo/Ax+AT8Cn4DHwOvgBfgq/A1+Ab8C34DnwPfgA/gp/Az+AX8Cv4DfwOtoA/gGwsOSAX+EAeyAcFoAqoCgpBNVAd7AJqgF1BTVAL1AZ1QF1QD9QHu4HdwR6gAdgTNASNwF6gMWgCmoJmoDnYG+wD9gX7gRagJWgFWoM2oC1oB9qDDsAEFvCDAAiCEAiDCIiCGOgIOoHOoAvoCrqBItAd7A96gJ6gF+gN+oC+oB/oDwaAgWAQGAyGgKFgGBgORoCRYBQYDcaAsWAcGA8mgIlgEpgMpoCpIA6KQQIkQQqkwTQwHcwAM8EsMBvMAXPBPDAfLAALwSKwGCwBS8EysBysAAeAA8FB4GBwCDgUlIDDwOHgCLASrAJHgqPA0WA1WAOOAceCteA4cDxYB04AJ4KTwHpwMjgFnApOA6eDM8CZ4CxwNjgHbADngvPA+eACsBFsApvBheAicDG4BFwKLgOXgyvAleAqcDW4BlwLrgPXgxvAjeAmcDO4BdwKbgO3gzvAneAucDe4B9wL7gP3gwfAg+Ah8DB4BDwKHgOPgyfAk+Ap8DR4BjwLngPPgxfAi+Al8DJ4BbwKXgOvgzfAm+At8DZ4B7wL3gPvgw/Ah+Aj8DH4BHwKPgOfgy/Al+Ar8DX4BnwLvgPfgx/Aj+An8DP4BfwKfgO/gy3gDyAHBjkgF/hAHsgHBaAKqAoKQTVQHewCaoBdQU1QC9QGdUBdUA/UB7uB3cEeoAHYEzQEjcBeoDFoApqCZqA52BvsA/YF+4EWoCVoBVqDNqAtaAfagw7ABBbwgwAIghAIgwiIghjoCDqBzqAL6Aq6gSLQHewPeoCeoBfoDfqAvqAf6A8GgIFgEBgMhoChYBgYDkaAkWAUGA3GgLFgHBgPJoCJYBKYDKaAqSAOikECJEEKpME0MB3MADPBLDAbzAFzwTwwHywAC8EisBgsAUvBMrAcrADyvnp5F7y8Z13eYS7vB5d3b5cAeWe0vI9Z3nUs7xGWd/TK+2/l3bLy3lZ5J6q8b1Te5SnvyZR3UMr7HeXdifJeQnnnn7xPT95VJ++Bk3esyfvL5N1g8t4teaeVvC9K3sUk7zmSdwjJ+3nk3TfnAnlni7wPRd41Iu/xkHdkyPsn5N0O8t4EeSeBPO9fnqUvz6mXZ8DL89Xl2eXyXHB55rY8z1qeFS3PYZZnHMvzg+XZvPLcW3mmrDyvVZ6FKs8ZlWd4yvMx5dmTdwF5ZqI8j1Ce9SfP0ZNn1Mnz3+TZavLcMnkmmDxvS55lJc+JkmcwyfON5NlB8lweeeaNPE9GntUiz0GRZ4zI8zvk2Rjy3Al5poM8L0GeRSC/85ff0Mvv0+W3328B+c2y/B5Yfmsrv2OVY1f5/aX8tlF+Nyi/yZPfu8lvyeR3WvIbKPl9kfx2R34XI785kd9zyG8l5HcI0sdf+s9L33Tpqy39oKUvr/Rtlb6e0vdR+gJK3zjpKyZ9p6QvkfStkb4m0vdC+iLIvXm5Vy33buVeptzbk3tdcu9H7oXIvQG5Vi7XjuVaqlxblGttcu1JrsXItQk5V5dzVzmXk3MbOdbP3XrYYUhfZRmixrYh0ySJ1p/zpW+v9HWVvp/SF1L6BkpfOek7Jn2ppG+R9LWRvifSF0P6Jsi9erl3Lfdy5d6m3OuTe19yL0jujci9Arl2LteS5dqqXGuUa29NQTPQHMi5u5zLyrmdnOtI//mWoBVoDdqAtqAdaA86ADnhsoAfBEAQhEAYRIyyQ1VlvFXms/573RsseOTCXmo6q5x5gzOfGy5ufH3D93LHq/OGlDNvZDnzRpczb3E5LsuyzKuS+QxnPgszn7mZT1nnsr6LMt/Nig1WoZKv7vyjOEsuNEoPmv0DhUqeHuTvt/PP8yZ/017fPUpK5284lutzpHP7nxqZ8RyjbBo7Di/qEdZz0ONysuz8C7zJP2CXW75Sdj6XmOzl1zBKryt7vtunYZRep4ZjWdUMT+uwVV5sqr9dN2o50jvLIFte+f8wr39znaplra7TP9OUbJuX65iXp8zLd8zLLykbo+y3Givp3LZBO10rR7l42SZ71RbIUNfFX12WDFVKjL8Guwx8yjS7LO2yraqmd8wrVObllZReTrXM9zxlOWpetke+I33LzPeamc8C5X/s/6/lsvwCx/JLebtMc5ZLoUv6Qpf0UmebZcbl+E7qj6nkla3e5xpl86pplN3G7f/1eBv15xhl2yFne6Iu3z6OlWF+PDGr+8JpS+ak5i5epDa2zn82XIK25+Uo07PtfJ3/41PSq0N1Y9sBW15J6fRFmelmBYZI1DTtZdobQb5RuvAMx/LzHelDme/VlHjUeIt20DMdiVvpQDwdD8WTyWAiXseRv2FsK0cpJ/tImfwAN15ZB7gebYB/7QyqeJO/6wGuGos9367DPUu2lWXPktJOdpreSpreWdL0UdL0UdLIUN6BsnMnrXq4HfT1cszLM8q62fPUBtl2koa7nuIlQ9+Sbb45jnn9lHm2o5cnQajjUY8P7v11jextr5RPJ6N0Odr1x06rloFH9TiQ41ieYbgf1NvLr2Z4ut3+dVBfxeHjLB+7jsiOs25mPBGfPXvowhlL44tTvZfMTSyeMW+uGoKaba5LiNl2qWr1dqZzblLOzci56aibi5pvtv93TrOXXdMoeyxa4HB0rlLnNOe5jPP/ZXBrUnKyfNrLMbazHDdnt+ZpR5fj8bUTs5bDVV2Wx01KyK3JNRxlWN56VJsR5zZguJSvoaRRm67uSr7OdE4ft3NSt2Nh5/pyu06xvXNeZ7kXZllOUea7WbEh7NZ0O+NXy9y5Pqoq8/7p+rBj+qfrQy2jKo556rbmc8xT/ew8GE4NijLf/+1TA3WXX9MoW3edbbu6npxtm9fnrXa9sMva6VOgzFfT9818SqwjHbGp20h51+mcDmp6Ne48R3mp23iVyimvcg9X3MrLTm9v9wVZ0qvlr6YfmvmU72My4277VZ9jXq5L3m7bvF2GUl91by+paCxpxtKpuGVZ/qSZ2t72onv5wVA8kohHLCsWtFJBK7S95TfLjJOfyocr61Tey/JxOz7QlL/rqbzbsV15p9dVjW37Xvuzp5JfjmNeL5dleXy6G/y3T3cbZsbdjtuc27jzuq5zX2FkyUPNx1mu6nor2rGYLecEZ5zlxeZ2zJuXJW71//Nd4s535O9cp4bLMnxZ/tct39xy4tje/6plz37s2DTz/d8+dmySGf//fVG5w3+m38SOXup120+p+yI7P4/7VYQ8Xk9WXSP7/kPKoMG2oilVrvlG9v1IviOtfXlbjuFrZ8mvoJz83K6PqP+3e2bc7b65obGs3DxyXDzKu0bA0Jbb/RX+7bZ8Zmacuy0Pp7jbcn8xSx849f96Kml6ZknTS0nTK0uabLca1TTZbjWqafoqafpmSdNPSdMvS5r+Spr+WdIMUNIMyJJmoJJmYJY0g5Q0g7KkGaykGZwlzRAlzZAsaYYqaYZmSTNMSTMsS5rhSprhWdKMUNKMyJJmpJJmZJY0o5Q0o7KkGa2kGZ0lzRglzZgsacYqacZmSTNOSTMuS5rxSprxWdJMUNJMyJJmopJmYpY0k5Q0k7KkmaykmexI43E/uIC37ZqVKK+PqLf3W6xkjmN5hlG6TTUcy9/Z+qC69cXMcczLKykbx/b6YnZV0rnVLRm8PaYPpT3en6b/xXpn/i/WO+e8vJKycfzTepftfKtfZtzbtm/rMalXdVyG/4U+wPY9up25D3D3zLh93zRppze83M7NtHM/7jPKXjdVXSuje1aO4X7v1O1+p1t3vZwsn3Zeznn2sqoZnrbnVnmx5bmUtVs/Jee1bLe8Cv5hXv/mOnW7B5zj+K6mz3WJza2tr+KYl6fMc/5ORG3r1T4mXR3l41Ebmy5v35bjEq89vapLerd6VNMoW75VHbEVehObv7x1r/YFspe/izI9mSpeMm3gvGmGY3Bet7PLrZGSRl1fuUbZul8lS16G47szT5/B+5OBGZnvO0O/IEMpL9VH970Le5ke5G+q7ZPhiEVdrrMM8lz+LyfL91zHZ3lpndPVaTVc5tl52t2JVV87jkLHZ30lXy+u3dbzJn/XdVVfGa/niFMt7yJNDnZ+9jbr1qc11zFPPadQ/XL0+1lOF5/LsuzBrjP1lGl2ef4fq0JPneGtAgA=",
+      "debug_symbols": "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",
       "brillig_names": [
+        "pack_arguments_oracle_wrapper",
+        "call_private_function_internal",
         "decompose_hint",
         "lte_hint",
         "debug_log_oracle_wrapper",
         "directive_integer_quotient",
         "directive_invert"
       ],
-      "verification_key": "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"
-    },
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [],
-        "return_type": null
-      },
-      "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
-      "debug_symbols": "nZLNCoQgFIXf5a5bpGk/vkoMYWUhiIbZwBC9+1g0QzO00c2FI+c7G78VetEuYyP1YGZg9QrKdNxJo31atwRaK5WSY3N9hnQ/CB39eeJ6j7Pj1gHLcAJC98BI6ulBKgEsx9sjAYQD+1lgnwT2aVgf3+5XBFUnURGSfxmU0QOiMVAeAxUxUBkBZbcfX9G0/EAUF7/Q5uOTW8lbJU6xhkV3F8/caxJ/yk3WdKJfrNjlu3jnb42KBGM/66ff",
-      "brillig_names": [
-        "sync_notes"
-      ]
-    },
-    {
-      "name": "compute_note_hash_and_optionally_a_nullifier",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "16541607464495309456": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 16
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [
-          {
-            "name": "contract_address",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "nonce",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "storage_slot",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "note_type_id",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "compute_nullifier",
-            "type": {
-              "kind": "boolean"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "serialized_note",
-            "type": {
-              "kind": "array",
-              "length": 0,
-              "type": {
-                "kind": "field"
-              }
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": {
-          "abi_type": {
-            "kind": "array",
-            "length": 4,
-            "type": {
-              "kind": "field"
-            }
-          },
-          "visibility": "public"
-        }
-      },
-      "bytecode": "H4sIAAAAAAAA/9VZ227aQBBdsI2xiQmFP4jUt1ayCdc3pF7yHSiBL+gH+KEv7VeXFTv2YTypkJipykjRGs/6zNkz4931pufONjz99cJ1HNqB6xr12YW2vM0qRazSkmfvTnj274RndCc8Y0WePYGnb+l9S9z5nUvd+X3sOPFhn+gI/O5vQCzo79Bmoe2DXzExVSYMVgt/Uy5eM3dpyvyfs4CZ2uAvCX9og18S7y91i49jobhRaF/qVssXeMZbEa6xiAmXfH3wfWW+CHzfmA9r+DvzYd0TJ9JtAGNRrKuNdV5obCmMrfdO61yrHd4jrXNnWqMV5TxjfDh/4lNQn7rlM2C+GHwZ8yXgI/19+wT9eO5T6PcZ7vOajFy3hslPOUetLWoqNsA/2ULSneckri9jow91j0HPJ6aPxVqB+ljo7/WZvcOfrr2ltWssYnqiRqTZEPszXwa+uL6Mk4ffMcRBLOKRsP6fwu/H0A7gGXp+IsQfsPgXvIV7qBHHioR71N+/kx/D9cid6+cn9XfdeUpvU71aSHO2Hv66wc9s+B8JP7fBXxH+yAa/2cs8mODPS8IvbPhvCX9sUz/NXvLRhv+B8Ccm+IsDrbsfXGvN/BCup3Bfb+6uqmv2RBg/Z1yt9kRTxofrg+uv980ErhPBx3M4E+LMhDgSVqaI9aCI9fifjnGoiDVSxBorYmnmMVXE0tQrV8QqFLE0615TL8qjtE/ztgtteaNJ+zRF/Erap2l+u5PWVF+xoCGOL2H9fzCdRyY8qzmtOfSuUwyMXRjFvna9pviFwId454LvlkPZw3Jz3G6W29OWrFrNt00+C8aV38NvIpyPsb+09kv7PkWtS+m7fwy6eovBVzBfAj7iKH33j434X6M/xp8IPr7+X5vLqeuuhyM2bjzj2qmMuT3/k87mjeev5bXvJsXPXXe+/lfni6gP30vnAteJ4OP7k1yIkwtx7hGLn9Gjhr6uSae4bv1auVxv2n9w0VyUuMtzf8fiJ6z/r/Abx0btLXP+cb2vjs/74365f3tbvO6nDN9bH3T6A/vRhmkVHwAA",
-      "debug_symbols": "tdfRioQgFAbgd/HaC49aZq+yLIOVDYJYWC0s0buvDbO7w8zl8N8EJ06fIf7I2dngu+16CWmcFtZ+7CxOvVvDlEq1H5x1OcQYrpfH10ycD6tu/cvs0lkuq8sra5XkzKeBtVqUr8cQPWtrefCXRvPbaMxfYyWPT86sRsEVCq5RsEHBDQq2IJiEgMkEkyVMVjBZw+QKJtcw2cDkBibDMkiwDBIsgwTLIMEySLAMEiyD9F4Grbo3lm19oQ2ObnC0hdFS4GjC0RJHKxytcXSFo3FplLg0SlwaJSiNR6m+XA6ui/4+M41b6h9GqPV79k/T1Jyn3g9b9udc9T9SnYdYaa717RYvBZX/I2XKImWhHw==",
-      "brillig_names": [
-        "compute_note_hash_and_optionally_a_nullifier"
-      ]
+      "verification_key": "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"
     }
   ],
   "outputs": {
@@ -2366,7 +2372,15 @@
     }
   },
   "file_map": {
-    "135": {
+    "119": {
+      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/arguments.nr",
+      "source": "/// Notifies the simulator that `args` will later be used at some point during execution, referenced by their hash. This\n/// allows the simulator to know how to respond to this future request.\n///\n/// This is only used during private execution, since in public it is the VM itself that keeps track of arguments.\npub fn pack_arguments(args: [Field]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call. When\n    // unpacking however the caller must check that the returned value is indeed the preimage.\n    unsafe { pack_arguments_oracle_wrapper(args) };\n}\n\n/// Same as `pack_arguments`, but using arrays instead of slices.\npub fn pack_arguments_array<let N: u32>(args: [Field; N]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call. When\n    // unpacking however the caller must check that the returned value is indeed the preimage.\n    unsafe { pack_arguments_array_oracle_wrapper(args) };\n}\n\nunconstrained fn pack_arguments_oracle_wrapper(args: [Field]) {\n    let _ = pack_arguments_oracle(args);\n}\n\nunconstrained fn pack_arguments_array_oracle_wrapper<let N: u32>(args: [Field; N]) {\n    let _ = pack_arguments_array_oracle(args);\n}\n\n#[oracle(packArguments)]\nunconstrained fn pack_arguments_oracle(_args: [Field]) -> Field {}\n\n#[oracle(packArgumentsArray)]\nunconstrained fn pack_arguments_array_oracle<let N: u32>(_args: [Field; N]) -> Field {}\n"
+    },
+    "121": {
+      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr",
+      "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, utils::reader::Reader,\n};\n\n#[oracle(callPrivateFunction)]\nunconstrained fn call_private_function_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _start_side_effect_counter: u32,\n    _is_static_call: bool,\n) -> [Field; 2] {}\n\npub unconstrained fn call_private_function_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    start_side_effect_counter: u32,\n    is_static_call: bool,\n) -> (u32, Field) {\n    let fields = call_private_function_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        start_side_effect_counter,\n        is_static_call,\n    );\n\n    let mut reader = Reader::new(fields);\n    let end_side_effect_counter = reader.read_u32();\n    let returns_hash = reader.read();\n\n    (end_side_effect_counter, returns_hash)\n}\n"
+    },
+    "133": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
       "source": "use crate::{note::{note_header::NoteHeader, note_interface::NoteInterface}, utils::array};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let note_content = array::subarray(fields, read_offset + 2);\n\n            let mut note = Note::deserialize_content(note_content);\n            note.set_header(NoteHeader { contract_address, nonce, storage_slot, note_hash_counter });\n\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_indexed_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_indexed_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_indexed_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_indexed_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
     },
@@ -2382,41 +2396,57 @@
       "path": "std/field/mod.nr",
       "source": "pub mod bn254;\nuse crate::runtime::is_unconstrained;\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        assert(BIT_SIZE < modulus_num_bits() as u32);\n        self.__assert_max_bit_size(BIT_SIZE);\n    }\n\n    #[builtin(apply_range_constraint)]\n    fn __assert_max_bit_size(self, bit_size: u32) {}\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n    /// This slice will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n    /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n    /// wrap around due to overflow when verifying the decomposition.\n    #[builtin(to_le_bits)]\n    // 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\n    /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n    /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n    /// wrap around due to overflow when verifying the decomposition.\n    #[builtin(to_be_bits)]\n    // 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\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        // 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        // Compute the byte decomposition\n        let bytes = self.to_be_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_be_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[i] != p[i]) {\n                        assert(bytes[i] < p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    // docs:start:to_le_radix\n    pub fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            crate::assert_constant(radix);\n        }\n        self.__to_le_radix(radix)\n    }\n    // docs:end:to_le_radix\n\n    // docs:start:to_be_radix\n    pub fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            crate::assert_constant(radix);\n        }\n        self.__to_be_radix(radix)\n    }\n    // docs:end:to_be_radix\n\n    // `_radix` must be less than 256\n    #[builtin(to_le_radix)]\n    fn __to_le_radix<let N: u32>(self, radix: u32) -> [u8; N] {}\n\n    #[builtin(to_be_radix)]\n    fn __to_be_radix<let N: u32>(self, radix: u32) -> [u8; N] {}\n\n    // Returns self to the power of the given exponent value.\n    // Caution: we assume the exponent fits into 32 bits\n    // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n    pub fn pow_32(self, exponent: Field) -> Field {\n        let mut r: Field = 1;\n        let b: [u1; 32] = exponent.to_le_bits();\n\n        for i in 1..33 {\n            r *= r;\n            r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n        }\n        r\n    }\n\n    // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n    pub fn sgn0(self) -> u1 {\n        self as u1\n    }\n\n    pub fn lt(self, another: Field) -> bool {\n        if crate::compat::is_bn254() {\n            bn254_lt(self, another)\n        } else {\n            lt_fallback(self, another)\n        }\n    }\n\n    /// Convert a little endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n\n    /// Convert a big endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[N - 1 - i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n    __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..16 {\n        high = high + (bytes32[15 - i] as Field) * v;\n        low = low + (bytes32[16 + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    // Abuse that a % p + b % p = (a + b) % p and that low < p\n    low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n    if is_unconstrained() {\n        unsafe {\n            //@safety : unconstrained context\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 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        let field = 2;\n        let bytes: [u8; 8] = field.to_be_radix(256);\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_radix_example\n\n    #[test]\n    // docs:start:to_le_radix_example\n    fn test_to_le_radix() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_le_radix(256);\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_radix_example\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"
     },
-    "231": {
+    "230": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
       "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        MAX_FIELD_VALUE,\n    },\n    contract_class_id::ContractClassId,\n    hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n    merkle_tree::membership::MembershipWitness,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n    traits::{Deserialize, Empty, FromField, Serialize, ToField},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse ec::{pow, sqrt};\nuse std::embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key};\n\n// Aztec address\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        FromField::from_field(fields[0])\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secrect can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_private_function(\n        function_selector: FunctionSelector,\n        function_vk_hash: Field,\n        function_leaf_membership_witness: MembershipWitness<FUNCTION_TREE_HEIGHT>,\n        contract_class_artifact_hash: Field,\n        contract_class_public_bytecode_commitment: Field,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let private_functions_root = private_functions_root_from_siblings(\n            function_selector,\n            function_vk_hash,\n            function_leaf_membership_witness.leaf_index,\n            function_leaf_membership_witness.sibling_path,\n        );\n\n        let contract_class_id = ContractClassId::compute(\n            contract_class_artifact_hash,\n            private_functions_root,\n            contract_class_public_bytecode_commitment,\n        );\n\n        // Compute contract address using the preimage which includes the class_id.\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
     },
-    "234": {
+    "233": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/address/partial_address.nr",
       "source": "use crate::{\n    address::{aztec_address::AztecAddress, salted_initialization_hash::SaltedInitializationHash},\n    constants::GENERATOR_INDEX__PARTIAL_ADDRESS,\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    traits::{Deserialize, Serialize, ToField},\n};\n\nglobal PARTIAL_ADDRESS_LENGTH: u32 = 1;\n\n// Partial address\npub struct PartialAddress {\n    pub inner: Field,\n}\n\nimpl ToField for PartialAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl Serialize<PARTIAL_ADDRESS_LENGTH> for PartialAddress {\n    fn serialize(self: Self) -> [Field; PARTIAL_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<PARTIAL_ADDRESS_LENGTH> for PartialAddress {\n    fn deserialize(fields: [Field; PARTIAL_ADDRESS_LENGTH]) -> Self {\n        PartialAddress { inner: fields[0] }\n    }\n}\n\nimpl PartialAddress {\n    pub fn from_field(field: Field) -> Self {\n        Self { inner: field }\n    }\n\n    pub fn compute(\n        contract_class_id: ContractClassId,\n        salt: Field,\n        initialization_hash: Field,\n        deployer: AztecAddress,\n    ) -> Self {\n        PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            SaltedInitializationHash::compute(salt, initialization_hash, deployer),\n        )\n    }\n\n    pub fn compute_from_salted_initialization_hash(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n    ) -> Self {\n        PartialAddress::from_field(poseidon2_hash_with_separator(\n            [contract_class_id.to_field(), salted_initialization_hash.to_field()],\n            GENERATOR_INDEX__PARTIAL_ADDRESS,\n        ))\n    }\n\n    pub fn to_field(self) -> Field {\n        self.inner\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.to_field() == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n"
     },
-    "236": {
+    "235": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/address/salted_initialization_hash.nr",
       "source": "use crate::{\n    address::aztec_address::AztecAddress, constants::GENERATOR_INDEX__PARTIAL_ADDRESS,\n    hash::poseidon2_hash_with_separator, traits::ToField,\n};\n\n// Salted initialization hash. Used in the computation of a partial address.\npub struct SaltedInitializationHash {\n    pub inner: Field,\n}\n\nimpl ToField for SaltedInitializationHash {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl SaltedInitializationHash {\n    pub fn from_field(field: Field) -> Self {\n        Self { inner: field }\n    }\n\n    pub fn compute(salt: Field, initialization_hash: Field, deployer: AztecAddress) -> Self {\n        SaltedInitializationHash::from_field(poseidon2_hash_with_separator(\n            [salt, initialization_hash, deployer.to_field()],\n            GENERATOR_INDEX__PARTIAL_ADDRESS,\n        ))\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n"
     },
-    "247": {
+    "246": {
       "path": "/build-volume/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    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe 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"
     },
-    "248": {
+    "247": {
       "path": "/build-volume/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        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::scoped::Scoped,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    traits::{is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::{arrays::array_concat, field::field_from_bytes};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(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\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    tx_hash: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: BoundedVec<u8, 160> = BoundedVec::new();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..inputs.len() {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes.push(item_bytes[j]);\n        }\n    }\n\n    sha256_to_field(bytes.storage())\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> std::hash::poseidon2::Poseidon2 {\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::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: std::hash::poseidon2::Poseidon2,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> std::hash::poseidon2::Poseidon2 {\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: std::hash::poseidon2::Poseidon2,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> std::hash::poseidon2::Poseidon2 {\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 two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let two_pow_64 = 18446744073709551616;\n    let empty_sponge = std::hash::poseidon2::Poseidon2::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 = std::hash::poseidon2::Poseidon2::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 contructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(contructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == contructed_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 = std::hash::sha256(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
+      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::scoped::Scoped,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    traits::{is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::{arrays::array_concat, field::field_from_bytes};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(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\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    tx_hash: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> std::hash::poseidon2::Poseidon2 {\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::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: std::hash::poseidon2::Poseidon2,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> std::hash::poseidon2::Poseidon2 {\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: std::hash::poseidon2::Poseidon2,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> std::hash::poseidon2::Poseidon2 {\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 two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let two_pow_64 = 18446744073709551616;\n    let empty_sponge = std::hash::poseidon2::Poseidon2::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 = std::hash::poseidon2::Poseidon2::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 contructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(contructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == contructed_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 = std::hash::sha256(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
     },
     "26": {
       "path": "std/hash/poseidon2.nr",
       "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = crate::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n\npub 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"
     },
-    "273": {
+    "272": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/public_keys.nr",
       "source": "use crate::{\n    address::public_keys_hash::PublicKeysHash,\n    constants::{\n        DEFAULT_IVPK_M_X, DEFAULT_IVPK_M_Y, DEFAULT_NPK_M_X, DEFAULT_NPK_M_Y, DEFAULT_OVPK_M_X,\n        DEFAULT_OVPK_M_Y, DEFAULT_TPK_M_X, DEFAULT_TPK_M_Y, GENERATOR_INDEX__PUBLIC_KEYS_HASH,\n    },\n    hash::poseidon2_hash_with_separator,\n    point::POINT_LENGTH,\n    traits::{Deserialize, Hash, Serialize},\n};\n\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse std::default::Default;\n\npub global PUBLIC_KEYS_LENGTH: u32 = 12;\n\npub struct PublicKeys {\n    pub npk_m: NpkM,\n    pub ivpk_m: IvpkM,\n    pub ovpk_m: OvpkM,\n    pub tpk_m: TpkM,\n}\n\npub trait ToPoint {\n    fn to_point(self) -> Point;\n}\n\npub struct NpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for NpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for NpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\n// Note: If we store npk_m_hash directly we can remove this trait implementation. See #8091\nimpl Hash for NpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\npub struct IvpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for IvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for IvpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\npub struct OvpkM {\n    pub inner: Point,\n}\n\nimpl Hash for OvpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\nimpl ToPoint for OvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for OvpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\npub struct TpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for TpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for TpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\nimpl Default for PublicKeys {\n    fn default() -> Self {\n        PublicKeys {\n            npk_m: NpkM {\n                inner: Point { x: DEFAULT_NPK_M_X, y: DEFAULT_NPK_M_Y, is_infinite: false },\n            },\n            ivpk_m: IvpkM {\n                inner: Point { x: DEFAULT_IVPK_M_X, y: DEFAULT_IVPK_M_Y, is_infinite: false },\n            },\n            ovpk_m: OvpkM {\n                inner: Point { x: DEFAULT_OVPK_M_X, y: DEFAULT_OVPK_M_Y, is_infinite: false },\n            },\n            tpk_m: TpkM {\n                inner: Point { x: DEFAULT_TPK_M_X, y: DEFAULT_TPK_M_Y, is_infinite: false },\n            },\n        }\n    }\n}\n\nimpl Eq for PublicKeys {\n    fn eq(self, other: PublicKeys) -> bool {\n        (self.npk_m.inner == other.npk_m.inner)\n            & (self.ivpk_m.inner == other.ivpk_m.inner)\n            & (self.ovpk_m.inner == other.ovpk_m.inner)\n            & (self.tpk_m.inner == other.tpk_m.inner)\n    }\n}\n\nimpl PublicKeys {\n    pub fn hash(self) -> PublicKeysHash {\n        PublicKeysHash::from_field(poseidon2_hash_with_separator(\n            self.serialize(),\n            GENERATOR_INDEX__PUBLIC_KEYS_HASH as Field,\n        ))\n    }\n}\n\nimpl Serialize<PUBLIC_KEYS_LENGTH> for PublicKeys {\n    fn serialize(self) -> [Field; PUBLIC_KEYS_LENGTH] {\n        [\n            self.npk_m.inner.x,\n            self.npk_m.inner.y,\n            self.npk_m.inner.is_infinite as Field,\n            self.ivpk_m.inner.x,\n            self.ivpk_m.inner.y,\n            self.ivpk_m.inner.is_infinite as Field,\n            self.ovpk_m.inner.x,\n            self.ovpk_m.inner.y,\n            self.ovpk_m.inner.is_infinite as Field,\n            self.tpk_m.inner.x,\n            self.tpk_m.inner.y,\n            self.tpk_m.inner.is_infinite as Field,\n        ]\n    }\n}\n\nimpl Deserialize<PUBLIC_KEYS_LENGTH> for PublicKeys {\n    fn deserialize(serialized: [Field; PUBLIC_KEYS_LENGTH]) -> PublicKeys {\n        PublicKeys {\n            npk_m: NpkM {\n                inner: Point {\n                    x: serialized[0],\n                    y: serialized[1],\n                    is_infinite: serialized[2] as bool,\n                },\n            },\n            ivpk_m: IvpkM {\n                inner: Point {\n                    x: serialized[3],\n                    y: serialized[4],\n                    is_infinite: serialized[5] as bool,\n                },\n            },\n            ovpk_m: OvpkM {\n                inner: Point {\n                    x: serialized[6],\n                    y: serialized[7],\n                    is_infinite: serialized[8] as bool,\n                },\n            },\n            tpk_m: TpkM {\n                inner: Point {\n                    x: serialized[9],\n                    y: serialized[10],\n                    is_infinite: serialized[11] as bool,\n                },\n            },\n        }\n    }\n}\n\npub struct AddressPoint {\n    pub inner: Point,\n}\n\nimpl ToPoint for AddressPoint {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\n#[test]\nunconstrained fn compute_public_keys_hash() {\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n        ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n        ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n        tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n    };\n\n    let actual = keys.hash();\n    let expected_public_keys_hash =\n        0x0fecd9a32db731fec1fded1b9ff957a1625c069245a3613a2538bd527068b0ad;\n\n    assert(actual.to_field() == expected_public_keys_hash);\n}\n\n#[test]\nunconstrained fn compute_default_hash() {\n    let keys = PublicKeys::default();\n\n    let actual = keys.hash();\n    let test_data_default_hash = 0x1d3bf1fb93ae0e9cda83b203dd91c3bfb492a9aecf30ec90e1057eced0f0e62d;\n\n    assert(actual.to_field() == test_data_default_hash);\n}\n\n#[test]\nunconstrained fn test_public_keys_serialization() {\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n        ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n        ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n        tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n    };\n\n    let serialized = keys.serialize();\n    let deserialized = PublicKeys::deserialize(serialized);\n\n    assert_eq(keys.npk_m.inner.x, deserialized.npk_m.inner.x);\n    assert_eq(keys.npk_m.inner.y, deserialized.npk_m.inner.y);\n    assert_eq(keys.ivpk_m.inner.x, deserialized.ivpk_m.inner.x);\n    assert_eq(keys.ivpk_m.inner.y, deserialized.ivpk_m.inner.y);\n    assert_eq(keys.ovpk_m.inner.x, deserialized.ovpk_m.inner.x);\n    assert_eq(keys.ovpk_m.inner.y, deserialized.ovpk_m.inner.y);\n    assert_eq(keys.tpk_m.inner.x, deserialized.tpk_m.inner.x);\n    assert_eq(keys.tpk_m.inner.y, deserialized.tpk_m.inner.y);\n}\n"
     },
+    "311": {
+      "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
+      "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() as bool\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
+    },
+    "325": {
+      "path": "/build-volume/noir-projects/noir-contracts/contracts/contract_class_registerer_contract/src/main.nr",
+      "source": "mod events;\nmod capsule;\n\nuse dep::aztec::macros::aztec;\n\n#[aztec]\ncontract ContractClassRegisterer {\n    use dep::aztec::protocol_types::{\n        abis::log_hash::LogHash,\n        constants::{\n            ARTIFACT_FUNCTION_TREE_MAX_HEIGHT, FUNCTION_TREE_HEIGHT,\n            MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,\n            MAX_PACKED_BYTECODE_SIZE_PER_UNCONSTRAINED_FUNCTION_IN_FIELDS,\n            MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS,\n        },\n        contract_class_id::ContractClassId,\n    };\n\n    use dep::aztec::{\n        context::PrivateContext, macros::functions::private,\n        oracle::logs::emit_contract_class_unencrypted_log_private,\n    };\n\n    use crate::events::{\n        class_registered::ContractClassRegistered,\n        private_function_broadcasted::{\n            ClassPrivateFunctionBroadcasted, InnerPrivateFunction, PrivateFunction,\n        },\n        unconstrained_function_broadcasted::{\n            ClassUnconstrainedFunctionBroadcasted, InnerUnconstrainedFunction,\n            UnconstrainedFunction,\n        },\n    };\n\n    // docs:start:import_pop_capsule\n    use crate::capsule::pop_capsule;\n\n    // docs:end:import_pop_capsule\n\n    #[private]\n    fn register(\n        artifact_hash: Field,\n        private_functions_root: Field,\n        public_bytecode_commitment: Field,\n        emit: bool,\n    ) {\n        // TODO: Validate public_bytecode_commitment is the correct commitment of packed_public_bytecode\n        // TODO: We should be able to remove public_bytecode_commitment from the input if it's calculated in this function\n        // docs:start:pop_capsule\n        let packed_public_bytecode: [Field; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS] =\n            pop_capsule();\n        // docs:end:pop_capsule\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        assert(bytecode_length_in_fields < MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);\n\n        let mut computed_public_bytecode_commitment = 0;\n        // We can hash up to MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS - 1, since the first element is the length\n        for i in 0..(MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS - 1) {\n            // While we are forced to run the hash MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS times in the circuit,\n            // we want the bytecode commitment to be based on the actual length\n            if (i < bytecode_length_in_fields) {\n                // We skip the first element when hashing since it is the length\n                computed_public_bytecode_commitment = std::hash::poseidon2::Poseidon2::hash(\n                    [packed_public_bytecode[i + 1], computed_public_bytecode_commitment],\n                    2,\n                );\n            } else {\n                // Any bytes after the bytecode length must be 0\n                assert_eq(packed_public_bytecode[i + 1], 0);\n            }\n        }\n        assert_eq(computed_public_bytecode_commitment, public_bytecode_commitment);\n\n        // Compute contract class id from preimage\n        let contract_class_id = ContractClassId::compute(\n            artifact_hash,\n            private_functions_root,\n            public_bytecode_commitment,\n        );\n\n        // Emit the contract class id as a nullifier to be able to prove that this class has been (not) registered\n        context.push_nullifier(contract_class_id.to_field());\n\n        // Broadcast class info including public bytecode\n        dep::aztec::oracle::debug_log::debug_log_format(\n            \"ContractClassRegistered: {}\",\n            [\n                contract_class_id.to_field(),\n                artifact_hash,\n                private_functions_root,\n                public_bytecode_commitment,\n            ],\n        );\n\n        // TODO(#10007): Drop this conditional and always emit the bytecode. We allow skipping the broadcast\n        // as a stopgap solution to allow txs to fit in Sepolia when we broadcast public bytecode.\n        if emit {\n            let event = ContractClassRegistered {\n                contract_class_id,\n                version: 1,\n                artifact_hash,\n                private_functions_root,\n                packed_public_bytecode,\n            };\n            emit_contract_class_log(&mut context, event.serialize());\n        }\n    }\n\n    #[private]\n    fn broadcast_private_function(\n        contract_class_id: ContractClassId,\n        artifact_metadata_hash: Field,\n        unconstrained_functions_artifact_tree_root: Field,\n        private_function_tree_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n        private_function_tree_leaf_index: Field,\n        artifact_function_tree_sibling_path: [Field; ARTIFACT_FUNCTION_TREE_MAX_HEIGHT],\n        artifact_function_tree_leaf_index: Field,\n        function_data: InnerPrivateFunction,\n    ) {\n        let private_bytecode: [Field; MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS] =\n            pop_capsule();\n\n        let event = ClassPrivateFunctionBroadcasted {\n            contract_class_id,\n            artifact_metadata_hash,\n            unconstrained_functions_artifact_tree_root,\n            private_function_tree_sibling_path,\n            private_function_tree_leaf_index,\n            artifact_function_tree_sibling_path,\n            artifact_function_tree_leaf_index,\n            function: PrivateFunction {\n                selector: function_data.selector,\n                metadata_hash: function_data.metadata_hash,\n                vk_hash: function_data.vk_hash,\n                bytecode: private_bytecode,\n            },\n        };\n        dep::aztec::oracle::debug_log::debug_log_format(\n            \"ClassPrivateFunctionBroadcasted: {}\",\n            [\n                contract_class_id.to_field(),\n                artifact_metadata_hash,\n                unconstrained_functions_artifact_tree_root,\n                function_data.selector.to_field(),\n                function_data.vk_hash,\n                function_data.metadata_hash,\n            ],\n        );\n        emit_contract_class_log(&mut context, event.serialize());\n    }\n\n    #[private]\n    fn broadcast_unconstrained_function(\n        contract_class_id: ContractClassId,\n        artifact_metadata_hash: Field,\n        private_functions_artifact_tree_root: Field,\n        artifact_function_tree_sibling_path: [Field; ARTIFACT_FUNCTION_TREE_MAX_HEIGHT],\n        artifact_function_tree_leaf_index: Field,\n        function_data: InnerUnconstrainedFunction,\n    ) {\n        let unconstrained_bytecode: [Field; MAX_PACKED_BYTECODE_SIZE_PER_UNCONSTRAINED_FUNCTION_IN_FIELDS] =\n            pop_capsule();\n        let event = ClassUnconstrainedFunctionBroadcasted {\n            contract_class_id,\n            artifact_metadata_hash,\n            private_functions_artifact_tree_root,\n            artifact_function_tree_sibling_path,\n            artifact_function_tree_leaf_index,\n            function: UnconstrainedFunction {\n                selector: function_data.selector,\n                metadata_hash: function_data.metadata_hash,\n                bytecode: unconstrained_bytecode,\n            },\n        };\n        dep::aztec::oracle::debug_log::debug_log_format(\n            \"ClassUnconstrainedFunctionBroadcasted: {}\",\n            [\n                contract_class_id.to_field(),\n                artifact_metadata_hash,\n                private_functions_artifact_tree_root,\n                function_data.selector.to_field(),\n                function_data.metadata_hash,\n            ],\n        );\n        emit_contract_class_log(&mut context, event.serialize());\n    }\n\n    #[contract_library_method]\n    fn emit_contract_class_log<let N: u32>(context: &mut PrivateContext, log: [Field; N]) {\n        let contract_address = context.this_address();\n        let counter = context.next_counter();\n\n        // The log preimage is too large for the hash to compile (16,200 fields, 518,400 bytes), so we do this via a\n        // specialized oracle.\n        // A malicious oracle cannot force us to use an incorrect bytecode:\n        // - Contract class -> we will commit to the packed bytecode (currently a TODO)\n        // - Private function -> we provide a membership proof\n        // - Unconstrained function -> we provide a membership proof\n        // However, the sequencer will be required to know a contract's preimage if it is called and the sequencer\n        // cannot prove non-registration. Therefore, it is possible that a malicious oracle might prevent sequencers\n        // from including transactions with calls to certain badly-broadcasted contracts.\n        // TODO(#8978): review correctness\n        let log_hash = emit_contract_class_unencrypted_log_private(contract_address, log, counter);\n\n        // 40 = addr (32) + raw log len (4) + processed log len (4)\n        context.contract_class_logs_hashes.push(\n            LogHash { value: log_hash, counter, length: 40 + (N as Field) * 32 },\n        );\n    }\n\n    #[private]\n    fn assert_class_id_is_registered(contract_class_id: ContractClassId) {\n        context.push_nullifier_read_request(contract_class_id.to_field());\n    }\n}\n"
+    },
     "52": {
       "path": "std/panic.nr",
       "source": "pub fn panic<T, U, let N: u32>(message: fmtstr<N, T>) -> U {\n    assert(false, message);\n    crate::mem::zeroed()\n}\n"
     },
     "62": {
       "path": "/build-volume/noir-projects/noir-contracts/contracts/contract_instance_deployer_contract/src/main.nr",
-      "source": "use dep::aztec::macros::aztec;\n\n#[aztec]\ncontract ContractInstanceDeployer {\n    use dep::aztec::macros::{events::event, functions::private};\n    use dep::aztec::protocol_types::{\n        address::{AztecAddress, PartialAddress},\n        constants::DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE,\n        contract_class_id::ContractClassId,\n        public_keys::PublicKeys,\n        traits::Serialize,\n        utils::arrays::array_concat,\n    };\n    use std::meta::derive;\n\n    #[derive(Serialize)]\n    #[event]\n    struct ContractInstanceDeployed {\n        DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE: Field,\n        address: AztecAddress,\n        version: u8,\n        salt: Field,\n        contract_class_id: ContractClassId,\n        initialization_hash: Field,\n        public_keys: PublicKeys,\n        deployer: AztecAddress,\n    }\n\n    // We need to impl this separately because ts deserializes a point as two fields only.\n    // We had issues that:\n    // Notice how the 'is_infinite' field is deserialized as the next point.\n    // {\n    //     masterNullifierPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000012>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000000034>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // },\n    // masterIncomingViewingPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000000>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000000056>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // },\n    // masterOutgoingViewingPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000078>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000000000>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // },\n    // masterTaggingPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000910>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000001112>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // }\n\n    impl Serialize<15> for ContractInstanceDeployed {\n        fn serialize(self) -> [Field; 15] {\n            [\n                self.DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE,\n                self.address.to_field(),\n                self.version.to_field(),\n                self.salt,\n                self.contract_class_id.to_field(),\n                self.initialization_hash,\n                self.public_keys.npk_m.serialize()[0],\n                self.public_keys.npk_m.serialize()[1],\n                self.public_keys.ivpk_m.serialize()[0],\n                self.public_keys.ivpk_m.serialize()[1],\n                self.public_keys.ovpk_m.serialize()[0],\n                self.public_keys.ovpk_m.serialize()[1],\n                self.public_keys.tpk_m.serialize()[0],\n                self.public_keys.tpk_m.serialize()[1],\n                self.deployer.to_field(),\n            ]\n        }\n    }\n\n    #[private]\n    fn deploy(\n        salt: Field,\n        contract_class_id: ContractClassId,\n        initialization_hash: Field,\n        public_keys: PublicKeys,\n        universal_deploy: bool,\n    ) {\n        // TODO(@spalladino): assert nullifier_exists silo(contract_class_id, ContractClassRegisterer)\n        let deployer = if universal_deploy {\n            AztecAddress::zero()\n        } else {\n            context.msg_sender()\n        };\n\n        let partial_address =\n            PartialAddress::compute(contract_class_id, salt, initialization_hash, deployer);\n\n        let address = AztecAddress::compute(public_keys, partial_address);\n\n        // Emit the address as a nullifier to be able to prove that this instance has been (not) deployed\n        context.push_nullifier(address.to_field());\n\n        // Broadcast the event\n        let event = ContractInstanceDeployed {\n            DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE,\n            contract_class_id,\n            address,\n            public_keys,\n            initialization_hash,\n            salt,\n            deployer,\n            version: 1,\n        };\n\n        let payload = event.serialize();\n        dep::aztec::oracle::debug_log::debug_log_format(\"ContractInstanceDeployed: {}\", payload);\n\n        let padded_log = array_concat(payload, [0; 3]);\n        context.emit_private_log(padded_log);\n    }\n}\n"
+      "source": "use dep::aztec::macros::aztec;\n\n#[aztec]\ncontract ContractInstanceDeployer {\n    use dep::aztec::macros::{events::event, functions::private};\n    use dep::aztec::protocol_types::{\n        address::{AztecAddress, PartialAddress},\n        constants::{DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE, REGISTERER_CONTRACT_ADDRESS},\n        contract_class_id::ContractClassId,\n        public_keys::PublicKeys,\n        traits::Serialize,\n        utils::arrays::array_concat,\n    };\n    use dep::contract_class_registerer::ContractClassRegisterer;\n    use std::meta::derive;\n\n    #[derive(Serialize)]\n    #[event]\n    struct ContractInstanceDeployed {\n        DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE: Field,\n        address: AztecAddress,\n        version: u8,\n        salt: Field,\n        contract_class_id: ContractClassId,\n        initialization_hash: Field,\n        public_keys: PublicKeys,\n        deployer: AztecAddress,\n    }\n\n    // We need to impl this separately because ts deserializes a point as two fields only.\n    // We had issues that:\n    // Notice how the 'is_infinite' field is deserialized as the next point.\n    // {\n    //     masterNullifierPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000012>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000000034>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // },\n    // masterIncomingViewingPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000000>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000000056>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // },\n    // masterOutgoingViewingPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000078>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000000000>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // },\n    // masterTaggingPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000910>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000001112>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // }\n\n    impl Serialize<15> for ContractInstanceDeployed {\n        fn serialize(self) -> [Field; 15] {\n            [\n                self.DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE,\n                self.address.to_field(),\n                self.version.to_field(),\n                self.salt,\n                self.contract_class_id.to_field(),\n                self.initialization_hash,\n                self.public_keys.npk_m.serialize()[0],\n                self.public_keys.npk_m.serialize()[1],\n                self.public_keys.ivpk_m.serialize()[0],\n                self.public_keys.ivpk_m.serialize()[1],\n                self.public_keys.ovpk_m.serialize()[0],\n                self.public_keys.ovpk_m.serialize()[1],\n                self.public_keys.tpk_m.serialize()[0],\n                self.public_keys.tpk_m.serialize()[1],\n                self.deployer.to_field(),\n            ]\n        }\n    }\n\n    #[private]\n    fn deploy(\n        salt: Field,\n        contract_class_id: ContractClassId,\n        initialization_hash: Field,\n        public_keys: PublicKeys,\n        universal_deploy: bool,\n    ) {\n        // contract class must be registered to deploy an instance\n        ContractClassRegisterer::at(REGISTERER_CONTRACT_ADDRESS)\n            .assert_class_id_is_registered(contract_class_id)\n            .call(&mut context);\n\n        let deployer = if universal_deploy {\n            AztecAddress::zero()\n        } else {\n            context.msg_sender()\n        };\n\n        let partial_address =\n            PartialAddress::compute(contract_class_id, salt, initialization_hash, deployer);\n\n        let address = AztecAddress::compute(public_keys, partial_address);\n\n        // Emit the address as a nullifier to be able to prove that this instance has been (not) deployed\n        context.push_nullifier(address.to_field());\n\n        // Broadcast the event\n        let event = ContractInstanceDeployed {\n            DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE,\n            contract_class_id,\n            address,\n            public_keys,\n            initialization_hash,\n            salt,\n            deployer,\n            version: 1,\n        };\n\n        // This is a hack to get around there being two implementations of `Serialize`.\n        // Can be replaced with the below once fixed\n        // let payload = event.serialize();\n        let payload = Serialize::<15>::serialize(event);\n        dep::aztec::oracle::debug_log::debug_log_format(\"ContractInstanceDeployed: {}\", payload);\n\n        let padded_log = array_concat(payload, [0; 3]);\n        context.emit_private_log(padded_log);\n    }\n}\n"
+    },
+    "63": {
+      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr",
+      "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, traits::Deserialize,\n};\n\nuse crate::context::{gas::GasOpts, private_context::PrivateContext, public_context::PublicContext};\n\nuse crate::hash::hash_args;\nuse crate::oracle::arguments::pack_arguments;\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\npub struct PrivateCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateCallInterface<N, T> {\n    pub fn call<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            false,\n        );\n        let unpacked: T = returns.unpack_into();\n        unpacked\n    }\n\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.unpack_into()\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PrivateVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n}\n\nimpl<let N: u32> PrivateVoidCallInterface<N> {\n    pub fn call(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\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        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PrivateStaticCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PrivateStaticCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateStaticCallInterface<N, T> {\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.unpack_into()\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateStaticVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PrivateStaticVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n}\n\nimpl<let N: u32> PrivateStaticVoidCallInterface<N> {\n    pub fn view(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PublicCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub gas_opts: GasOpts,\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PublicCallInterface<N, T> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PublicVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n    pub gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicVoidCallInterface<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 args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicStaticCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PublicStaticCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n    pub gas_opts: GasOpts,\n}\n\nimpl<let N: u32, T> PublicStaticCallInterface<N, T> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicStaticVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PublicStaticVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    return_type: (),\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicStaticVoidCallInterface<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 args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n"
+    },
+    "70": {
+      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/context/packed_returns.nr",
+      "source": "use crate::{hash::hash_args_array, oracle::returns::unpack_returns};\nuse dep::protocol_types::traits::Deserialize;\n\npub struct PackedReturns {\n    packed_returns: Field,\n}\n\nimpl PackedReturns {\n    pub fn new(packed_returns: Field) -> Self {\n        PackedReturns { packed_returns }\n    }\n\n    pub fn assert_empty(self) {\n        assert_eq(self.packed_returns, 0);\n    }\n\n    pub fn raw(self) -> Field {\n        self.packed_returns\n    }\n\n    pub fn unpack<let N: u32>(self) -> [Field; N] {\n        // We verify that the value returned by `unpack_returns` is the preimage of `packed_returns`, fully constraining\n        // it.\n        let unpacked: [Field; N] = unsafe { unpack_returns(self.packed_returns) };\n        assert_eq(self.packed_returns, hash_args_array(unpacked));\n        unpacked\n    }\n\n    pub fn unpack_into<T, let N: u32>(self) -> T\n    where\n        T: Deserialize<N>,\n    {\n        let unpacked: [Field; N] = self.unpack();\n        Deserialize::deserialize(unpacked)\n    }\n}\n"
     },
     "71": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/context/private_context.nr",