npm - @aztec/aztec.js - Versions diffs - 0.1.0-alpha43 → 0.1.0-alpha45 - Mend

@aztec/aztec.js 0.1.0-alpha43 → 0.1.0-alpha45

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (38) hide show

package/.tsbuildinfo +1 -1
package/README.md +7 -7
package/dest/abis/ecdsa_account_contract.json +68 -3
package/dest/abis/schnorr_account_contract.json +68 -3
package/dest/abis/schnorr_single_key_account_contract.json +37 -1
package/dest/account/account.js +2 -2
package/dest/account/contract/ecdsa_account_contract.js +1 -1
package/dest/account/contract/schnorr_account_contract.js +1 -1
package/dest/account/contract/single_key_account_contract.js +1 -1
package/dest/aztec_rpc_client/aztec_rpc_client.d.ts +1 -2
package/dest/aztec_rpc_client/aztec_rpc_client.d.ts.map +1 -1
package/dest/aztec_rpc_client/aztec_rpc_client.js +2 -3
package/dest/aztec_rpc_client/wallet.d.ts +3 -3
package/dest/aztec_rpc_client/wallet.d.ts.map +1 -1
package/dest/aztec_rpc_client/wallet.js +5 -5
package/dest/contract/sent_tx.d.ts +3 -0
package/dest/contract/sent_tx.d.ts.map +1 -1
package/dest/contract/sent_tx.js +4 -1
package/dest/main.js +1 -1
package/dest/sandbox/index.d.ts +61 -0
package/dest/sandbox/index.d.ts.map +1 -1
package/dest/sandbox/index.js +1 -1
package/dest/utils/account.js +2 -2
package/dest/utils/cheat_codes.js +2 -2
package/package.json +4 -4
package/src/abis/ecdsa_account_contract.json +68 -3
package/src/abis/schnorr_account_contract.json +68 -3
package/src/abis/schnorr_single_key_account_contract.json +37 -1
package/src/account/account.ts +1 -1
package/src/account/contract/ecdsa_account_contract.ts +1 -1
package/src/account/contract/schnorr_account_contract.ts +1 -1
package/src/account/contract/single_key_account_contract.ts +1 -1
package/src/aztec_rpc_client/aztec_rpc_client.ts +1 -2
package/src/aztec_rpc_client/wallet.ts +5 -5
package/src/contract/sent_tx.ts +3 -0
package/src/sandbox/index.ts +1 -1
package/src/utils/account.ts +1 -1
package/src/utils/cheat_codes.ts +1 -1

package/dest/abis/ecdsa_account_contract.json CHANGED Viewed

@@ -48,7 +48,7 @@
                     }
                 }
             ],
-            "bytecode": "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",
+            "bytecode": "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",
             "verificationKey": "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"
         },
         {
@@ -153,8 +153,73 @@
                 }
             ],
             "returnTypes": [],
-            "bytecode": "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",
+            "bytecode": "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",
             "verificationKey": "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"
         }
-    ]
+    ],
+    "debug": {
+        "debugSymbols": [
+            "eJyrVsrJT04syczPK1ayqq6tBQAz9wY7",
+            "eJztnMtqIzEQRf9Fay8klZ7+lWEWZiYBQ3DC2DvT/z5xYnVfcNHBjNUM6buz4VJVHFul05s+m5fXX7vT/vVwNNuzyc5sf5zN8W13uHw9nnZ/TmYrEsLGPB1+Xz5mN2zM8/7lyWztsLnJOolSrmEnycuYFjf83Jjsu3eQ7h1C9w6xe4fUvUPu3qF071B7dyi2e4fuZ7p0P9Ol+5ku3c900U9clNg6xJpmO9SaWn0rYYyGok3jkxuHCRnDl1n0k3PHLM75sb4raX6YnNrgxU0QpSrRkFs01DJVTUrU5+ivWZ/rhLs4LWzbD+llmlY+YOiHfJ0wqr6PVgpDX50rhaFv+ZXC0C+klcLQ786VwtDVfaUw/tl5vhMM/YFopTBooACDBjrBcJYKijTooEiDEoo0aKFIgxqKNOihSIMiijRookiDKoo06KJAw9FFkQZdFGnQRZEGXRRp0EWRBl0UadBFkQZdFGnQRZEGXRRoeLoo0qCLIg26KNKgiyINuijSoIsiDboo0qCLIg26KNKgiwINoYsiDboo0qCLIg26KNKgiyINuijSoIsiDboo0qCLIg26KNAIdFGkQRdFGnRRpEEXRRp0UaRBF0UadFGkQRdFGv+tfUXbojHGL2iU9q4C8X6K+jtZxGVto9p6zdZUkMXHLMve9TBLlptZlr1p52dZ9p6bn2XZW2Z+Fn3HZ8ltlhznZ5E0RmH7ZPtZXn9kvaN8CnKNJnj3SCuvb6FHlU/6Q9XDyut742Hl9VXwsPL66U6urV8pNs6W99mOf3hYZO9LdRj+An0zJrY=",
+            "eJztnUGO5DYSRe9S615IIiVSfZXBLBoeD2DAaA+mvTP67lOutpTpEkt/qhh8opTc2YCafPyV/MHIVAT/ePr1t5++/P7Lb1+/PX3+4ym4p8//+OPp23++fP3zf7/9/uW/vz997mMXPj39/PVff/6n898/Pf37l19/fvrcff+0fda5MC4POz+G9WnXf//np6fgi88wFp9hKj5DKD5DLD7DXHqG2BWfoS8+w1B8huJ7Ohbf07H4no7F93Qsvqdj8T0di+/pufienovv6dlgx40urjNMg3s9g8GOEzMY7Dgxg8GOEzMY7Dgxg8GOEzMY7Lj9GfrOYMupKQz2nJrCIJCqKYrv674rvrH7rvjO7rv0xpu9W/7VHN3+FD7My7Oj69ZnfUw87PuV3T8/fXu4+0GT3qTlaKZ+oRmGv9EkRu78Gkm6GDbo6d1/BvQ+7SqnQE+71SnQ0y54CvS0u9aB/hxelpGfHW+DnnbtU6Cno8Ep0NMHyFOg0wHSEB2OpsPkF3Q3DAJ99OshZpzu1jn9QIejqSH6AEdTS3Q4mr4LPUzrZz328R49MXKYloFn8egQxmXcIcy31cU+9XC3AA932839EA+O59cSDz5RXEs8+ExzLfHgU9W1xIPPddcSDz5ZXku8ms+21YtX8+m6dvFczef76sVrGUaGeC3DyBCvZRgZ4rUMI0O8lmFkiNcyjAzxWoaRIV7LMDLEaxnGx8XzLcPIEK9lGBnitQwjQ7yWYWSI1zKMDPFahpEhXsswMsRrGUaGeC3DyBCvZRgfF29sGUaGeC3DyBCvZRgZ4rUMI0O8lmFkiNcyjAzxWoaRIV7LMDLEaxlGhngtw/i4eFPLMDLEaxlGhngtw8gQr2UYGeK1DCNDvJZhZIjXMowM8VqGkSFeyzAyxGsZxsfFCy3DyBCvZRgZ4rUMI0O8lmFkiNcyjAzxWoaRIV7LMDLEaxlGhngtw8gQr2UYHxfvjablTbz/S7yKz3nD4MIK3vX7ivR9XHtmDd7vPxy7pW9inMS4h/xRKj4/Pu4f5SoePXaLeOM4CvHi0pXYDXePDi+CpNu+D75bFjl4F3YFcWubOxduwz/zvwyfTN/thk8an93wyS1sN3wySbIbPplG2A2fPGjbDZ88itoNnzQCq+GHdPN4u+GL7toh3TTebviiu/bZ/ssOX3TXDl3RXTuke9DbDV901w7pxu9mw6ebs9sNX3bXppuc2w1fdtemm4XbDV9216abbtsNX3bXpptX2w1fdtemm0DbDV9216ZbGdsNX3bXptvh2g1fdtemW6raDV9216bbctoNX3bXpls72g1fdtem2wPaDV9216ZbzNkNX3bXptuU2Q1fdtemW13ZDV9216bbJdkNX3bXplvu2A1fdtem27bYDV9216Zbf9gNX3bXpttH2A1fdtemWxDYDV9216bL2O2GL7tr06XQdsOnP/fT2C3DT9N8N/zLv0l/mKd4+42ln/aRuvV3DdfF2+8a4S+o9MfZboJ0xZvlBOmP9HsmGNbflJy7uzkypH4nCpNbfjYLYbr9qOSGHzTpHVCMZp6Wh8Mc5g1NesMcRZPeX0fRpIPoUTTpmFuKJnb94jqxG6YNzRtWdRBNvgla0uQ7piFN+nX/gjTrPXyxC2FDw3qxomG9WNGwXqxoWC+Ovl9iePRuEzXT7yAfRgN7saCBvVjQwF7sw+p+Pm7dD/bifZr0i5GH0cBeLGhgLx7d8nAcx82nOP0W5mE0sBcLGtiLBQ3rxX0X3d0V3+Ow4WHdWPOwfqx5WEeWPDPryc8MsV955qHf8LCurHlYX9Y8rDNrHtabNQ/rzpoH92fBg/uz4MH9WfDg/rzL4954+/Y4HtqfZ9/deObX52b3xvu9x/HQ/qx4aH9WPLQ/Kx7anxUP7c+Kh/ZnxUP7s+B54z3r43gq8+c33uQuxtN3/VJN9vzf45YH9mfJA/uz5IH9WfLA/ix5YH+WPLA/Sx7YnxXPG2/UH8cD+7Pkqcyf33jJvyBPuPE8R7AND+7Pggf3Z8GD+7Pgwf1Z8OD+LHhwf97neaN24jge2p/HYf1+vh/j5vuWN6ozjuOh/Vnx0P6seGh/Vjy0Pyse2p8VD+3Piof256lb8/d+Gv1rnjeqZI7jof1Z8dD+rHhof1Y8tD8rHtqfFQ/tz4qH9ucprP2q+uDGDQ/tz4oH9+d9njfqoY7jwf1Z8OD+LHhwfxY8uD8LHtqfw+hXnujjhof2Z8VD+7Piof1Z8dD+LHgMyvtseWh/Vjy0Pyse2p8VD+3Piqcyf4brAp8ZprWDbD/71+/TOrgyUPPQ/qx4aH8WPHB9oOah/Vnx0P6seGh/Vjy0Pyse2p8VT2X+bFDZtNtuwRkUK4kJ8v/CYgL2T7bfMMLBBUX7bQgcXE6kaNhgKmjgUiJFQ5fa77UhcHAZkaKhS+33adgQqmjg8s7dNgQOLh9SNHTbk30auu3JPg1dar/XhsDDZUOKhi6136eBvVjQwF6824bAd7AXCxq67ck+Dd32ZJ8G9uLdNgQeLhNSNLAX79PAJUKKBi+w321A4OkCIcmDF9gLHvgLJslTV4G9pwuEJE9dBfaeLhCSPHUV2Hu6QEjy1NUAxdMFQpKnrgYoni4QkjyV+TNdICQKkj1dICR56iqw93SBkOKhC4QkT10F9p4uEJI8dTVA8XSBkOSpqwGKpwuEJE9dBfYeLxBSPHUV2Hu8QEjx1FVg7/ECIcVTVwMUjxcIKZ66GqB4vEBI8VTmz3iB0H4BuccLhAQPXiCkeHB/Fjy4PwueuhqgeLxASPHU1QDF4wVC+wXkHi8QUjx1Fdh7vEBI8OAFQoqnrgYoHi8QUjx1NUDxeIHQfgG5xwuEFE9dBfYeLxBSPHiBveCpqwGKxwuEFE9dDVA8XiC0X0Du8QIhxYP7s+DB/Vnw4P4seOpqgOLhC8U0T10NUDx8qZgqSPbwtWKap64Cew9fLaZ5aH9WPHUV2Hv6gjHJU1cDFE9fMCZ56mqA4ukLxiRPXQX2nr5gTPLUVWDv6QvGJE9dBfaevmBM8tTVAMXTF4xJnroaoIz0BWOSpy5/HukLmfp5vH3fO89/y3e2j/tugfd3r96O4w90+qNviE7vEjt0+kYoS3R6730U3YUNOn2MMkSnT1yG6PThzBCdPscZotNHPkP0s0TTBPpZomkC/SzRdIuO399liH7eaIrfCmaIft5oit81Zoh+3miK32BmiH7eaIrfi2aIft5oit+2Zoh+3miK3+FmiH7eaIrfxGaHblCz4ePy1pbzc7xHf5kgfzOJCfI/8mKC/A/mNM7LBMHP4q87xPWz0A9zeP0aymhQJvEuHteH9Wtr189uw5P/6bflyT9l2fLkH51sefLPQ+/jGYb1Z/Jnn+s2PPmHHFMegzIJW558B7XlyTfcd/KE8cYzvy5LGA3KJGx5aH9WPLQ/Kx7an6fh5oeT3/ihQZmELQ/tz4qH9mfBY1Am8U6e6G488+uyzNGgTMKWh/ZnxUP7s+Kh/Tn4tazXhWn7eab9WfHQ/qx4aH9WPLA/+2lez2M+3H05sPDA/qx4DMokbHlgf5Y8sD9LHtifJQ/sz5IH9mfJA/uz5IH9WfJU5s8GZRLv4wnjev7xcdNGZDQok7Dlof1Z8dD+rHhof1Y8tD8rHtqfFQ/tz4qH9mfFQ/uz4qnLnyeDMon38UQXbjyb66YmgzIJWx7anxUP7c+Kh/ZnxUP7s+Kh/Vnx0P6seGh/Vjy0Pwseg6obWx7Yn8dhXuPX6PwmfhnUx9jywP4seWB/ljywP0se2J8lD+zPkgf2Z8kD+/Poprjy+OF1Ge1kUMdhy0P7s+Kh/Vnx0P6seGh/Vjy0Pyse2p8VD+3P3q/XUI1j9/r3wcmg3sCWh/ZnwWNQGWDLQ/uz4qH9WfHQ/qx4aH9WPLQ/j8Ow8kx3Qy88tD8rHtqfFQ/tz4qH9mfBY3DNki0P7c+Kh/ZnxUP7s+Kh/VnxVObPBtcsvY9nul2zPYb+9fv8k8E1S7Y8tD8rHtqfBY9ByZ4tD+3Piof2Z8VD+7Piof1Z8dD+rHgq82e6Pm4M4y3fCdPf6ne2j0/TMvR0V2o4pR7tu+dYs4zc3T/u+sTjc++W753n4f61uv5FFrpM7yyy0G58ElloEz6JLHQsOIksdEg6iSx0pnASWeiE5SSytHNLSha6XPQsstBZ20lkaeeWpCwtQCdloVPXk8jSzi1JWVqATslC1y+fRZZ2bknK0gJ0Upb2xUJSlnZuScrSAnRSlvbFQlKWdm5JyULX0ReUJcS1o0IX+3lflnjrFxZDHzeyXOeLBVNZrhOgTWW5ToA2leU6AdpUlusEaENZAt3B4CyytACdlOU6GbSpLC1AJ2W5zlfcprK0AJ2U5TqpoqUsdAuLs8jSUsWkLC1AJ2W5TKrYu1sHy97f3yf010ovE3PlSi8TRuVKL5O6ypVe5gygVop3PjlupZdJpeVKL3MmkSu9zDFDrvQyqb1c6cOckfCuOMet9GHOSHgnn+NW+jBnJLz70HErfZgzEt4x6biVPswZCe/ydNxKH+aMhHemOm6lD3NGwrtpHbfShzkj4R3Ajlvpw5yR8K5lx630Yc5IBp27fOyWlfo53q/0ZYJ8cxcT5Hvq/gR0s6wh+rVZ+jCH8f7D8MJDXxbch9tlyv39G+Z/8dCXBSse+rJgxQOnIZIHv8x9WC3IDf51c6pAN8uSPPRlwYqHvsxd8dCXuQ9hvPHM/WseuouX5KH9WfHQ/qx48Mvch5sfTn7jh3QDK8lD+7Piof1Z8dD+PEV345nnDQ/tz4qH9mfBE2h/Vjy0Pwc/rTzP7rfhof1Z8dD+rHhof1Y8dV3mHuiOPZKnrsvcQ6jrMvdA98xRPHSzGslDXxaseOjLghUPfVmw4oH9WfJU5s+xrsvcA90pRfLUdZl7oHuDKJ6Z9mfFQ/uz4qH9WfHQ/qx4aH9WPLQ/K57K/JlulCEuBw90hwrJU9dl7pFuVSF5aH9WPLQ/Kx7anxUP7c+Kh/ZnxUP7s+Kpy59jV9dl7hFvmCB48E4Fiod+YUzx0K91KR765SvFA/uz5KFf9lY8dV3mHvECfMVD+7Piof1Z8OAl54qH9mfFQ/uz4qH9WfHQ/rx/mXvEC5YVD+3Piof2Z8VD+7Piof1Z8ODlroqH9mfFU9dl7hEv8FQ8tD8rnrouc494SaPiof1Z8dD+rHhofxY8eKmd4qH9WfFU5s94cdn+5eDR0/6seOq6zD36ui5zjwYle7Y8tD8rHtqfBQ9dPyh5aH9WPLQ/K57K/JmujzvHXUWRLtM7iyyXaaZhKgtdJHgWWS7TvMJWlst0urCVhc4UTiLLZbpv2crSzi1JWVqATspymdZYprLQxbNnkaUF6KQsl+lbZStLO7ckZWkBOilL+2IhKUs7t6RkoaunzyJL+2IhKUs7tyRlaQE6KUv7YiEpSzu3JGW5ToA2vGMx0uX8J5GFruI/iyzXCdCmslwnQJvKcp0AbSrLdTJoU1lagE7IMtP9E84iSwvQSVmu8xW3qSwtQCdluU6qaCpLC9BJWVqqmJIFb6BxElkukyqKS4JmvCPHcSu9TBiVK71M6ipXepkzgFzpZcK6XOllUmm50sucSdRK8T4wx630Mqm9XOnDnJHwrjjHrfRhzkh4J5/jVvowZyS8+9BxK32YMxLeMemwleK9mI5b6cOckfD+Ucet9GHOSHjPq+NW+jBnJLxP13ErfZgzEt5b7LiVPswZCe+HdtxK8Xg6uLuVDvsr9d3y65kfbqKM4w90PEDaoeMRzw4dD2F26HhM+iC6Cxt0PMjYoeNRwwwdb7tmiI7nvnboeDJrh36WaJpAP0s0TaCfJZom0M8STRPo542mfIM7O/TzRlO+f54d+nmjKd+Hzg79vNGUb3Nnh37eaMq3i7NDP2805bvR2aGfN5qGk4ak79//B2fftks="
+        ],
+        "fileMap": {
+            "0": {
+                "source": "mod storage;\nmod ecdsa_public_key_note;\n\n// Account contract that uses ECDSA signatures for authentication on the same curve as Ethereum.\n// The signing key is stored in an immutable private note and should be different from the signing key.\ncontract EcdsaAccount {\n    use dep::std;\n    use dep::aztec::entrypoint;\n    use dep::aztec::entrypoint::EntrypointPayload;\n    use dep::aztec::abi;\n    use dep::aztec::abi::PrivateContextInputs;\n    use dep::aztec::abi::CallContext;\n    use dep::aztec::context::PrivateContext;\n    use dep::aztec::log::emit_encrypted_log;\n    use dep::aztec::oracle::get_public_key::get_public_key;\n    use dep::aztec::types::vec::BoundedVec;\n    use dep::aztec::types::point::Point;\n    use dep::aztec::constants_gen::GENERATOR_INDEX__SIGNATURE_PAYLOAD;\n\n    use dep::aztec::constants_gen::MAX_NOTE_FIELDS_LENGTH;\n    use dep::aztec::note::{\n        note_header::{NoteHeader},\n        utils as note_utils,\n    };\n\n    use crate::storage::Storage;\n    use crate::ecdsa_public_key_note::EcdsaPublicKeyNote;\n    use crate::ecdsa_public_key_note::EcdsaPublicKeyNoteInterface;\n    use crate::ecdsa_public_key_note::ECDSA_PUBLIC_KEY_NOTE_LEN;\n\n    // All calls made by this account will be routed through this entrypoint\n    fn entrypoint(  \n        inputs: pub PrivateContextInputs,\n        payload: pub EntrypointPayload, // contains a set of arguments, selectors, targets and a nonce\n        signature: pub [u8;64],\n    ) -> distinct pub abi::PrivateCircuitPublicInputs {\n        \n        // Initialise context\n        // ENTRYPOINT_PAYLOAD_SIZE(13) + 64\n        let mut args: BoundedVec<Field, 77> = BoundedVec::new(0);\n        args.push_array(payload.serialize());\n        for byte in signature { args.push(byte as Field); }\n        let mut context = PrivateContext::new(inputs, abi::hash_args(args.storage));\n\n        // Load public key from storage\n        let storage = Storage::init();\n        let public_key = storage.public_key.get_note(&mut context);\n\n        // Verify payload signature using Ethereum's signing scheme\n        // Note that noir expects the hash of the message/challenge as input to the ECDSA verification.\n        let payload_fields: [Field; entrypoint::ENTRYPOINT_PAYLOAD_SIZE] = payload.serialize();\n        let message_field: Field = std::hash::pedersen_with_separator(payload_fields, GENERATOR_INDEX__SIGNATURE_PAYLOAD)[0];\n        let message_bytes = message_field.to_be_bytes(32);\n        let hashed_message: [u8; 32] = std::hash::sha256(message_bytes);\n        let verification = std::ecdsa_secp256k1::verify_signature(public_key.x, public_key.y, signature, hashed_message);\n        assert(verification == true);\n\n        payload.execute_calls(&mut context);\n\n        context.finish()\n    }\n\n    // Creates a new account out of an ECDSA public key to use for signature verification\n    fn constructor(\n        inputs: pub PrivateContextInputs,\n        signing_pub_key_x: pub [u8;32],\n        signing_pub_key_y: pub [u8;32],\n    ) -> distinct pub abi::PrivateCircuitPublicInputs {\n        let storage = Storage::init();\n        \n        let mut args: BoundedVec<Field, 64> = BoundedVec::new(0);\n        for byte in signing_pub_key_x { args.push(byte as Field); }\n        for byte in signing_pub_key_y { args.push(byte as Field); }\n        let mut context = PrivateContext::new(inputs, abi::hash_args(args.storage));\n        \n        let this = context.this_address();\n        let mut pub_key_note = EcdsaPublicKeyNote::new(signing_pub_key_x, signing_pub_key_y, this);\n        storage.public_key.initialise(&mut context, &mut pub_key_note);\n        \n        emit_encrypted_log(\n            &mut context,\n            this,\n            storage.public_key.storage_slot,\n            get_public_key(this),\n            pub_key_note.serialise(),\n        );\n\n        context.finish()\n    }\n\n    // Computes note hash and nullifier.\n    // Note 1: Needs to be defined by every contract producing logs.\n    // Note 2: Having it in all the contracts gives us the ability to compute the note hash and nullifier differently for different kind of notes.\n    unconstrained fn compute_note_hash_and_nullifier(contract_address: Field, nonce: Field, storage_slot: Field, preimage: [Field; ECDSA_PUBLIC_KEY_NOTE_LEN]) -> [Field; 4] {\n        assert(storage_slot == 1);\n        let note_header = NoteHeader { contract_address, nonce, storage_slot };\n        note_utils::compute_note_hash_and_nullifier(EcdsaPublicKeyNoteInterface, note_header, preimage)\n    }\n}\n",
+                "path": "/mnt/user-data/alvaro/aztec-packages/yarn-project/noir-contracts/src/contracts/ecdsa_account_contract/src/main"
+            },
+            "3": {
+                "source": "mod poseidon;\n\n#[foreign(sha256)]\nfn sha256<N>(_input : [u8; N]) -> [u8; 32] {}\n\n#[foreign(blake2s)]\nfn blake2s<N>(_input : [u8; N]) -> [u8; 32] {}\n\nfn pedersen<N>(input : [Field; N]) -> [Field; 2] {\n    pedersen_with_separator(input, 0)\n}\n\n#[foreign(pedersen)]\nfn pedersen_with_separator<N>(_input : [Field; N], _separator : u32) -> [Field; 2] {}\n\n#[foreign(hash_to_field_128_security)]\nfn hash_to_field<N>(_input : [Field; N]) -> Field {}\n\n#[foreign(keccak256)]\nfn keccak256<N>(_input : [u8; N], _message_size: u32) -> [u8; 32] {}\n\n// mimc-p/p implementation\n// constants are (publicly generated) random numbers, for instance using keccak as a ROM.\n// You must use constants generated for the native field\n// Rounds number should be ~ log(p)/log(exp)\n// For 254 bit primes, exponent 7 and 91 rounds seems to be recommended\nfn mimc<N>(x: Field, k: Field, constants: [Field; N], exp : Field) -> Field {\n    //round 0\n    let mut t = x + k;\n    let mut h = t.pow_32(exp);\n    //next rounds\n    for i in 1 .. constants.len() {\n        t = h + k + constants[i];\n        h = t.pow_32(exp);\n    };\n    h + k\n}\n\nglobal MIMC_BN254_ROUNDS = 91;\n\n//mimc implementation with hardcoded parameters for BN254 curve.\nfn mimc_bn254<N>(array: [Field; N]) -> Field {\n    //mimc parameters\n    let exponent = 7;\n    //generated from seed \"mimc\" using keccak256 \n    let constants: [Field; MIMC_BN254_ROUNDS] = [\n        0, \n        20888961410941983456478427210666206549300505294776164667214940546594746570981,\n        15265126113435022738560151911929040668591755459209400716467504685752745317193,\n        8334177627492981984476504167502758309043212251641796197711684499645635709656,\n        1374324219480165500871639364801692115397519265181803854177629327624133579404,\n        11442588683664344394633565859260176446561886575962616332903193988751292992472,\n        2558901189096558760448896669327086721003508630712968559048179091037845349145,\n        11189978595292752354820141775598510151189959177917284797737745690127318076389,\n        3262966573163560839685415914157855077211340576201936620532175028036746741754,\n        17029914891543225301403832095880481731551830725367286980611178737703889171730,\n        4614037031668406927330683909387957156531244689520944789503628527855167665518,\n        19647356996769918391113967168615123299113119185942498194367262335168397100658,\n        5040699236106090655289931820723926657076483236860546282406111821875672148900,\n        2632385916954580941368956176626336146806721642583847728103570779270161510514,\n        17691411851977575435597871505860208507285462834710151833948561098560743654671,\n        11482807709115676646560379017491661435505951727793345550942389701970904563183,\n        8360838254132998143349158726141014535383109403565779450210746881879715734773,\n        12663821244032248511491386323242575231591777785787269938928497649288048289525,\n        3067001377342968891237590775929219083706800062321980129409398033259904188058,\n        8536471869378957766675292398190944925664113548202769136103887479787957959589,\n        19825444354178182240559170937204690272111734703605805530888940813160705385792,\n        16703465144013840124940690347975638755097486902749048533167980887413919317592,\n        13061236261277650370863439564453267964462486225679643020432589226741411380501,\n        10864774797625152707517901967943775867717907803542223029967000416969007792571,\n        10035653564014594269791753415727486340557376923045841607746250017541686319774,\n        3446968588058668564420958894889124905706353937375068998436129414772610003289,\n        4653317306466493184743870159523234588955994456998076243468148492375236846006,\n        8486711143589723036499933521576871883500223198263343024003617825616410932026,\n        250710584458582618659378487568129931785810765264752039738223488321597070280,\n        2104159799604932521291371026105311735948154964200596636974609406977292675173,\n        16313562605837709339799839901240652934758303521543693857533755376563489378839,\n        6032365105133504724925793806318578936233045029919447519826248813478479197288,\n        14025118133847866722315446277964222215118620050302054655768867040006542798474,\n        7400123822125662712777833064081316757896757785777291653271747396958201309118,\n        1744432620323851751204287974553233986555641872755053103823939564833813704825,\n        8316378125659383262515151597439205374263247719876250938893842106722210729522,\n        6739722627047123650704294650168547689199576889424317598327664349670094847386,\n        21211457866117465531949733809706514799713333930924902519246949506964470524162,\n        13718112532745211817410303291774369209520657938741992779396229864894885156527,\n        5264534817993325015357427094323255342713527811596856940387954546330728068658,\n        18884137497114307927425084003812022333609937761793387700010402412840002189451,\n        5148596049900083984813839872929010525572543381981952060869301611018636120248,\n        19799686398774806587970184652860783461860993790013219899147141137827718662674,\n        19240878651604412704364448729659032944342952609050243268894572835672205984837,\n        10546185249390392695582524554167530669949955276893453512788278945742408153192,\n        5507959600969845538113649209272736011390582494851145043668969080335346810411,\n        18177751737739153338153217698774510185696788019377850245260475034576050820091,\n        19603444733183990109492724100282114612026332366576932662794133334264283907557,\n        10548274686824425401349248282213580046351514091431715597441736281987273193140,\n        1823201861560942974198127384034483127920205835821334101215923769688644479957,\n        11867589662193422187545516240823411225342068709600734253659804646934346124945,\n        18718569356736340558616379408444812528964066420519677106145092918482774343613,\n        10530777752259630125564678480897857853807637120039176813174150229243735996839,\n        20486583726592018813337145844457018474256372770211860618687961310422228379031,\n        12690713110714036569415168795200156516217175005650145422920562694422306200486,\n        17386427286863519095301372413760745749282643730629659997153085139065756667205,\n        2216432659854733047132347621569505613620980842043977268828076165669557467682,\n        6309765381643925252238633914530877025934201680691496500372265330505506717193,\n        20806323192073945401862788605803131761175139076694468214027227878952047793390,\n        4037040458505567977365391535756875199663510397600316887746139396052445718861,\n        19948974083684238245321361840704327952464170097132407924861169241740046562673,\n        845322671528508199439318170916419179535949348988022948153107378280175750024,\n        16222384601744433420585982239113457177459602187868460608565289920306145389382,\n        10232118865851112229330353999139005145127746617219324244541194256766741433339,\n        6699067738555349409504843460654299019000594109597429103342076743347235369120,\n        6220784880752427143725783746407285094967584864656399181815603544365010379208,\n        6129250029437675212264306655559561251995722990149771051304736001195288083309,\n        10773245783118750721454994239248013870822765715268323522295722350908043393604,\n        4490242021765793917495398271905043433053432245571325177153467194570741607167,\n        19596995117319480189066041930051006586888908165330319666010398892494684778526,\n        837850695495734270707668553360118467905109360511302468085569220634750561083,\n        11803922811376367215191737026157445294481406304781326649717082177394185903907,\n        10201298324909697255105265958780781450978049256931478989759448189112393506592,\n        13564695482314888817576351063608519127702411536552857463682060761575100923924,\n        9262808208636973454201420823766139682381973240743541030659775288508921362724,\n        173271062536305557219323722062711383294158572562695717740068656098441040230,\n        18120430890549410286417591505529104700901943324772175772035648111937818237369,\n        20484495168135072493552514219686101965206843697794133766912991150184337935627,\n        19155651295705203459475805213866664350848604323501251939850063308319753686505,\n        11971299749478202793661982361798418342615500543489781306376058267926437157297,\n        18285310723116790056148596536349375622245669010373674803854111592441823052978,\n        7069216248902547653615508023941692395371990416048967468982099270925308100727,\n        6465151453746412132599596984628739550147379072443683076388208843341824127379,\n        16143532858389170960690347742477978826830511669766530042104134302796355145785,\n        19362583304414853660976404410208489566967618125972377176980367224623492419647,\n        1702213613534733786921602839210290505213503664731919006932367875629005980493,\n        10781825404476535814285389902565833897646945212027592373510689209734812292327,\n        4212716923652881254737947578600828255798948993302968210248673545442808456151,\n        7594017890037021425366623750593200398174488805473151513558919864633711506220,\n        18979889247746272055963929241596362599320706910852082477600815822482192194401,\n        13602139229813231349386885113156901793661719180900395818909719758150455500533,\n    ];\n\n    let mut r = 0;\n    for elem in array {\n        let h = mimc(elem, r, constants, exponent);\n        r = r + elem + h;\n    }\n    r\n}\n",
+                "path": "std/hash"
+            },
+            "18": {
+                "source": "\nimpl Field {\n    #[builtin(to_le_bits)]\n    fn to_le_bits(_x : Field, _bit_size: u32) -> [u1] {}\n    #[builtin(to_be_bits)]\n    fn to_be_bits(_x : Field, _bit_size: u32) -> [u1] {}\n\n    fn to_le_bytes(x : Field, byte_size: u32) -> [u8] {\n        x.to_le_radix(256, byte_size)\n    }\n    fn to_be_bytes(x : Field, byte_size: u32) -> [u8] {\n        x.to_be_radix(256, byte_size)\n    }\n\n    #[builtin(to_le_radix)]\n    //decompose _x into a _result_len vector over the _radix basis\n    //_radix must be less than 256\n    fn to_le_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8] {}\n    #[builtin(to_be_radix)]\n    fn to_be_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8] {}\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    fn pow_32(self, exponent: Field) -> Field {\n        let mut r: Field = 1;\n        let b = exponent.to_le_bits(32);\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 ∈ {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n    fn sgn0(self) -> u1 {\n        self as u1\n    }\n}\n\n#[builtin(modulus_num_bits)]\nfn modulus_num_bits() -> Field {}\n\n#[builtin(modulus_be_bits)]\nfn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\nfn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\nfn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\nfn modulus_le_bytes() -> [u8] {}\n",
+                "path": "std/field"
+            },
+            "31": {
+                "source": "use crate::constants_gen::{\n    RETURN_VALUES_LENGTH,\n    MAX_READ_REQUESTS_PER_CALL,\n    MAX_NEW_COMMITMENTS_PER_CALL,\n    MAX_NEW_NULLIFIERS_PER_CALL,\n    MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,\n    MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n    MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n    NUM_FIELDS_PER_SHA256,\n    MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,\n    MAX_PUBLIC_DATA_READS_PER_CALL,\n    GENERATOR_INDEX__FUNCTION_ARGS,\n    HISTORIC_BLOCK_DATA_LENGTH,\n    CONTRACT_DEPLOYMENT_DATA_LENGTH,\n    CALL_CONTEXT_LENGTH,\n    PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH,\n    PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH,\n    CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH,\n    CONTRACT_STORAGE_READ_LENGTH,\n    PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH,\n    PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH,\n    GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS,\n    GENERATOR_INDEX__FUNCTION_DATA,\n    GENERATOR_INDEX__PUBLIC_DATA_READ,\n    GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST,\n    GENERATOR_INDEX__CALL_CONTEXT,\n    GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS,\n    GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA,\n};\n\nuse crate::oracle::debug_log;\nuse crate::types::vec::BoundedVec;\nuse crate::types::point::Point;\n\nstruct PrivateGlobalVariables {\n    chain_id: Field,\n    version: Field,\n}\n\nimpl PrivateGlobalVariables {\n    fn serialize(self) -> [Field; 2] {\n        [self.chain_id, self.version]\n    }\n}\n\nstruct PublicGlobalVariables {\n    chain_id: Field,\n    version: Field,\n    block_number: Field,\n    timestamp: Field,\n}\n\nimpl PublicGlobalVariables {\n    fn serialize(self) -> [Field; 4] {\n        [self.chain_id, self.version, self.block_number, self.timestamp]\n    }\n}\n\nstruct ContractDeploymentData {\n    deployer_public_key: Point,\n    constructor_vk_hash : Field,\n    function_tree_root : Field,\n    contract_address_salt : Field,\n    portal_contract_address : Field,\n}\n\nimpl ContractDeploymentData {\n    fn serialize(self) -> [Field; CONTRACT_DEPLOYMENT_DATA_LENGTH] {\n        [\n            self.deployer_public_key.x,\n            self.deployer_public_key.y,\n            self.constructor_vk_hash,\n            self.function_tree_root,\n            self.contract_address_salt,\n            self.portal_contract_address,\n        ]\n    }\n\n    fn hash(self) -> Field {\n        dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA)[0]\n    }\n}\n\n// PrivateContextInputs are expected to be provided to each private function\nstruct PrivateContextInputs {\n    call_context : CallContext,\n    block_data: HistoricBlockData,\n\n    contract_deployment_data: ContractDeploymentData,\n\n    private_global_variables: PrivateGlobalVariables,\n}\n\n// PublicContextInputs are expected to be provided to each public function\nstruct PublicContextInputs {\n    call_context: CallContext,\n    block_data: HistoricBlockData,\n\n    public_global_variables: PublicGlobalVariables,\n}\n\nstruct CallContext {\n    msg_sender : Field,\n    storage_contract_address : Field,\n    portal_contract_address : Field,\n\n    is_delegate_call : bool,\n    is_static_call : bool,\n    is_contract_deployment: bool,\n}\n\nimpl CallContext {\n    fn serialize(self) -> [Field; CALL_CONTEXT_LENGTH] {\n        [\n            self.msg_sender,\n            self.storage_contract_address,\n            self.portal_contract_address,\n            self.is_delegate_call as Field,\n            self.is_static_call as Field,\n            self.is_contract_deployment as Field,\n        ]\n    }\n\n    fn hash(self) -> Field {\n        dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__CALL_CONTEXT)[0]\n    }\n}\n\nstruct HistoricBlockData {\n    private_data_tree_root : Field,\n    nullifier_tree_root : Field,\n    contract_tree_root : Field,\n    l1_to_l2_messages_tree_root : Field,\n    blocks_tree_root: Field,\n    public_data_tree_root: Field,\n    global_variables_hash: Field,\n}\n\nimpl HistoricBlockData {\n    // NOTE: this order must match the order in `private_circuit_public_inputs.hpp`\n    fn serialize(self) -> [Field; HISTORIC_BLOCK_DATA_LENGTH] {\n        [\n            self.private_data_tree_root,\n            self.nullifier_tree_root,\n            self.contract_tree_root,\n            self.l1_to_l2_messages_tree_root,\n            self.blocks_tree_root,\n            self.public_data_tree_root,\n            self.global_variables_hash,\n        ]\n    }\n\n    fn empty() -> Self {\n        Self { private_data_tree_root: 0, nullifier_tree_root: 0, contract_tree_root: 0, l1_to_l2_messages_tree_root: 0, blocks_tree_root: 0, public_data_tree_root: 0, global_variables_hash: 0 }\n    }\n}\n\nstruct FunctionData {\n    function_selector: Field,\n    is_internal: bool,\n    is_private: bool,\n    is_constructor: bool,\n}\n\nimpl FunctionData {\n    fn hash(self) -> Field {\n        dep::std::hash::pedersen_with_separator([\n            self.function_selector,\n            self.is_internal as Field,\n            self.is_private as Field,\n            self.is_constructor as Field,\n        ], GENERATOR_INDEX__FUNCTION_DATA)[0]\n    }\n}\n\nstruct PrivateCircuitPublicInputs {\n    call_context: CallContext,\n    args_hash: Field,\n    return_values: [Field; RETURN_VALUES_LENGTH],\n    read_requests: [Field; crate::abi::MAX_READ_REQUESTS_PER_CALL],\n    new_commitments: [Field; MAX_NEW_COMMITMENTS_PER_CALL],\n    new_nullifiers: [Field; MAX_NEW_NULLIFIERS_PER_CALL],\n    nullified_commitments: [Field; MAX_NEW_NULLIFIERS_PER_CALL],\n    private_call_stack: [Field; MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL],\n    public_call_stack: [Field; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n    new_l2_to_l1_msgs: [Field; MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n    // Explore introducing a new type like uint256 (similar to Point), so it's more explicit that\n    // we're talking about a single number backed by two field elements.\n    encrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n    unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n    encrypted_log_preimages_length: Field,\n    unencrypted_log_preimages_length: Field,\n    block_data: HistoricBlockData,\n    contract_deployment_data: ContractDeploymentData,\n    chain_id: Field,\n    version: Field,\n}\n\nimpl PrivateCircuitPublicInputs {\n    fn hash(self) -> Field {\n        let mut fields: BoundedVec<Field, PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH> = BoundedVec::new(0); \n        fields.push(self.call_context.hash());\n        fields.push(self.args_hash);\n        fields.push_array(self.return_values);\n        fields.push_array(self.read_requests);\n        fields.push_array(self.new_commitments);\n        fields.push_array(self.new_nullifiers);\n        fields.push_array(self.nullified_commitments);\n        fields.push_array(self.private_call_stack);\n        fields.push_array(self.public_call_stack);\n        fields.push_array(self.new_l2_to_l1_msgs);\n        fields.push_array(self.encrypted_logs_hash);\n        fields.push_array(self.unencrypted_logs_hash);\n        fields.push(self.encrypted_log_preimages_length);\n        fields.push(self.unencrypted_log_preimages_length);\n        fields.push_array(self.block_data.serialize());\n        fields.push(self.contract_deployment_data.hash());\n        fields.push(self.chain_id);\n        fields.push(self.version);\n\n        dep::std::hash::pedersen_with_separator(fields.storage, GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS)[0]\n    }\n\n    fn serialize(self) -> [Field; PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH] {\n        let mut fields: BoundedVec<Field, PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH> = BoundedVec::new(0); \n        fields.push_array(self.call_context.serialize());\n        fields.push(self.args_hash);\n        fields.push_array(self.return_values);\n        fields.push_array(self.read_requests);\n        fields.push_array(self.new_commitments);\n        fields.push_array(self.new_nullifiers);\n        fields.push_array(self.private_call_stack);\n        fields.push_array(self.public_call_stack);\n        fields.push_array(self.new_l2_to_l1_msgs);\n        fields.push_array(self.encrypted_logs_hash);\n        fields.push_array(self.unencrypted_logs_hash);\n        fields.push(self.encrypted_log_preimages_length);\n        fields.push(self.unencrypted_log_preimages_length);\n        fields.push_array(self.block_data.serialize());\n        fields.push_array(self.contract_deployment_data.serialize());\n        fields.push(self.chain_id);\n        fields.push(self.version);\n        fields.storage\n    }\n}\n\nstruct ContractStorageRead {\n    storage_slot: Field,\n    value: Field,\n}\n\nimpl ContractStorageRead {\n    fn serialize(self) -> [Field; CONTRACT_STORAGE_READ_LENGTH] {\n        [self.storage_slot, self.value]\n    }\n\n    fn hash(self) -> Field {\n        dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_READ)[0]\n    }\n\n    fn empty() -> Self {\n        Self { storage_slot: 0, value: 0 }\n    }\n}\n\nstruct ContractStorageUpdateRequest {\n    storage_slot: Field,\n    old_value: Field,\n    new_value: Field,\n}\n\nimpl ContractStorageUpdateRequest {\n    fn serialize(self) -> [Field; CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH] {\n        [self.storage_slot, self.old_value, self.new_value]\n    }\n\n    fn hash(self) -> Field {\n        dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST)[0]\n    }\n\n    fn empty() -> Self {\n        Self { storage_slot: 0, old_value: 0, new_value: 0 }\n    }\n}\n\n\nstruct PublicCircuitPublicInputs {\n    call_context: CallContext,\n    args_hash: Field,\n    return_values: [Field; RETURN_VALUES_LENGTH],\n    contract_storage_update_requests: [ContractStorageUpdateRequest; MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL],\n    contract_storage_read: [ContractStorageRead; MAX_PUBLIC_DATA_READS_PER_CALL],\n    public_call_stack: [Field; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n    new_commitments: [Field; MAX_NEW_COMMITMENTS_PER_CALL],\n    new_nullifiers: [Field; crate::abi::MAX_NEW_NULLIFIERS_PER_CALL],\n    new_l2_to_l1_msgs: [Field; crate::abi::MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n    unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n    unencrypted_log_preimages_length: Field,\n    block_data: HistoricBlockData,\n    prover_address: Field,\n\n    // TODO: include globals in here and check them elsewhere\n    // https://github.com/AztecProtocol/aztec-packages/issues/1567\n}\n\nimpl PublicCircuitPublicInputs {\n    \n    fn hash(self) -> Field {\n        let mut inputs: BoundedVec<Field, PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH> = BoundedVec::new(0);\n        inputs.push(self.call_context.hash());\n        inputs.push(self.args_hash);\n        inputs.push_array(self.return_values);\n        for i in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL {\n            inputs.push(self.contract_storage_update_requests[i].hash());\n        }\n        for i in 0..MAX_PUBLIC_DATA_READS_PER_CALL {\n            inputs.push(self.contract_storage_read[i].hash());\n        }\n        inputs.push_array(self.public_call_stack);\n        inputs.push_array(self.new_commitments);\n        inputs.push_array(self.new_nullifiers);\n        inputs.push_array(self.new_l2_to_l1_msgs);\n\n        // We do not include block_data since it's not in the cpp hash\n\n        inputs.push_array(self.unencrypted_logs_hash);\n        inputs.push(self.unencrypted_log_preimages_length);\n        inputs.push_array(self.block_data.serialize()); // see https://github.com/AztecProtocol/aztec-packages/issues/1473\n        inputs.push(self.prover_address);\n\n        dep::std::hash::pedersen_with_separator(inputs.storage, GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS)[0]\n    }\n\n    fn serialize(self) -> [Field; PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH] {\n        let mut fields: BoundedVec<Field, PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH> = BoundedVec::new(0); \n        fields.push_array(self.call_context.serialize());   \n        fields.push(self.args_hash);\n        fields.push_array(self.return_values);\n        for i in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL {\n            fields.push_array(self.contract_storage_update_requests[i].serialize());\n        }\n        for i in 0..MAX_PUBLIC_DATA_READS_PER_CALL {\n            fields.push_array(self.contract_storage_read[i].serialize());\n        }\n        fields.push_array(self.public_call_stack);\n        fields.push_array(self.new_commitments);\n        fields.push_array(self.new_nullifiers);\n        fields.push_array(self.new_l2_to_l1_msgs);\n        fields.push_array(self.unencrypted_logs_hash);\n        fields.push(self.unencrypted_log_preimages_length);\n        fields.push_array(self.block_data.serialize());\n        fields.push(self.prover_address);\n        fields.storage\n    }\n}\n\nglobal ARGS_HASH_CHUNK_LENGTH: u32 = 32;\nglobal ARGS_HASH_CHUNK_COUNT: u32 = 16;\n\nfn hash_args<N>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        let mut chunks_hashes = [0; ARGS_HASH_CHUNK_COUNT];\n        for i in 0..ARGS_HASH_CHUNK_COUNT {\n            let mut chunk_hash = 0;\n            let start_chunk_index = i * ARGS_HASH_CHUNK_LENGTH;\n            if start_chunk_index < (args.len() as u32) {\n                let mut chunk_args = [0; ARGS_HASH_CHUNK_LENGTH];\n                for j in 0..ARGS_HASH_CHUNK_LENGTH {\n                    let item_index = i * ARGS_HASH_CHUNK_LENGTH + j;\n                    if item_index < (args.len() as u32) {\n                        chunk_args[j] = args[item_index];\n                    }\n                }\n                chunk_hash = dep::std::hash::pedersen_with_separator(chunk_args, GENERATOR_INDEX__FUNCTION_ARGS)[0];\n            }\n            chunks_hashes[i] = chunk_hash;\n        }\n        dep::std::hash::pedersen_with_separator(chunks_hashes, GENERATOR_INDEX__FUNCTION_ARGS)[0]\n    }\n}\n",
+                "path": "/mnt/user-data/alvaro/aztec-packages/yarn-project/noir-libs/noir-aztec/src/abi"
+            },
+            "32": {
+                "source": "use crate::constants_gen::{\n    EMPTY_NULLIFIED_COMMITMENT,\n    MAX_NEW_COMMITMENTS_PER_CALL,\n    MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n    MAX_NEW_NULLIFIERS_PER_CALL,\n    MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,\n    MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n    MAX_PUBLIC_DATA_READS_PER_CALL,\n    MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,\n    MAX_READ_REQUESTS_PER_CALL,\n    NUM_FIELDS_PER_SHA256,\n    RETURN_VALUES_LENGTH,\n};\n\nuse crate::abi;\n\nuse crate::abi::{\n    hash_args,\n    CallContext,\n    ContractDeploymentData,\n    HistoricBlockData,\n    FunctionData,\n    PrivateCircuitPublicInputs,\n    PublicCircuitPublicInputs,\n};\n\n// TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n// use dep::std::collections::vec::Vec;\n\n// l1 to l2 messaging\nuse crate::messaging::process_l1_to_l2_message;\nuse crate::private_call_stack_item::PrivateCallStackItem;\nuse crate::public_call_stack_item::PublicCallStackItem;\n\nuse crate::types::{\n    vec::BoundedVec,\n    point::Point,\n};\n\nuse crate::utils::arr_copy_slice;\n\nuse crate::oracle::{\n    arguments,\n    call_private_function::call_private_function_internal,\n    public_call::call_public_function_internal,\n    enqueue_public_function_call::enqueue_public_function_call_internal,\n    context::get_portal_address,\n};\n\n\n// When finished, one can call .finish() to convert back to the abi\nstruct PrivateContext {\n    inputs: abi::PrivateContextInputs,\n\n    args_hash : Field,\n    return_values : BoundedVec<Field, RETURN_VALUES_LENGTH>,\n\n    read_requests: BoundedVec<Field, MAX_READ_REQUESTS_PER_CALL>,\n\n    new_commitments: BoundedVec<Field, MAX_NEW_COMMITMENTS_PER_CALL>,\n    new_nullifiers: BoundedVec<Field, MAX_NEW_NULLIFIERS_PER_CALL>,\n    nullified_commitments: BoundedVec<Field, MAX_NEW_NULLIFIERS_PER_CALL>,\n\n    private_call_stack : BoundedVec<Field, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    public_call_stack : BoundedVec<Field, MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL>,\n    new_l2_to_l1_msgs : BoundedVec<Field, MAX_NEW_L2_TO_L1_MSGS_PER_CALL>,\n\n    block_data: HistoricBlockData,\n\n    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n    // encrypted_logs_preimages: Vec<Field>,\n    // unencrypted_logs_preimages: Vec<Field>,\n}\n\nimpl PrivateContext {\n    fn new(inputs: abi::PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs: inputs,\n\n            args_hash: args_hash,\n            return_values: BoundedVec::new(0),\n\n            read_requests: BoundedVec::new(0),\n\n            new_commitments: BoundedVec::new(0),\n            new_nullifiers: BoundedVec::new(0),\n            nullified_commitments: BoundedVec::new(0),\n\n            block_data: inputs.block_data,\n\n            private_call_stack: BoundedVec::new(0),\n            public_call_stack: BoundedVec::new(0),\n            new_l2_to_l1_msgs: BoundedVec::new(0),\n\n            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n            // encrypted_logs_preimages: Vec::new(),\n            // unencrypted_logs_preimages: Vec::new(),\n        }\n    }\n\n    fn msg_sender(self) -> Field {\n        self.inputs.call_context.msg_sender\n    }\n\n    fn this_address(self) -> Field {\n        self.inputs.call_context.storage_contract_address\n    }\n\n    fn this_portal_address(self) -> Field {\n        self.inputs.call_context.portal_contract_address\n    }\n\n    fn chain_id(self) -> Field {\n        self.inputs.private_global_variables.chain_id\n    }\n\n    fn version(self) -> Field {\n        self.inputs.private_global_variables.version\n    }\n\n    fn finish(self) -> abi::PrivateCircuitPublicInputs {\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n        let encrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n        let unencrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n        let encrypted_log_preimages_length = 0;\n        let unencrypted_log_preimages_length = 0;\n\n        let priv_circuit_pub_inputs = abi::PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            return_values: self.return_values.storage,\n            read_requests: self.read_requests.storage,\n            new_commitments: self.new_commitments.storage,\n            new_nullifiers: self.new_nullifiers.storage,\n            nullified_commitments: self.nullified_commitments.storage,\n            private_call_stack: self.private_call_stack.storage,\n            public_call_stack: self.public_call_stack.storage,\n            new_l2_to_l1_msgs: self.new_l2_to_l1_msgs.storage,\n            encrypted_logs_hash: encrypted_logs_hash,\n            unencrypted_logs_hash: unencrypted_logs_hash,\n            encrypted_log_preimages_length: encrypted_log_preimages_length,\n            unencrypted_log_preimages_length: unencrypted_log_preimages_length,\n            block_data: self.block_data,\n            contract_deployment_data: self.inputs.contract_deployment_data,\n            chain_id: self.inputs.private_global_variables.chain_id,\n            version: self.inputs.private_global_variables.version,\n        };\n        priv_circuit_pub_inputs\n    }\n\n    fn push_read_request(&mut self, read_request: Field) {\n        self.read_requests.push(read_request);\n    }\n\n    fn push_new_note_hash(&mut self, note_hash: Field) {\n        self.new_commitments.push(note_hash);\n    }\n\n    fn push_new_nullifier(&mut self, nullifier: Field, nullified_commitment: Field) {\n        self.new_nullifiers.push(nullifier);\n        self.nullified_commitments.push(nullified_commitment);\n    }\n\n    fn message_portal(&mut self, content: Field) {\n        self.new_l2_to_l1_msgs.push(content);\n    }\n\n    // PrivateContextInputs must be temporarily passed in to prevent too many unknowns\n    // Note this returns self to get around an issue where mutable structs do not maintain mutations unless reassigned\n    fn consume_l1_to_l2_message(&mut self, inputs: abi::PrivateContextInputs, msg_key: Field, content: Field, secret: Field) {\n        let nullifier = process_l1_to_l2_message(inputs.block_data.l1_to_l2_messages_tree_root, inputs.call_context.storage_contract_address, msg_key, content, secret);\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_new_nullifier(nullifier, EMPTY_NULLIFIED_COMMITMENT)\n    }\n\n    fn accumulate_encrypted_logs<N>(&mut self, log: [Field; N]) {\n        let _void1 = self.inputs;\n        let _void2 = log;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n    }\n\n    fn accumulate_unencrypted_logs<T>(&mut self, log: T) {\n        let _void1 = self.inputs;\n        let _void2 = log;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n    }\n\n    fn call_private_function<ARGS_COUNT>(\n        &mut self,\n        contract_address: Field, \n        function_selector: Field, \n        args: [Field; ARGS_COUNT]\n    ) -> [Field; RETURN_VALUES_LENGTH] {\n        let args_hash = hash_args(args);\n        assert(args_hash == arguments::pack_arguments(args));\n        self.call_private_function_with_packed_args(contract_address, function_selector, args_hash)\n    }\n\n    fn call_private_function_no_args(\n        &mut self,\n        contract_address: Field, \n        function_selector: Field, \n    ) -> [Field; RETURN_VALUES_LENGTH] {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0)\n    }\n\n    fn call_private_function_with_packed_args(\n        &mut self,\n        contract_address: Field,\n        function_selector: Field,\n        args_hash: Field\n    ) -> [Field; RETURN_VALUES_LENGTH] {\n        let fields = call_private_function_internal(\n            contract_address, \n            function_selector, \n            args_hash\n        );\n        let item = PrivateCallStackItem {\n            contract_address: fields[0],\n            function_data: FunctionData {\n                function_selector: fields[1],\n                is_internal: fields[2] as bool,\n                is_private: fields[3] as bool,\n                is_constructor: fields[4] as bool,\n            },\n            public_inputs: PrivateCircuitPublicInputs {\n                call_context: CallContext {\n                    msg_sender : fields[5],\n                    storage_contract_address : fields[6],\n                    portal_contract_address : fields[7],\n                    \n                    is_delegate_call : fields[8] as bool,\n                    is_static_call : fields[9] as bool,\n                    is_contract_deployment: fields[10] as bool,\n                },\n                // TODO handle the offsets as a variable incremented during extraction?\n                args_hash: fields[11],\n                return_values: arr_copy_slice(fields, [0; RETURN_VALUES_LENGTH], 12),\n                read_requests: arr_copy_slice(fields, [0; MAX_READ_REQUESTS_PER_CALL], 16),\n                new_commitments: arr_copy_slice(fields, [0; MAX_NEW_COMMITMENTS_PER_CALL], 20),\n                new_nullifiers: arr_copy_slice(fields, [0; MAX_NEW_NULLIFIERS_PER_CALL], 24),\n                nullified_commitments: arr_copy_slice(fields, [0; MAX_NEW_NULLIFIERS_PER_CALL], 28),\n                private_call_stack: arr_copy_slice(fields, [0; MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL], 32),\n                public_call_stack: arr_copy_slice(fields, [0; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL], 36),\n                new_l2_to_l1_msgs: arr_copy_slice(fields, [0; MAX_NEW_L2_TO_L1_MSGS_PER_CALL], 40),\n                encrypted_logs_hash: arr_copy_slice(fields, [0; NUM_FIELDS_PER_SHA256], 42),\n                unencrypted_logs_hash: arr_copy_slice(fields, [0; NUM_FIELDS_PER_SHA256], 44),\n                encrypted_log_preimages_length: fields[46],\n                unencrypted_log_preimages_length: fields[47],\n                block_data: HistoricBlockData {\n                    // Must match order in `private_circuit_public_inputs.hpp`\n                    private_data_tree_root : fields[48],\n                    nullifier_tree_root : fields[49],\n                    contract_tree_root : fields[50],\n                    l1_to_l2_messages_tree_root : fields[51],\n                    blocks_tree_root : fields[52],\n                    public_data_tree_root: fields[53],\n                    global_variables_hash: fields[54],\n                },\n                contract_deployment_data: ContractDeploymentData {\n                    deployer_public_key: Point::new(fields[55], fields[56]),\n                    constructor_vk_hash : fields[57],\n                    function_tree_root : fields[58],\n                    contract_address_salt : fields[59],\n                    portal_contract_address : fields[60],\n                },\n                chain_id: fields[61],\n                version: fields[62],\n            },\n            is_execution_request: fields[63] as bool,\n        };\n        assert(contract_address == item.contract_address);\n        assert(function_selector == item.function_data.function_selector);\n\n        assert(args_hash == item.public_inputs.args_hash);\n\n        assert(item.is_execution_request == false);\n\n        // Assert that the call context of the enqueued call generated by the oracle matches our request.\n        // We are issuing a regular call which is not delegate, static, or deployment. We also constrain\n        // the msg_sender in the nested call to be equal to our address, and the execution context address\n        // for the nested call to be equal to the address we actually called.\n        assert(item.public_inputs.call_context.is_delegate_call == false);\n        assert(item.public_inputs.call_context.is_static_call == false);\n        assert(item.public_inputs.call_context.is_contract_deployment == false);\n        assert(item.public_inputs.call_context.msg_sender == self.inputs.call_context.storage_contract_address);\n        assert(item.public_inputs.call_context.storage_contract_address == contract_address);\n\n        self.private_call_stack.push(item.hash());\n\n        item.public_inputs.return_values\n    }\n\n    fn call_public_function<ARGS_COUNT>(\n        &mut self,\n        contract_address: Field, \n        function_selector: Field, \n        args: [Field; ARGS_COUNT]\n    ) {\n        let args_hash = hash_args(args);\n        assert(args_hash == arguments::pack_arguments(args));\n        self.call_public_function_with_packed_args(contract_address, function_selector, args_hash)\n    }\n\n    fn call_public_function_no_args(\n        &mut self,\n        contract_address: Field, \n        function_selector: Field,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0)\n    }\n\n    fn call_public_function_with_packed_args(\n        &mut self,\n        contract_address: Field,\n        function_selector: Field,\n        args_hash: Field\n    ) {\n        let fields = enqueue_public_function_call_internal(\n            contract_address, \n            function_selector, \n            args_hash\n        );\n        let item = PublicCallStackItem {\n            contract_address: fields[0],\n            function_data: FunctionData {\n                function_selector: fields[1],\n                is_internal: fields[2] as bool,\n                is_private: fields[3] as bool,\n                is_constructor: fields[4] as bool,\n            },\n            public_inputs: PublicCircuitPublicInputs {\n                call_context: CallContext {\n                    msg_sender : fields[5],\n                    storage_contract_address : fields[6],\n                    portal_contract_address : fields[7],\n                    \n                    is_delegate_call : fields[8] as bool,\n                    is_static_call : fields[9] as bool,\n                    is_contract_deployment: fields[10] as bool,\n                },\n                args_hash: fields[11],\n                return_values: [0; RETURN_VALUES_LENGTH],\n                contract_storage_update_requests: [ContractStorageUpdateRequest::empty(); MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL],\n                contract_storage_read: [ContractStorageRead::empty(); MAX_PUBLIC_DATA_READS_PER_CALL],\n                public_call_stack: [0; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n                new_commitments: [0; MAX_NEW_COMMITMENTS_PER_CALL],\n                new_nullifiers: [0; MAX_NEW_NULLIFIERS_PER_CALL],\n                new_l2_to_l1_msgs:[0; MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n                unencrypted_logs_hash:[0; NUM_FIELDS_PER_SHA256],\n                unencrypted_log_preimages_length: 0,\n                block_data: HistoricBlockData::empty(),\n                prover_address: 0,\n            },\n            is_execution_request: true,\n        };\n\n        assert(contract_address == item.contract_address);\n        assert(function_selector == item.function_data.function_selector);\n        \n        assert(args_hash == item.public_inputs.args_hash);\n\n        // Assert that the call context of the enqueued call generated by the oracle matches our request.\n        // We are issuing a regular call which is not delegate, static, or deployment. We also constrain\n        // the msg_sender in the nested call to be equal to our address, and the execution context address\n        // for the nested call to be equal to the address we actually called.\n        assert(item.public_inputs.call_context.is_delegate_call == false);\n        assert(item.public_inputs.call_context.is_static_call == false);\n        assert(item.public_inputs.call_context.is_contract_deployment == false);\n        assert(item.public_inputs.call_context.msg_sender == self.inputs.call_context.storage_contract_address);\n        assert(item.public_inputs.call_context.storage_contract_address == contract_address);\n\n        self.public_call_stack.push(item.hash());\n    }\n}\n\nuse crate::abi::{\n    ContractStorageRead,\n    ContractStorageUpdateRequest\n};\n\nstruct PublicContext {\n    inputs: abi::PublicContextInputs,\n\n    args_hash : Field,\n    return_values : BoundedVec<Field, RETURN_VALUES_LENGTH>,\n\n    contract_storage_update_requests: BoundedVec<ContractStorageUpdateRequest, MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL>,\n    contract_storage_read: BoundedVec<ContractStorageRead, MAX_PUBLIC_DATA_READS_PER_CALL>,\n    public_call_stack: BoundedVec<Field, MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL>,\n\n    new_commitments: BoundedVec<Field, MAX_NEW_COMMITMENTS_PER_CALL>,\n    new_nullifiers: BoundedVec<Field, crate::abi::MAX_NEW_NULLIFIERS_PER_CALL>,\n\n    new_l2_to_l1_msgs: BoundedVec<Field, crate::abi::MAX_NEW_L2_TO_L1_MSGS_PER_CALL>,\n\n    unencrypted_logs_hash: BoundedVec<Field, NUM_FIELDS_PER_SHA256>,\n    unencrypted_logs_preimages_length: Field,\n\n    block_data: HistoricBlockData,\n    prover_address: Field,\n}\n\nimpl PublicContext {\n    fn new(inputs: abi::PublicContextInputs, args_hash: Field) -> PublicContext {\n        let empty_storage_read = ContractStorageRead::empty();\n        let empty_storage_update = ContractStorageUpdateRequest::empty();\n        PublicContext {\n            inputs: inputs,\n\n            args_hash: args_hash,\n            return_values: BoundedVec::new(0),\n\n            contract_storage_update_requests: BoundedVec::new(empty_storage_update),\n            contract_storage_read: BoundedVec::new(empty_storage_read),\n            public_call_stack: BoundedVec::new(0),\n\n            new_commitments: BoundedVec::new(0),\n            new_nullifiers: BoundedVec::new(0),\n\n            new_l2_to_l1_msgs: BoundedVec::new(0),\n\n            \n            unencrypted_logs_hash: BoundedVec::new(0),\n            unencrypted_logs_preimages_length: 0,\n\n            block_data: inputs.block_data,\n            prover_address: 0,\n\n            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n            // encrypted_logs_preimages: Vec::new(),\n            // unencrypted_logs_preimages: Vec::new(),\n        }\n    }\n\n    fn msg_sender(self) -> Field {\n        self.inputs.call_context.msg_sender\n    }\n\n    fn this_address(self) -> Field {\n        self.inputs.call_context.storage_contract_address\n    }\n\n    fn this_portal_address(self) -> Field {\n        self.inputs.call_context.portal_contract_address\n    }\n\n    fn chain_id(self) -> Field {\n        self.inputs.public_global_variables.chain_id\n    }\n\n    fn version(self) -> Field {\n        self.inputs.public_global_variables.version\n    }\n\n    fn block_number(self) -> Field {\n        self.inputs.public_global_variables.block_number\n    }\n\n    fn timestamp(self) -> Field {\n        self.inputs.public_global_variables.timestamp\n    }\n\n    fn finish(self) -> abi::PublicCircuitPublicInputs {\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n        let unencrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n        let unencrypted_log_preimages_length = 0;\n\n\n        // Compute the public call stack hashes\n        let pub_circuit_pub_inputs = abi::PublicCircuitPublicInputs {\n            call_context: self.inputs.call_context, // Done\n            args_hash: self.args_hash, // Done\n            contract_storage_update_requests: self.contract_storage_update_requests.storage,\n            contract_storage_read: self.contract_storage_read.storage,\n            return_values: self.return_values.storage,\n            new_commitments: self.new_commitments.storage,\n            new_nullifiers: self.new_nullifiers.storage,\n            public_call_stack: self.public_call_stack.storage,\n            new_l2_to_l1_msgs: self.new_l2_to_l1_msgs.storage,\n            unencrypted_logs_hash: unencrypted_logs_hash,\n            unencrypted_log_preimages_length: unencrypted_log_preimages_length,\n            block_data: self.inputs.block_data,\n            prover_address: self.prover_address,\n        };\n        pub_circuit_pub_inputs\n    }\n\n    fn push_new_note_hash(&mut self, note_hash: Field) {\n        self.new_commitments.push(note_hash);\n    }\n\n    fn push_new_nullifier(&mut self, nullifier: Field, _nullified_commitment: Field) {\n        self.new_nullifiers.push(nullifier);\n    }\n\n    fn message_portal(&mut self, content: Field) {\n        self.new_l2_to_l1_msgs.push(content);\n    }\n\n    // PrivateContextInputs must be temporarily passed in to prevent too many unknowns\n    // Note this returns self to get around an issue where mutable structs do not maintain mutations unless reassigned\n    fn consume_l1_to_l2_message(&mut self, msg_key: Field, content: Field, secret: Field) {\n        let this = (*self).this_address();\n        let nullifier = process_l1_to_l2_message(self.block_data.l1_to_l2_messages_tree_root, this, msg_key, content, secret);\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_new_nullifier(nullifier, EMPTY_NULLIFIED_COMMITMENT)\n    }\n\n    fn accumulate_encrypted_logs<N>(&mut self, log: [Field; N]) {\n        let _void1 = self;\n        let _void2 = log;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n    }\n\n    fn accumulate_unencrypted_logs<T>(&mut self, log: T) {\n        let _void1 = self;\n        let _void2 = log;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n    }\n\n    fn call_public_function<ARGS_COUNT>(\n        _self: Self,\n        contract_address: Field, \n        function_selector: Field,\n        args: [Field; ARGS_COUNT],\n    ) -> [Field; RETURN_VALUES_LENGTH] {\n        let args_hash = abi::hash_args(args);\n        assert(args_hash == arguments::pack_arguments(args));\n        call_public_function_internal(\n            contract_address, \n            function_selector, \n            args_hash,\n        )\n    }\n\n    fn call_public_function_no_args(\n        _self: Self,\n        contract_address: Field, \n        function_selector: Field,\n    ) -> [Field; RETURN_VALUES_LENGTH] {\n        call_public_function_internal(\n            contract_address, \n            function_selector, \n            0,\n        )\n    }\n\n}",
+                "path": "/mnt/user-data/alvaro/aztec-packages/yarn-project/noir-libs/noir-aztec/src/context"
+            },
+            "33": {
+                "source": "use crate::context::PrivateContext;\nuse crate::oracle;\nuse crate::types::point::Point;\n\nfn emit_encrypted_log<N>(\n    context: &mut PrivateContext,\n    contract_address: Field,\n    storage_slot: Field,\n    encryption_pub_key: Point,\n    log: [Field; N],\n) {\n    let _ = oracle::logs::emit_encrypted_log(contract_address, storage_slot, encryption_pub_key, log);\n    context.accumulate_encrypted_logs(log);\n}\n\nfn emit_unencrypted_log<T>(\n    context: &mut PrivateContext,\n    log: T,\n) {\n    let _ = oracle::logs::emit_unencrypted_log(log);\n    context.accumulate_unencrypted_logs(log);\n}\n",
+                "path": "/mnt/user-data/alvaro/aztec-packages/yarn-project/noir-libs/noir-aztec/src/log"
+            },
+            "39": {
+                "source": "use dep::std::option::Option;\nuse crate::abi::PublicContextInputs;\nuse crate::context::{\n    PrivateContext,\n    PublicContext,\n};\nuse crate::note::{\n    note_header::NoteHeader,\n    note_interface::NoteInterface,\n    utils::compute_inner_note_hash,\n};\nuse crate::oracle::notes::{notify_created_note, notify_nullified_note};\nuse crate::constants_gen::EMPTY_NULLIFIED_COMMITMENT;\n\nfn create_note<Note, N>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n    note: &mut Note,\n    note_interface: NoteInterface<Note, N>,\n) {\n    let contract_address = (*context).this_address();\n\n    let header = NoteHeader { contract_address, storage_slot, nonce: 0 };\n    let set_header = note_interface.set_header;\n    set_header(note, header);\n    let inner_note_hash = compute_inner_note_hash(note_interface, *note);\n\n    let serialise = note_interface.serialise;\n    let preimage = serialise(*note);\n    assert(notify_created_note(storage_slot, preimage, inner_note_hash) == 0);\n\n    context.push_new_note_hash(inner_note_hash);\n}\n\nfn create_note_hash_from_public<Note, N>(\n    context: &mut PublicContext,\n    storage_slot: Field,\n    note: &mut Note,\n    note_interface: NoteInterface<Note, N>,\n) {\n    let contract_address = (*context).this_address();\n\n    let header = NoteHeader { contract_address, storage_slot, nonce: 0 };\n    let set_header = note_interface.set_header;\n    set_header(note, header);\n    let inner_note_hash = compute_inner_note_hash(note_interface, *note);\n\n    context.push_new_note_hash(inner_note_hash);\n}\n\nfn destroy_note<Note, N>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n    note: Note,\n    note_interface: NoteInterface<Note, N>,\n) {\n    let mut nullifier = 0;\n    let mut nullified_commitment: Field = EMPTY_NULLIFIED_COMMITMENT;\n    let compute_nullifier = note_interface.compute_nullifier;\n    nullifier = compute_nullifier(note);\n\n    let serialise = note_interface.serialise;\n    let preimage = serialise(note);\n\n    // We also need the note commitment corresponding to the \"nullifier\"\n    let get_header = note_interface.get_header;\n    let header = get_header(note);\n    // 0 nonce implies \"transient\" nullifier (must nullify a commitment in this TX).\n    // `nullified_commitment` is used to inform the kernel which pending commitment\n    // the nullifier corresponds to so they can be matched and both squashed/deleted.\n    // nonzero nonce implies \"persistable\" nullifier (nullifies a persistent/in-tree\n    // commitment) in which case `nullified_commitment` is not used since the kernel\n    // just siloes and forwards the nullier to its output.\n    if (header.nonce == 0) {\n        // TODO(suyash): Can we reuse the note commitment computed in `compute_nullifier`?\n        nullified_commitment = compute_inner_note_hash(note_interface, note);\n    }\n    assert(notify_nullified_note(storage_slot, nullifier, preimage, nullified_commitment) == 0);\n\n    context.push_new_nullifier(nullifier, nullified_commitment)\n}",
+                "path": "/mnt/user-data/alvaro/aztec-packages/yarn-project/noir-libs/noir-aztec/src/note/lifecycle"
+            },
+            "40": {
+                "source": "use dep::std::option::Option;\nuse crate::constants_gen::{\n    MAX_READ_REQUESTS_PER_CALL,\n    GET_NOTE_ORACLE_RETURN_LENGTH,\n    GET_NOTES_ORACLE_RETURN_LENGTH,\n    MAX_NOTES_PER_PAGE,\n    VIEW_NOTE_ORACLE_RETURN_LENGTH,\n};\nuse crate::context::PrivateContext;\nuse crate::note::{\n    note_getter_options::{NoteGetterOptions, Select, Sort},\n    note_interface::NoteInterface,\n    note_header::NoteHeader,\n    note_viewer_options::NoteViewerOptions,\n    utils::compute_note_hash_for_read_or_nullify,\n    utils::compute_unique_siloed_note_hash,\n    utils::compute_inner_note_hash,\n    utils::compute_siloed_note_hash,\n};\nuse crate::messaging::get_commitment_getter_data::make_commitment_getter_data;\nuse crate::oracle;\nuse crate::types::vec::BoundedVec;\n\nfn check_note_header<Note, N>(\n    context: PrivateContext,\n    storage_slot: Field,\n    note_interface: NoteInterface<Note, N>,\n    note: Note,\n) {\n    let get_header = note_interface.get_header;\n    let header = get_header(note);\n    let contract_address = context.this_address();\n    assert(header.contract_address == contract_address);\n    assert(header.storage_slot == storage_slot);\n}\n\nfn ensure_note_exists<Note, N>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n    note_interface: NoteInterface<Note, N>,\n    note: &mut Note,\n) {\n    let saved_note = get_note_internal(storage_slot, note_interface);\n\n    // Only copy over the header to the original note to make sure the preimage is the same.\n    let get_header = note_interface.get_header;\n    let set_header = note_interface.set_header;\n    let note_header = get_header(saved_note);\n    set_header(note, note_header);\n\n    check_note_header(*context, storage_slot, note_interface, *note);\n\n    let note_hash_for_read_request = compute_note_hash_for_read_or_nullify(note_interface, *note);\n    context.push_read_request(note_hash_for_read_request);\n}\n\n// Ensure a note's hash exists in the tree without retrieving the entire\n// notes via the oracle.\n// Modifies the note by populating it with header info.\nfn ensure_note_hash_exists<Note, N>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n    note_interface: NoteInterface<Note, N>,\n    note: &mut Note,\n) {\n    // Initialize header of note. Must be done before computing note hashes as it initializes the:\n    // - storage slot (used in inner note hash)\n    // - the contract address (used in siloed note hash)\n    // - and the nonce (used in the unique siloed note hash)\n    let set_header = note_interface.set_header;\n    let note_header = NoteHeader {\n        contract_address: (*context).this_address(),\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386): should be\n        // real nonce (once public kernel applies nonces).\n        nonce: 0,\n        storage_slot\n    };\n    set_header(note, note_header);\n\n    // Get a note from oracle and early out if it doesn't exist.\n    let inner_note_hash = compute_inner_note_hash(note_interface, *note);\n\n    let raw_oracle_ret = oracle::get_commitment::get_commitment(inner_note_hash);\n    let deserialized_oracle_ret = make_commitment_getter_data(raw_oracle_ret, 0);\n    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386): should be\n    // unique_siloed_note_hash once public kernel applies nonces\n    let saved_siloed_note_hash = deserialized_oracle_ret.message;\n\n    assert(saved_siloed_note_hash != 0); // TODO(dbanks12): necessary?\n\n    check_note_header(*context, storage_slot, note_interface, *note);\n\n    // Ensure that the note hash retrieved from oracle matches the one computed from note.\n    let computed_siloed_note_hash = compute_siloed_note_hash(note_interface, *note);\n    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386): should be\n    // compute_note_hash_for_read_or_nullify once public kernel applies nonces\n    assert(computed_siloed_note_hash == saved_siloed_note_hash);\n\n    context.push_read_request(computed_siloed_note_hash);\n}\n\nfn get_note<Note, N>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n    note_interface: NoteInterface<Note, N>,\n) -> Note {\n    let note = get_note_internal(storage_slot, note_interface);\n\n    check_note_header(*context, storage_slot, note_interface, note);\n\n    let note_hash_for_read_request = compute_note_hash_for_read_or_nullify(note_interface, note);\n\n    context.push_read_request(note_hash_for_read_request);\n    note\n}\n\nfn get_notes<Note, N, FILTER_ARGS>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n    note_interface: NoteInterface<Note, N>,\n    options: NoteGetterOptions<Note, N, FILTER_ARGS>,\n) -> [Option<Note>; MAX_READ_REQUESTS_PER_CALL] {\n    let opt_notes = get_notes_internal(storage_slot, note_interface, options);\n    for i in 0..opt_notes.len() {\n        let opt_note = opt_notes[i];\n        let mut note_hash_for_read_request = 0;\n        if opt_note.is_some() {\n            let note = opt_note.unwrap_unchecked();\n            check_note_header(*context, storage_slot, note_interface, note);\n            note_hash_for_read_request = compute_note_hash_for_read_or_nullify(note_interface, note);\n        };\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1410): test to ensure\n        // failure if malicious oracle injects 0 nonce here for a \"pre-existing\" note.\n        context.push_read_request(note_hash_for_read_request);\n    };\n\n    // TODO(#1660)\n    // Move it back to get_notes_internal and only make read request for selected notes.\n    let filter = options.filter;\n    let filter_args = options.filter_args;\n    filter(opt_notes, filter_args)\n}\n\nunconstrained fn get_note_internal<Note, N>(\n    storage_slot: Field,\n    note_interface: NoteInterface<Note, N>,\n) -> Note {\n    let placeholder_note = [Option::none()];\n    let placeholder_fields = [0; GET_NOTE_ORACLE_RETURN_LENGTH];\n    oracle::notes::get_notes(\n        storage_slot,\n        note_interface,\n        0,\n        [],\n        [],\n        [],\n        [],\n        1, // limit\n        0, // offset\n        placeholder_note,\n        placeholder_fields,\n    )[0].unwrap() // Notice: we don't allow dummies to be returned from get_note (singular).\n}\n\nunconstrained fn get_notes_internal<Note, N, FILTER_ARGS>(\n    storage_slot: Field,\n    note_interface: NoteInterface<Note, N>,\n    options: NoteGetterOptions<Note, N, FILTER_ARGS>,\n) -> [Option<Note>; MAX_READ_REQUESTS_PER_CALL] {\n    let (num_selects, select_by, select_values, sort_by, sort_order) = flatten_options(options.selects, options.sorts);\n    let placeholder_opt_notes = [Option::none(); MAX_READ_REQUESTS_PER_CALL];\n    let placeholder_fields = [0; GET_NOTES_ORACLE_RETURN_LENGTH];\n    oracle::notes::get_notes(\n        storage_slot,\n        note_interface,\n        num_selects,\n        select_by,\n        select_values,\n        sort_by,\n        sort_order,\n        options.limit,\n        options.offset,\n        placeholder_opt_notes,\n        placeholder_fields,\n    )\n}\n\nunconstrained fn view_notes<Note, N>(\n    storage_slot: Field,\n    note_interface: NoteInterface<Note, N>,\n    options: NoteViewerOptions<Note, N>,\n) -> [Option<Note>; MAX_NOTES_PER_PAGE] {\n    let (num_selects, select_by, select_values, sort_by, sort_order) = flatten_options(options.selects, options.sorts);\n    let placeholder_opt_notes = [Option::none(); MAX_NOTES_PER_PAGE];\n    let placeholder_fields = [0; VIEW_NOTE_ORACLE_RETURN_LENGTH];\n    oracle::notes::get_notes(\n        storage_slot,\n        note_interface,\n        num_selects,\n        select_by,\n        select_values,\n        sort_by,\n        sort_order,\n        options.limit,\n        options.offset,\n        placeholder_opt_notes,\n        placeholder_fields,\n    )\n}\n\nunconstrained fn flatten_options<Note, N>(\n    selects: BoundedVec<Option<Select>, N>,\n    sorts: BoundedVec<Option<Sort>, N>,\n) -> (u8, [u8; N], [Field; N], [u8; N], [u2; N]) {\n    let mut num_selects = 0;\n    let mut select_by = [0; N];\n    let mut select_values = [0; N];\n    for i in 0..selects.len {\n        let select = selects.get(i);\n        if select.is_some() {\n            select_by[num_selects] = select.unwrap_unchecked().field_index;\n            select_values[num_selects] = select.unwrap_unchecked().value;\n            num_selects += 1;\n        };\n    };\n\n    let mut sort_by = [0; N];\n    let mut sort_order = [0; N];\n    for i in 0..sorts.len {\n        let sort = sorts.get(i);\n        if sort.is_some() {\n            sort_by[i] = sort.unwrap_unchecked().field_index;\n            sort_order[i] = sort.unwrap_unchecked().order;\n        };\n    };\n\n    (num_selects, select_by, select_values, sort_by, sort_order)\n}",
+                "path": "/mnt/user-data/alvaro/aztec-packages/yarn-project/noir-libs/noir-aztec/src/note/note_getter"
+            },
+            "42": {
+                "source": "use dep::std::hash::{pedersen, pedersen_with_separator};\nuse crate::constants_gen::{GENERATOR_INDEX__UNIQUE_COMMITMENT, GENERATOR_INDEX__SILOED_COMMITMENT};\n\nfn compute_inner_hash(storage_slot: Field, note_hash: Field) -> Field {\n    // TODO(#1205) Do we need a generator index here?\n    pedersen([storage_slot, note_hash])[0]\n}\n\nfn compute_siloed_hash(contract_address: Field, inner_note_hash: Field) -> Field {\n    let inputs = [contract_address, inner_note_hash];\n    pedersen_with_separator(inputs, GENERATOR_INDEX__SILOED_COMMITMENT)[0]\n}\n\nfn compute_unique_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    pedersen_with_separator(inputs, GENERATOR_INDEX__UNIQUE_COMMITMENT)[0]\n}\n",
+                "path": "/mnt/user-data/alvaro/aztec-packages/yarn-project/noir-libs/noir-aztec/src/note/note_hash"
+            },
+            "46": {
+                "source": "use crate::note::{\n    note_hash::{compute_inner_hash, compute_siloed_hash, compute_unique_hash},\n    note_header::NoteHeader,\n    note_interface::NoteInterface,\n};\nuse crate::utils::arr_copy_slice;\n\nfn compute_inner_note_hash<Note, N>(\n    note_interface: NoteInterface<Note, N>,\n    note: Note,\n) -> Field {\n    let get_header = note_interface.get_header;\n    let header = get_header(note);\n\n    let compute_note_hash = note_interface.compute_note_hash;\n    let note_hash = compute_note_hash(note);\n\n    compute_inner_hash(header.storage_slot, note_hash)\n}\n\nfn compute_siloed_note_hash<Note, N>(\n    note_interface: NoteInterface<Note, N>,\n    note_with_header: Note,\n) -> Field {\n    let get_header = note_interface.get_header;\n    let header = get_header(note_with_header);\n\n    let inner_note_hash = compute_inner_note_hash(note_interface, note_with_header);\n\n    compute_siloed_hash(header.contract_address, inner_note_hash)\n}\n\nfn compute_unique_siloed_note_hash<Note, N>(\n    note_interface: NoteInterface<Note, N>,\n    note_with_header: Note,\n) -> Field {\n    let get_header = note_interface.get_header;\n    let header = get_header(note_with_header);\n\n    let siloed_note_hash = compute_siloed_note_hash(note_interface, note_with_header);\n\n    compute_unique_hash(header.nonce, siloed_note_hash)\n}\n\nfn compute_note_hash_for_read_or_nullify<Note, N>(\n    note_interface: NoteInterface<Note, N>,\n    note_with_header: Note,\n) -> Field {\n    let get_header = note_interface.get_header;\n    let header = get_header(note_with_header);\n\n    if (header.nonce == 0) {\n        // when nonce is zero, that means we are reading a pending note (doesn't have a nonce yet),\n        // so we just read the inner_note_hash (kernel will silo by contract address)\n        compute_inner_note_hash(note_interface, note_with_header)\n    } else {\n        // When nonce is nonzero, that means we are reading a settled note (from tree) created in a\n        // previous TX. So we need the unique_siloed_note_hash which has already been hashed with\n        // contract address and then nonce. This hash will match the existing leaf in the private\n        // data tree, so the kernel can just perform a membership check directly on this hash/leaf.\n        compute_unique_siloed_note_hash(note_interface, note_with_header)\n    }\n\n}\n\nfn compute_note_hash_and_nullifier<Note, N, S>(\n    note_interface: NoteInterface<Note, N>,\n    note_header: NoteHeader,\n    preimage: [Field; S],\n) -> [Field; 4] {\n    let deserialise = note_interface.deserialise;\n    let set_header = note_interface.set_header;\n    let mut note = deserialise(arr_copy_slice(preimage, [0; N], 0));\n    set_header(&mut note, note_header);\n\n    let compute_note_hash = note_interface.compute_note_hash;\n    let note_hash = compute_note_hash(note);\n    let inner_note_hash = compute_inner_hash(note_header.storage_slot, note_hash);\n\n    let siloed_note_hash = compute_siloed_hash(note_header.contract_address, inner_note_hash);\n\n    let unique_siloed_note_hash = compute_unique_hash(note_header.nonce, siloed_note_hash);\n\n    let compute_nullifier = note_interface.compute_nullifier;\n    let inner_nullifier = compute_nullifier(note);\n\n    [inner_note_hash, siloed_note_hash, unique_siloed_note_hash, inner_nullifier]\n}\n",
+                "path": "/mnt/user-data/alvaro/aztec-packages/yarn-project/noir-libs/noir-aztec/src/note/utils"
+            },
+            "48": {
+                "source": "use dep::std::hash::pedersen_with_separator;\nuse crate::context::PrivateContext;\nuse crate::note::{\n    lifecycle::create_note,\n    note_getter::{get_note, view_notes},\n    note_interface::NoteInterface,\n    note_viewer_options::NoteViewerOptions,\n};\nuse crate::oracle;\nuse crate::constants_gen::{\n    GENERATOR_INDEX__INITIALISATION_NULLIFIER,\n    EMPTY_NULLIFIED_COMMITMENT,\n};\n\nstruct ImmutableSingleton<Note, N> {\n    storage_slot: Field,\n    note_interface: NoteInterface<Note, N>,\n}\n\nimpl<Note, N> ImmutableSingleton<Note, N> {\n    fn new(storage_slot: Field, note_interface: NoteInterface<Note, N>) -> Self {\n        ImmutableSingleton { storage_slot, note_interface }\n    }\n\n    unconstrained fn is_initialised(self) -> bool {\n        let nullifier = self.compute_initialisation_nullifier();\n        oracle::notes::is_nullifier_emitted(nullifier)\n    }\n\n    fn initialise(self, context: &mut PrivateContext, note: &mut Note) {\n        // Nullify the storage slot.\n        let nullifier = self.compute_initialisation_nullifier();\n        context.push_new_nullifier(nullifier, EMPTY_NULLIFIED_COMMITMENT);\n\n        create_note(context, self.storage_slot, note, self.note_interface);\n    }\n\n    fn compute_initialisation_nullifier(self) -> Field {\n        pedersen_with_separator([self.storage_slot], GENERATOR_INDEX__INITIALISATION_NULLIFIER)[0]\n    }\n    \n    fn get_note(self, context: &mut PrivateContext) -> Note {\n        let storage_slot = self.storage_slot;\n        get_note(context, storage_slot, self.note_interface)\n    }\n\n    unconstrained fn view_note(self) -> Note {\n        let options = NoteViewerOptions::new().set_limit(1);\n        view_notes(self.storage_slot, self.note_interface, options)[0].unwrap()\n    }\n}",
+                "path": "/mnt/user-data/alvaro/aztec-packages/yarn-project/noir-libs/noir-aztec/src/state_vars/immutable_singleton"
+            },
+            "55": {
+                "source": "\nstruct BoundedVec<T, MaxLen> {\n    storage: [T; MaxLen],\n    len: Field,\n}\n\nimpl<T, MaxLen> BoundedVec<T, MaxLen> {\n    fn new(initial_value: T) -> Self {\n        BoundedVec { storage: [initial_value; MaxLen], len: 0 }\n    }\n\n    fn get(mut self: Self, index: Field) -> T {\n        assert(index as u64 < self.len as u64);\n        self.storage[index]\n    }\n\n    fn push(&mut self, elem: T) {\n        assert(self.len as u64 < MaxLen as u64);\n\n        self.storage[self.len] = elem;\n        self.len += 1;\n    }\n\n    fn push_array<Len>(&mut self, array: [T; Len]) {\n        let newLen = self.len + array.len();\n        assert(newLen as u64 <= MaxLen as u64);\n        for i in 0..array.len() {\n            self.storage[self.len + i] = array[i];\n        }\n        self.len = newLen;\n    }\n\n    fn pop(&mut self) -> T {\n        assert(self.len as u64 > 0);\n\n        let elem = self.storage[self.len - 1];\n        self.len -= 1;\n        elem\n    }\n}\n\n// #[test]\n// fn test_vec() {\n//     let vec: BoundedVec<Field, 2> = BoundedVec::new(0);\n//     assert(vec.len == 0);\n//     let vec1 = vec.push(1);\n//     assert(vec1.len == 1);\n//     let vec2 = vec1.push(1);\n//     assert(vec2.len == 2);\n//     let vec3 = vec2.push(1);\n//     assert(vec3.len == 3);\n//     let x = vec3.pop();\n//     assert(x == 1);\n// }",
+                "path": "/mnt/user-data/alvaro/aztec-packages/yarn-project/noir-libs/noir-aztec/src/types/vec"
+            },
+            "70": {
+                "source": "use crate::types::point::Point;\nuse dep::std::hash;\nuse crate::constants_gen::GENERATOR_INDEX__CONTRACT_ADDRESS;\n\n#[oracle(getPublicKey)]\nfn get_public_key_oracle(_address: Field) -> [Field; 3] {}\n\nunconstrained fn get_public_key_internal(address: Field) -> [Field; 3] {\n  get_public_key_oracle(address)\n}\n\nfn get_public_key(address: Field) -> Point {\n  let result = get_public_key_internal(address);\n  let pub_key_x = result[0];\n  let pub_key_y = result[1];\n  let partial_address = result[2];\n  \n  let calculated_address = hash::pedersen_with_separator([pub_key_x, pub_key_y, partial_address], GENERATOR_INDEX__CONTRACT_ADDRESS)[0];\n  assert(calculated_address == address);\n  \n  Point::new(pub_key_x, pub_key_y)\n}\n",
+                "path": "/mnt/user-data/alvaro/aztec-packages/yarn-project/noir-libs/noir-aztec/src/oracle/get_public_key"
+            },
+            "78": {
+                "source": "use crate::abi;\nuse crate::types::vec::BoundedVec;\nuse crate::context::PrivateContext;\nuse crate::private_call_stack_item::PrivateCallStackItem;\nuse crate::public_call_stack_item::PublicCallStackItem;    \n\nglobal ACCOUNT_MAX_PRIVATE_CALLS: Field = 2;\nglobal ACCOUNT_MAX_PUBLIC_CALLS: Field = 2;\nglobal ACCOUNT_MAX_CALLS: Field = 4;\n// 1 (ARGS_HASH) + 1 (FUNCTION_SELECTOR) + 1 (TARGET_ADDRESS)\nglobal FUNCTION_CALL_SIZE: Field = 3;\n\nstruct FunctionCall {\n  args_hash: Field,\n  function_selector: Field,\n  target_address: Field,\n}\n\nimpl FunctionCall {\n  fn serialize(self) -> [Field; FUNCTION_CALL_SIZE] {\n    [self.args_hash, self.function_selector, self.target_address]\n  }\n}\n\n// FUNCTION_CALL_SIZE * (ACCOUNT_MAX_PUBLIC_CALLS + ACCOUNT_MAX_PRIVATE_CALLS) + 1\nglobal ENTRYPOINT_PAYLOAD_SIZE: Field = 13;\nglobal ENTRYPOINT_PAYLOAD_SIZE_IN_BYTES: Field = 416;\n\nstruct EntrypointPayload {\n  // Noir doesnt support nested arrays or structs yet so we flatten everything\n  flattened_args_hashes: [Field; ACCOUNT_MAX_CALLS],\n  flattened_selectors: [Field; ACCOUNT_MAX_CALLS],\n  flattened_targets: [Field; ACCOUNT_MAX_CALLS],\n  nonce: Field,\n}\n\nimpl EntrypointPayload {\n  // TODO(#1207) Do we need a generator index?\n  fn hash(self) -> Field {\n    dep::std::hash::pedersen(self.serialize())[0]\n  }\n\n  // Serializes the entrypoint struct\n  fn serialize(self) -> [Field; ENTRYPOINT_PAYLOAD_SIZE] {\n    let mut fields: BoundedVec<Field, ENTRYPOINT_PAYLOAD_SIZE> = BoundedVec::new(0); \n    fields.push_array(self.flattened_args_hashes);\n    fields.push_array(self.flattened_selectors);\n    fields.push_array(self.flattened_targets);\n    fields.push(self.nonce);\n    fields.storage\n  }\n\n  // Serializes the payload as an array of bytes. Useful for hashing with sha256.\n  fn to_be_bytes(self) -> [u8; ENTRYPOINT_PAYLOAD_SIZE_IN_BYTES] {\n    let mut bytes: [u8; ENTRYPOINT_PAYLOAD_SIZE_IN_BYTES] = [0; ENTRYPOINT_PAYLOAD_SIZE_IN_BYTES];\n\n    let args_len = self.flattened_args_hashes.len();\n    let selectors_len = self.flattened_selectors.len();\n    let targets_len = self.flattened_targets.len();\n\n    for i in 0..args_len {\n      let item_bytes = self.flattened_args_hashes[i].to_be_bytes(32);\n      for j in 0..32 { \n        bytes[i * 32 + j] = item_bytes[j];\n      }\n    }\n\n    for i in 0..selectors_len {\n      let item_bytes = self.flattened_selectors[i].to_be_bytes(32);\n      for j in 0..32 { \n        bytes[args_len * 32 + i * 32 + j] = item_bytes[j];\n      }\n    }\n\n    for i in 0..targets_len {\n      let item_bytes = self.flattened_targets[i].to_be_bytes(32);\n      for j in 0..32 { \n        bytes[(args_len + selectors_len) * 32 + i * 32 + j] = item_bytes[j];\n      }\n    }\n    \n    let item_bytes = self.nonce.to_be_bytes(32);\n    for j in 0..32 { \n      bytes[(args_len + selectors_len + targets_len) * 32 + j] = item_bytes[j];\n    }\n\n    bytes\n  }\n\n  // Executes all private and public calls \n  fn execute_calls(self, context: &mut PrivateContext) {\n    for i in 0..ACCOUNT_MAX_PRIVATE_CALLS {\n        let target_address = self.flattened_targets[i];\n        if target_address != 0 {\n            let function_selector = self.flattened_selectors[i];\n            let args_hash = self.flattened_args_hashes[i];\n            let _callStackItem = context.call_private_function_with_packed_args(target_address, function_selector, args_hash);\n        }\n    }\n    for i in ACCOUNT_MAX_PRIVATE_CALLS..ACCOUNT_MAX_CALLS {\n        let target_address = self.flattened_targets[i];\n        if target_address != 0 {\n            let function_selector = self.flattened_selectors[i];\n            let args_hash = self.flattened_args_hashes[i];\n            let _callStackItem = context.call_public_function_with_packed_args(target_address, function_selector, args_hash);\n        }\n    }\n  }\n}",
+                "path": "/mnt/user-data/alvaro/aztec-packages/yarn-project/noir-libs/noir-aztec/src/entrypoint"
+            }
+        }
+    }
 }