diff --git a/docs/docs/concepts/foundation/accounts/keys.md b/docs/docs/concepts/foundation/accounts/keys.md index a8b7d182709..d38a9f5140d 100644 --- a/docs/docs/concepts/foundation/accounts/keys.md +++ b/docs/docs/concepts/foundation/accounts/keys.md @@ -8,29 +8,11 @@ Typically, each account in Aztec is backed by two separate keys: Signing keys allow their holder to act as their corresponding account in Aztec, similarly to the keys used for an Ethereum account. If a signing key is leaked, the user can potentially lose all their funds. -Since Aztec implements full [signature abstraction](./main.md), signing keys depend on the account contract implementation for each user. Usually, an account contract will validate a signature of the incoming payload against a known public key. - -```noir -fn entrypoint( - inputs: pub PrivateContextInputs, - payload: pub EntrypointPayload, - signature: pub [u8;64], -) -> distinct pub abi::PrivateCircuitPublicInputs { - // Initialize context and load public key - // ... - - // Verify payload signature - let payload_bytes: [u8; entrypoint::ENTRYPOINT_PAYLOAD_SIZE_IN_BYTES] = payload.to_be_bytes(); - let payload_hash: [u8; 32] = std::hash::sha256(payload_bytes); - - // Verify signature of the payload hash - let verification = std::schnorr::verify_signature(public_key.x, public_key.y, signature, payload_hash); - assert(verification == true); - - // Execute calls and return - // ... -} -``` +Since Aztec implements full [signature abstraction](./main.md), signing keys depend on the account contract implementation for each user. Usually, an account contract will validate a signature of the incoming payload against a known public key. + +This is a snippet of our Schnorr Account contract implementation, which uses Schnorr signatures for authentication: + +#include_code entrypoint /yarn-project/noir-contracts/src/contracts/schnorr_account_contract/src/main.nr rust Still, different accounts may use different signing schemes, may require multi-factor authentication, or _may not even use signing keys_ and instead rely on other authentication mechanisms. Read [how to write an account contract](../../../dev_docs/wallets/writing_an_account_contract.md) for a full example of how to manage authentication. @@ -89,16 +71,7 @@ In a future version, encryption keys will be differentiated between incoming and An application in Noir can access the encryption public key for a given address using the oracle call `get_public_key`, which you can then use for calls such as `emit_encrypted_log`: -```noir -let encryption_public_key = get_public_key(recipient); -context = emit_encrypted_log( - context, - application_contract_address, - storage_slot, - encryption_public_key, - note.serialise(), -); -``` +#include_code encrypted /yarn-project/noir-libs/value-note/src/utils.nr rust :::info In order to be able to provide the public encryption key for a given address, that public key needs to have been registered in advance. At the moment, there is no broadcasting mechanism for public keys, which means that you will need to manually register all addresses you intend to send encrypted notes to. You can do this via the `registerRecipient` method of the Aztec RPC server, callable either via aztec.js or the CLI. Note that any accounts you own that have been added to the RPC server are automatically registered. @@ -110,13 +83,8 @@ In addition to deriving encryption keys, the privacy master key is used for deri An application in Noir can request a nullifier from the current user for computing the nullifier of a note via the `get_secret_key` oracle call: -```noir -fn compute_nullifier(self) -> Field { - let siloed_note_hash = compute_siloed_note_hash(ValueNoteMethods, self); - let secret = get_secret_key(self.owner); - dep::std::hash::pedersen([siloed_note_hash, secret])[0] -} -``` +#include_code nullifier /yarn-project/noir-libs/value-note/src/value_note.nr rust + ### Scoped keys :::warning diff --git a/yarn-project/aztec.js/src/abis/ecdsa_account_contract.json b/yarn-project/aztec.js/src/abis/ecdsa_account_contract.json index cc6ca54c468..2e4f7eed443 100644 --- a/yarn-project/aztec.js/src/abis/ecdsa_account_contract.json +++ b/yarn-project/aztec.js/src/abis/ecdsa_account_contract.json @@ -48,7 +48,7 @@ } } ], - "bytecode": "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", + "bytecode": "H4sIAAAAAAAA/+3dzY8kSZrX8Uj3eHWP98iMyPfXqqzMeo3M6uqq6e7p8Zne2ctekBAnxIWhZwVCC4IBaSWg4bBICC23PXDjxg1x58IR/gw4ckMr7XG07ZH+TP7K0iKrotO941uz5lIqzM0j/PmYeWSEu7mZRa9Wq23Ubpb4+7967e5i27Picf6w5WqjvH3Nq3RGn4gzLtGZ2xq1ao9/vYJ6LdvY+ASMzU/A2PoEjO1auf8/ZrTP0s73f8n3f+n3f93a7fJPtm+32/9cLK+x10eSFzt10JHttjQlnZVTrjfN8ut93ij8NXnU8vaLsrTKjXuldVSv3dZzS46Bbe/JY57XLtdy3ZSyl7TP1/k+k3L3+Vm+z7SC91S33H1+3pRjVtI+31q5a/LezOP0y41ztVF7f8kkbbHUEoMsdZClAbI0QZYWyNIGWTogSwKypCBLF2TpgSwba7Z0xFCTPNvelryBpO1xWKQTyRs55czzxkW6K3mTIt2TvM0irefMW0Vaz62nRVrP0WdFuiF5ei5qebYfLY/tZyh5tp+R5Nn3wVjy7HN5InlWb5uSZ/W2JXlWb1PJs3rT8vxr2W7P1TqaefZjaX2PWeyseJw/bFm8xzROJusWKxHDFGDpgSxdkCUFWRKQpQOytEGWFsjSBFkaIEsdZIlBlsix6HnGTPIi57Wtwl1yG8WbPJa2LZpfl0zSFZ7DzvN9DkreZ76PofitrHpObNsHUrZhuY7F+6Nfe79ObX0ocUP5S40byl8L5f+bXP7QBh3aoH+oJbRBhzboVSyhDTq0Qa9iGYAs9PZwbdO28wVt07a2Ym1bvq8NWtub7fvP9pF/B/2mfTde5Ik39LiqrkuNk8m6xdJ23yHAMgBZeiBLF2RJQZYEZOmALG2QpQWyNEGWBshSB1likCVyLKGNILQR/FBLaCMIbQSrWEIbQWgjWMVCaiOo+rt7FcsIZKG3nWg/OrdNJP8u/W/S1mH34LWtoxhu814/wJ0irf0Ad2WflrdXpJuSt1+kWx6r9gGwvn7bkmd9/XYkz/r67Uqe9RvYkzzrc7DvsegxtNdkxeP8YcviGGqcTNYtlrbZ7AMsI5BlCLIMQJYeyNIFWVKQJQFZOiBLG2RpgSxNkKUBstRBlhhkiTyW3XIt13oeVxOTLpmk9TxsxzHnvu0K6mrHsdi6xUrF0K/Mcr3ob+TGrqDM1x2nzPly3zHRc2g7x94R30G5vsUxmTkWW7dYWlfjyiw3x8SNXUGZrztOmfPlvmNi8fPXHRbpmfiOyvUtjsmhY7F1i6V1NanQknpiVxDnuuOUOV/uOyYWP3/dcZE+FN9JyfWwIXFsv7ZusbSuNiu0pJ7YFcS51rq15b5jYvHz150W6WPxnZVcDxsSx/Zr6xZL62qrQkvqiV1BnOuOU+Z8ue+YWPz8dY+K9Kn4HpdcDxsSx/Zr6xZL62paoSVdEtsWvYf4qIJ6qDn1YMsjjyUGWeogSwNkaYIsLZClDbJ0QJYEZElBli7I0gNZ+iDLAGQZgiwjkGUMskxAlk2QZQtkmYIsM5BlG2TZAVl2QZY9kGUfZDkAWQ5BliOQ5RhkOQFZTkGWM5BlY82WZf3UbLv21bJ2Ne3ndV6ktY/YkyJ9KHkXRfpY8i6L9KnkPS3SOtfeM0nb4/MirXPtRZ6yWVvbY8mrF+lzybO2pyeSZ21AF5JnbTGXkmfWp5JnVrWb1ex5zP/dv1smfU/Y67Picf6wZfGe0DiZrFss7ff2HGA5A1lOQZYTkOUYZDkCWQ5BlgOQZR9k2QNZdkGWHZBlG2SZgSxTkGULZNkEWSYgyxhkGYEsQ5BlALL0QZYeyNIFWVKQJQFZOiBLG2RpgSxNkKUBstRBlhhkiRxLItt1DIa1xe1InrXZzSTP2vYOJc/aAI8lz9oKrf1H23AjqZcq+ljqkkna188xBlnqIEsDZGmCLC2QpQ2ydECWBGRJQZYuyNIDWfogywBkGYIsI5BlDLJMQJZNkGULZKlyHM+qlhnIsg2y7IAsuyDLHsiyD7IcgCyHIMsRyHIMspyALKcgyxnIcg6yPAFZLkCWS5DlKcjyDGR5DrJsrNmyrL+wbde5J60frvaBfVGkta/syyKtfWpfFWntezsv0tpH96pIa1/eyGO2dnHtG2zWF5LXKNIvJc/aa19JnrWbziXP2i/NlO9rb3DXH3n8c0859Vhb7MyeX8Kx1jiZrFss7Qc8B1iegyzPQJanIMslyHIBsjwBWc5BljOQ5RRkOQFZjkGWI5DlEGQ5AFn2QZY9kGUXZNkBWbZBlhnIMgVZtkCWTZBlArKMQZYRyDIEWQYgSx9k6YEsXZAlBVkSkKUDsrRBlhbI0gRZGiBLHWSJQZbIsSzrY1+FT5dM0q88lhhkqYMsDZClCbK0QJY2yNIBWRKQJQVZuiBLD2TpgywDkGUIsoxAljHIMgFZNkGWLZBlCrLMQJZtkGUHZNkFWfZAln2Q5QBkOQRZjkCWY5DlBGQ5BVnOQJZzkOUJyHIBslyCLE9Blmcgy3OQpeq28FUsVyDLxpoty8Ye6D0Ey7P++1eSF3n2Z2359vy8DfuvBnf3HXn2/cpj0Dp64ZRl/rBlUUcaJ5P1F1IHG45vnZYrkGUOsjwHWZ6BLE9BlkuQ5QJkeQKynIMsZyDLKchyArIcgyxHIMshyHIAsuyDLHsgyy7IsgOybIMsM5BlCrJsgSybIMsEZBmDLCOQZQiyDECWPsjSA1m6IEsKsiQgSwdkaYMsLZClCbI0QJY6yBKDLO69hmVjGarw6ZJJ+oXHEoMsdZClAbI0QZYWyNIGWTogSwKypCBLF2TpgSx9kGUAsgxBlhHIMgZZJiDLJsiyBbJMQZYZyLINsuyALLsgyx7Isg+yHIAshyDLEchyDLKcgCynIMsZyHIOsjwBWS5AlkuQ5SnI8gxkeQ6yvARZqm6XX8UyB1muQJaNNVuWjfGw7W3Js99y0N9qiDz7c3/7IW/bfzG8u+/Is+8XHoPWURW/waFxMlm3WDrG4wXAcgWyzEGWVyDLS5DlOcjyDGR5CrJcgiwXIMsTkOUcZDkDWU5BlhOQ5RhkOQJZDkGWA5BlH2TZA1l2QZYdkGUbZJmBLFOQZQtk2QRZJiDLGGQZgSxDkMX6KREsfZClB7J0QZYUZElAlg7I0gZZWiBLE2RpgCx1kCUGWdx7MMvGvqz7t9RjkKUOsjRAlibI0gJZ2iBLB2RJQJYUZOmCLD2QpQ+yDECWIcgyAlnGIMsEZNkEWbZAlinIMgNZtkGWHZBlF2TZA1n2QZYDkOUQZDkCWY5BlhOQ5RRkOQNZHoEs5yDLE5DlAmS5BFmegizPQJbnIEvV7fKrWF6CLK9AljnIcgWybKzZsmxMkG63x+si/UjyIs/+7N6PPb/x/d8vh3f3HXn2/dhj0Dp67ZRl/rBlUUcaJ5N1i6Vjgh4DLFcgyxxkeQWyvARZXoAsz0GWZyDLU5DlEmS5AFmegCznIMsjkOUMZDkFWU5AlmOQ5QhkOQRZDkCWfZBlD2TZBVl2QJZtkGUGskxBli2QZRNkmYAsY5BlBLIMQZYByNIHWXogSxdkSUGWBGTpgCxtkKUFsjRBlgbIUgdZYpDFvTeVyPY9yfusSO9I3psiPZO8z4v0oeS9LdLHkveuSFv7z7IxWj+plV8vumSS/onHEoMsdZClAbI0QZYWyNIGWTogSwKypCBLF2TpgSx9kGUAsgxBlhHIMgZZJiDLJsiyBbJMQZYZyLINsuyALLsgyx7Isg+yHIAshyDLEchyDLKcgCynIMsZyPIIZHkMspyDLE9AlguQ5RJkeQqyPANZnoMsL0CWlyDLK5BlDrJcgSzXIMtrkOUzkOUNyPI5yPIWZHkHsmys2bJsDKhtb0jeF0X6teR9WaQ/k7yvivQbyftpkf5c8r4u0m8l72dF+p3kRR6z3b/+QvLsPvKXkmf+ryTP7qv+VPLs/ubXkmf3Gc2U72tvcNcfefxfe8qpx9piZ8Xj/GHL4lhrnEzWLZaOZf0aYHkHsrwFWT4HWd6ALJ+BLK9BlmuQ5QpkmYMsr0CWlyDLC5DlOcjyDGR5CrJcgiwXIMsTkOUcZHkMsjwCWc5AllOQ5QRkOQZZjkCWQ5DlAGTZB1n2QJZdkGUHZNkGWWYgyxRk2QJZNkGWCcgyBllGIMsQZBmALH2QpQeydEGWFGRJQJYOyNIGWVogSxNkaYAsdZAlBlkij+Wrci2faR+Amph0yST9lVi+LNeyuC30hcQyl8VJZbv20fuiXMfi+HzplN/W1fex1kefkPX6E7L+bM1W7WejfVYix9wqjM1yjdfaj8aW+/53m2K070WdV6FdQR22HIutW6xUDHF1ljepJ3aypB465caea58l23f+nffv2rcx05LLm++zX3I58uNp1wL58p2US8esVxG358RNnbgbtffnWfhOrPbaWJ7z5+3b4/AfirReA2r/uoETS//HbVur9v71rP5fDiVt9VWXvLGkI+c12nag47ytnSUrHucPW950HEe+3PdZouO8t8q1LI63jlHOJIbGnZUb90rjbhR/FsPyY0n/FzuY8rx8sfeAmbWNTp+n6bHzmlS2b1Zc5i1xZLJusfL36l9IWTc9bv08t+06R8Jmye58HxNxtB1bR8qhn+3TH7H+plInDae+KrAsvuPc2FXV/dYH6t7y7Hnu9129XNO19j225b7PL53bqtzzsuvF9/0POS/LH1ulWubzCs6lFtdpHfFbWc2eynadE6rk86p7zy91/qdQ/lLjhvLXQvlD+UP5Q/lD+UP5Q/lD+UP5Q/lD+UP5Q/lD+UP5Q/lD+UP5Q/lD+UP5Q/lD+UP5Q/lD+UP5Q/l//PJ3JC9esyUVQ3X9La/nac3/Pii5zNcdp8z5cl8/D7WU29/zps9JsoJFfweqW6qluj4n2gfUytqV8th2/Z/rleu4cvvAZrW7/UxD+UP5Q/lLjRvKXwvlD+UP5Q/lD+UP5Q/lD+UP5Q/lD+UP5Q/lD+UP5Q/lD+UP5Q/lD+UP5Q/lD+UP5Q/lD+VfT/k7ktdas0X7giSVWW76nPjeByWXefE+6EuZIyemztdb3ZxcN+V1DXmcQalxbo6xLpmkLZZaYpClDrI0QJYmyNICWdogSwdkSUCWFGTpgiw9kKUPsmys2dKp+X9H2rZ3JW9YpO+b5zLPs+9Ye37+3fL3hrfbbd6/SF5j897Fnngjj2vsea3Wpb0mKx7nD1sWdalxMlm3WPo7zWOApQ+y9ECWLsiSgiwJyNIBWdogSwtkaYIsDZClDrLEIEvksZTd/qHnF7bv/Hj8SXIbs9z5bq9+ne+z5HmX5+68wd9JuWZSf1XEnTpx3bmp8+foPNvf1e7OKxzLc/5r//Y4/MviOOhvB2qbzE655VnMRWy/I5kv9h60OPp7irvi+LHaw3ZLjXP/Ob/FWtYetm5LHWRpgCxNkKUFsrRBlg7IkoAsKcjSBVl6IEsfZBmALEOQZQSyjEGWCciyCbJsgSxTkGUGsmyDLDsgy8aaLcvuidj2bcnbK9K+eyK6P7vOsue790T2i3y9J3JQpGNPvH2P68DzWq1Le01WPM4ftizqUuNksm6x9J7IAcCyA7JsgywzkGUKsmyBLJsgywRkGYMsI5BlCLIMQJY+yNIDWbogSwqyJCBLB2RpgywtkKUJsjRAljrIEoMskcdS9j3qfB+HtdvFriM3xWGmwwod+T6PSt3nzdyWWjarb10ySR9J+U5KtdzcPz+V/WcSQ+OelRv3SuNuFH8Ww/JjSb+SBpez2+TvrgPNnL8vjj3P0/Sh85pUth9XXOYTcWSybrHyz5xHUtZjj3tT3LZd21fsuMVSluMKynJUe78sR45Z58c9rMxy01fBjV1Bma/zfejxi5yYiThOxPFj9c0o+bPh3rZH/d+xJQZZ6iBLA2RpgiwtkKUNsnRAlgRkSUGWLsjSA1n6IMsAZBmCLCOQZQyyTECWTZBlC2SZgiwzkGUbZNkBWXZBlj2QZR9kOQBZDkGWCtv9VrYcgywba7Ys62/ltpvmedZ+6etvpfuzthN7vtvfytoHI3nNoyIde+KdeVyPPK/VuqyivVPjZLJusbS/1SOA5RhkOQJZDkGWA5BlH2TZA1l2QZYdkGUbZJmBLFOQZQtk2QRZJiDLGGQZgSxDkGUAsvRBlh7I0gVZUpAlAVk6IEsbZGmBLE2QpQGy1EGWGGSJPJYq5haymDq3UKd7G7OK/pIXJZcjr8fz2u3ynZTrQuqvirhPnLibTtz8OY/F8J1Y7bWxPOfPZG6hUXEcEtmf9ol5Wm55Xuf7eFa7Xew9aHFyx2WRfiaOH6v/2rNS49zflmuxlvVfW7elDrI0QJYmyNICWdogSwdkSUCWFGTpgiw9kKUPsgxAliHIMgJZxiDLBGTZBFm2QJYpyDIDWbZBlh2QZRdk2QNZ9kGWA5DlEGQ5AlmOQZYTkOUUZDkDWR6BLI9BlnOQ5QnIcgGyXIIsT0GWjTVblvUbtu2Xkve8SPv6Dev+rM3anu/2G35R5EfympdFOvbEe+FxvfS8VuvSXpMVj/OHLYu61DiZrFss7Tf8EmB5CrJcgiwXIMsTkOUcZHkMsjwCWc5AllOQ5QRkOQZZjkCWQ5DlAGTZB1n2QJZdkGUHZNkGWWYgyxRk2QJZNkGWCcgyBllGIMsQZBmALH2QpQeydEGWFGRJQJYOyNIGWVogSxNkaYAsdZAlBlkij6WKOa9f1W4Xa5PXOa/N9KpCR77Pean7vJnzWstm9a1LJum5lO+6VMvNuI7Xsv9MYmjcz8qNe6VxN4o/i2H5saTnduIhz8sXa1M3c/6+uPI8T9OvnNeksv2q4jJfiyOTdYuVf+Y8lrJeedw657Vt13tVdty0T/5VBWWZ194vy9wxp2J4VZnlZgyNGzuRvFjyrjx187pUz3xxKPX9Zp+Xr8XhHvfU8/yq3oO6ZJL2WWKQpQ6yNECWJsjSAlnaIEsHZElAlhRk6YIsPZClD7IMQJYhyDICWcYgywRk2QRZtkCWKcgyA1m2QZYdkGUXZNkDWfZBlgOQ5RBkOQJZjkGWE5DlFGQ5A1kegSyPQZZzkOUJyHIBslyCLE9Blmcgy3OQ5QXI8hJkeQWyVH1/chVL1fcNV7FcgyyvQZaNNVt8Yx7z+0j/UcYovi3yI3nNuyKtYxR/UqTrkmdx3kremyL9TvI+L9I/8exP6+idU5b5w5ZFHWmcTNYtlo5l/AnA8hpkuQZZrkCWOcjyCmR5CbK8AFmegyzPQJanIMslyHIBsjwBWc5BlscgyyOQ5QxkOQVZTkCWY5DlCGQ5BFkOQJZ9kGUPZNkFWXZAlm2QZQayTEGWLZBlE2SZgCxjkGUEsgxBlgHI0gdZeiBLF2RJQZYEZOmALG2QpQWyNEGWBshSB1likCVyLHpvcS55dv/wSvK+KNLXkvdlkdb7m18V6TeS99Mi/bnkRY5P52/V+5d2LL+QPHuvfSl59r/wleTZ/6rFz9cTZ71WvHanSGfF4/xhy5Va8sXa4XYk7wtJnzr+RMr3hTjfluq8GYuujny57172W7F8XarlZiz6z2T/mcR46+SXGPdK427Ubv+HapIfS/o/24ld7f26sfeVmfNj+M7zPE1/4bwmle3vKi7z147JPZ75/95/krK+87jPxG3bvxR3Ff9Xb8Xh/l/pZ5r+f5f8Xl3U3zun/mxdj2XLqa/yLTfj393YVdX9uw/UveXZ8/Q3VhPxxRU7fybOkePMl59L2q5f7TWJWH4uzl+U6rz57FVHvtz32fsLsfxBqZabz95fyv4ziaFx/7DcuFca1z57LYblx5L+H/J59Ie3yd+9r8ycH8NvPM/T9M+d16Sy/ZuKy/wH4shk3WLl/zf/Xcr6jcc9Evc3jrGq/6tfiMP9v+qIQ/+/S36vLurvG6f+bF2PZezUV/mWm89eN3ZVdf/NB+re8ux5+XvoT5Lb+rAlEmdasvO+z6+0dtcSgyx1kKUBsjRBlhbI0gZZOiBLArJsrNmy7HdubHskedYurv28rd1e+3nbaUFD8nReDMuz89qW5Nl3RFvyxpK2R7vvlkhe5CmbWbuSZ9ae5Jm1L3lmHUieWYeSZ9aR5JlV7WY1ex7zL4Z3y6TvCXt9VjzOH7Ys3hMaJ5N1i6V93CcASwKydECWNsjSAlmaIEsDZKmDLDHIEjmWVuFJyvUsbkPY50dd4lqcWLb/28Ht844Gt3XULde0uA2Sekz6XW/bzwpHr7b8eq1Xru/ecxiLtex6bd2WOsjSAFmaIEsLZGmDLB2QJQFZUpClC7JsrNmy7DrWtus1q13j6TWrXePpNavOn2h5do2n16x2LqHXrJHHZwa9xjSDXmOaQa8xzaDXmGYYi/1/Du9aI4915CmTHkOLnRWP84cti2OocTJZt1h63TkCWLogSwqyJCBLB2RpgywtkKUJsjRAljrIEoMskWPR72L7/srr7t8MbrcPnP3k2/+yyFx2rdqvoHy6ZJK2WMuuVddtqYMsDZClCbK0QJY2yNIBWRKQJQVZuiDLAGQZgiwjkGUMsmys2bKsbcO2f+h+vN5vtjyd69/ybIyvtm3YGGRf24b6zKDtHe79Jm3b2JQ8M2xJnhmmYv/t8K418li3PGXSY2ixs+Jx/rBlcQw1Tibr+nuAG45vnZYxyDICWYYgywBk6YIsKciSgCwdkKUNsrRAlibI0gBZ6iBLDLJEjkXbuux8R9u69NxO7ylFzr6tj0uj3HJd63lfTcqnSyZpbetplmuZWzlrUk81iaPj37RdsFWuY3Gsm075bV19H2uN12xd1p5a8vG799qo6bHEIEsdZKnwf2xly8aaLcuupW27XjdHzmvzevxXo9vt7meH7kevoVuesrcrKLvGyWTdYuk1aAtgaYAsdZAlBlkij6VTrmVusWoSoyZxEsdk2xLHq/+zibjDeU44z/kh1gqO1WcV/C9f63eMLfe9F/XeXcn/y9fdwqLfoxZL61bfhyWPe1v8P3Rvi3vnvFXbbXRcWFe2W17kPC98noTPkx9qreBYvQ6fJzfLp/55Ui/TfDWf67WI3h+0zw1bPvaayVfPZZ8HbtTe7z+R1e4e7wqO75XG3Sj+9NhaHVr6nw5vn6tjp34r9VSX/XWl7n7rvMae05a07kffd5rWe7m1Yp+2XffV+oCvWSt9TNmiPjtizWS9K/F/Nbw1lPx5fK11Wq8t/zwuuexzfU/Ye9g9Lnl+FWMkLK69h91xGjqW79/bjU55Xr7Y+0o/u1rO83R8e7PiMnWkTJms9yR/2XP0/8VXRr2+TDzPu69eUtmefGQcfU3V48607Jmsa/+Qfy79KToes34WW562ddlj7NSDfadF5ZZr/qnsU79nfW2DmudrQ4w8x0LPXS3PbbOy+UPduTv0/r0eK7evkM4J3pA8d+4O7Sfhm7tDzxGqGNNtcWy/tm6x0trduUDKt9zMreXG1nqIK4v98fXgzn+yjnqoVxb74+vBnfOlCsuH6qEBqAcztNdYD01APbhtzOuohxagHsyQ/Mj10Kotv49cxb2OmlMXtrSlLmyJQZY6yNIAWZogS9X36VaxVH2P+UOWZffXbbue59pnr7ZP2eeQtvdZ+fR8WM9nLM+9ttJzafVpPHvUc2DLs3g6n5zF03Y+9/o4f92fje5aI4/V116ox7CKti6Nk9Xev6a1OthwfOu0tECWJsjSAFnqIEsMsrjt/fp5pu1p7vVqOD/6OEs4PwrnR6tYwvkR4/zo/47vWsP50Q+zhPOjcH40/z05P1p2zlOFT5dM0qnHEn4Hwm8JvwPht5B+B6Lq//NVLD2QperziA9ZOrX7f3vhvuvD/P/u705ut9t5WeTZj6/PvJa9U0HZNU7mGMy04fjWaemBLF2QpQWyNEGWBshSB1likCXyWEq+5l/0DZafwfvdZ66OVzKTzpejaXuMnOdZP6q4ZPPv+fiF3/UZ1+uHmtSjOfW70u0Xq8dD+1dV0d++gv+RxbiAsn+/ooLzpDcV9MH9vII+lW+XXZeGOURvlzCHaJhDdBVLmEM0zCG6ioU0h2gPZNlYs2VZO4Zt13tLOieRPerc35anvx1tedZ3UO8J2dyS2lZicxzp+Z3Nn6T3tnT+JMubFWm9l7ZdpPVemv2use9emm9eTC23xdPf93Dnpdd7adp31P2dvTzP6lfn1LT61XmjrH6nkmf1O5M8q99tybP6tXLn3n8g7U/2XK3zHc9+LK3vWYudFY/zhy2L96zGyWTdYmn70zbA0gNZuiBLCrIkIEsHZGmDLC2QpQmyNECWOsgSgyyRY1nW5lCFT5dM0jOPJQZZ6iBLA2RpgiwtkKUNsnRAlgRkSUGWLsjSA1mq/r5cxbIDslR9Xfshy7K2GNvuu7+lbR7/a/N2u7UTRJ79aBvC1FP2rQrKrnGy2t3f+9Br+inAsgOybIMsPZClC7KkIEsCsnRAljbI0gJZmiBLA2SpgywxyBJ5LCX/xsa13vepiUmXTNL6m2iTci2LfmJjiWUui5PKdj2frWJekIlTfltX38daZ2u2LmsjK/n43XvuPfFYYpClDrI0QJYmyNICWdogSwdkSUCWFGTpgiw9kKXC84mVLVsgyxRkmYEs2yDLDsiysWbLsjZV2659rCLntfn5zv+RNlU7b408+9F+XmNP2UcVlF3jZLJusbRNdQyw7IAs2yDLDGSZgixbIMsmyNIDWbogSwqyJCBLB2RpgywtkKUJsjRAljrIEoMskccyLNeyaPe2sQ/5Yue6OubDTDpGYuB49dzattl43JLHzl7rmIqa1KMumaS1jarkMbdzHaOh7XJV/GZP6pTP1nVuJvd3OKuwpJ7YFcS57jhlzpf7jrNaqjjO7u/1VDWeq+eUz9Z1bJk7d0wVltQTu4I41x2nzPly33FWy6DkMut4N22rrOI7YOiUz9Z1bJ0ZBhVaUk/squvW9p1/98eT25hl//ZJBffQ5+59z++kXNqOW0XcTSfu2Im74RzD78Rqr43lOfPJ7XFI5ThMS7Vf/Trfx0zsbv8CbQvQvpIzT71WYdsRW+yxWVvSjtjc8ZP583aLtH4P7xVp/d44KLUM8ze5Z7/2/nLfZ+iBWA7LtSzOKY8klrkOpR5s+644jsp1LD5jD53y27r6PtY6+4Sse5+QdecTstbXbO1I3r7kRY7Zrr2q+Ky0GNqXTM9ljiXtuhIpy7H4j51y5s87KdL6WXpapPV88Uxi2X5OZfsjSZ84r8ljP3bi5PV2XqSz4nH+sGVxbB+LI5N1i6XXb48qtKSe2FW9VyzOsvfKE0nb9669JhGfPa8j6XN53oXUoeVdFml9rzwtHiPZz6VsfybpC+c1eeznTpy83l4U6ax4nD9sWbxXnosjk/UXEj91zFVYUk/sRPL0GullmbGvbs4jLGYkMV/K8XjlcczLdBTHw+LYfm19Lsej59RTFZbUE7uKa7WaU2b3uk2v5ex57rVcmBdxpeVNlfMiLuuHG+bHu13C/HhhfrxVLGF+vDA/3iqWMD9emB8vXz40P17k8VU9T13+uv+3ebdMeq5hsXWOPjPWPWVS19jjH3nKaWl9T5R9brvhxMlk3WJpv8oq7zd9rKUHsnRBlhRkSUCWDsjSBllaIEsTZGmALHWQJQZZ3POCZdf0Vfh0ySQ98FhikKUOsjRAlibI0gJZ2iBLB2RJQJYUZOmCLD2Qpervy1UsVfZpW9UyBlkmIEvV1/sfsixrA7Lt2g5i7RraDmJ967QdxPqs6W8V6Nhqy7N+RfpbBdanTNuetO+ZPVr/KW17cvubad8wbXuyPmC+tietFyuntudYOfU3DaycOt7WyqnzEVo5tZ+fO0e5/kaCltvKuSt5Vs49ybNyah8ZK6eVO/f+f2nzsufqsT7w7MfS+p612FnxOH/YsnjPapxM1i2WtlHtAywTkGUMsoxAlj7I0gNZuiBLCrIkIEsHZGmDLC2QpQmyNECWOsgSgyyRY1nWplmFT5dM0nseSwyy1EGWBsjSBFlaIEsbZOmALAnIkoIsXZClB7L0QZYRyDIGWSYgS9XnV6tYDkCWqtvNPmRZ1tZr27WfnLUzHkhe5NmfnR/a8/Pzol8O7+478ux7z2PQOtpxyjJ/2LKoI42TybrF0rbFPYDlAGTZB1kmIMsYZBmBLH2QpQeydEGWFGRJQJYOyNIGWVogSxNkaYAsdZAlBll856+2Xe+rR85r7xtHWvJY33vP4y3WsmuKdViWXVPETl1pvdq2/H/m70xvtzc8r2l64unrLU/bht3Xah2VPI56UUcaJ5N1i5U4hnVbIseSf7/YOckff/ubv/3tr/7Zt7/5o2//VI+re2zyJZa09v9pOa9ZNja7gvfs7/tY+esqx8prfyQ9dh0nlvZHann2qX239P/WHs2h+wjj9D9sCeP0wzj9VSxhnH4Yp7+KJYzTD+P08yWM0w/j9Fe1hHH6YZz+KpYwTj+M01/FEsbph3H69/l0ySQdxul/vCWM0w/j9FexhHH6YZz+KpYwTj+M01/FEsbph3H6+fI3eZx+Z3a7PYzTf5gljNMP4/RXsYRx+mGc/iqWME4/jNNfxRLG6Ydx+vf5dMkk7RtbFsbp+y1hnL7fEsbp+y1hnL7fEsbp+y1hnL7fEsbp+y1hnL7fEsbpv98+6Gvrte0TyXvIOP0XYZx+aZYwTt9vCeP0/ZYwTt9vCeP0/ZYwTt9vCeP0/ZYwTt9vCeP0/ZYwTn/1suiSSfr3cZz+r7Zvt/vGGLvjj/V5WvYqxrxrnEzWfePv6wBL5LGUPE58nu/DvgNqtffvD5jDTNoW3C65TvJ9dDyOtji0X5E5knId1/k+fPdLEnm0+NrW2S3X8brjOPLlvv9fbevslWtZvEf6EstcPVm37VWP9+455XfHk61irXoMdpnWqsdFf8hawfvq1xX0kbzWsZe2fEy/ydwyLNfy2ubgsONq+3frVs8/qvh8H98W973jmS/axqDPs3Rdtuv3vW3/8+ltmZadU03KLdO95zEWa9k973Vb6iBLA2RpgiwtkKUNsnRAlgRkSUGWLsjSA1n6IMsAZBmCLCOQZQyybKzZsqxNSOdcsTwbR+Ob7033Z+dkm7KPfyRtRzb2RtuObOyNb7zSlsc19bxW69JekxWP84cti7rUOJmsWyxtY5oCLGOQZQSyDEGWAcjSB1l6IEsXZElBlgRk6YAsbZClBbI0QZYGyFIHWWKQJXIseu6oY7ptjLaeg0bO/vS8VMeyhzmHP2wJcw6HOYdXsYQ5h8Ocw6tYwpzDYc7hfAlzDoc5h1e1hDmHw5zDq1jCnMNhzuFVLGHO4TDn8H0+XTJJhzmHP94S5hwOcw6vYglzDoc5h1exhDmHw5zDq1jCnMMfP+ewtm9Yu4a2C+l9GnvUezyWN3XKrvd1tF3I5t4lzgec72tvcNcfefwzTzn1WFvsrHicP2xZHGuNk8m6xdK2nRnAMgFZxiDLCGTpgyw9kKULsqQgSwKydECWNsjSAlmaIEsDZKmDLDHIEjmWZW2BVfh0ySQ99VhikKUOsjRAlibI0gJZ2iBLB2RJQJYUZOmCLD2QpQ+yjECWMcgyAVmqPr9axbINslTdbvYhy7I2Utuufc6snVF/Qyzy7M/OD/X32f5qcHffkWffU49B62jTKcv8Ycu9/fkt1rKxkeuybIMsM5BlArKMQZYRyNIHWXogSxdkSUGWBGTpgCxtkKUFsjRBlgbIUgdZYpDFd/7qm7sjcl7bKtz1ct2v9fy5Jn5dMklb/PzzwL5D/vjb3/ytf/H3//E//NUfffunG7IP22/s2a+eizec52n5dc7VZXPp3vd67XMRe/bplrW0N0RbCh0VwetF8GYRvC1xFWpfinkF/zVnZa/ToTUEAA==", "verificationKey": "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" }, { @@ -442,8 +442,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -486,8 +486,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -530,8 +530,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -574,8 +574,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -618,8 +618,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -662,8 +662,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -706,8 +706,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -750,8 +750,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -794,8 +794,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -838,8 +838,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -882,8 +882,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -926,8 +926,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -970,8 +970,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1014,8 +1014,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1058,8 +1058,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1102,8 +1102,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1146,8 +1146,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1190,8 +1190,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1234,8 +1234,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1278,8 +1278,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1322,8 +1322,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1366,8 +1366,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1410,8 +1410,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1454,8 +1454,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1498,8 +1498,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1542,8 +1542,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1586,8 +1586,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1630,8 +1630,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1674,8 +1674,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1718,8 +1718,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1762,8 +1762,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1806,8 +1806,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1850,8 +1850,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1894,8 +1894,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1938,8 +1938,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -1982,8 +1982,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2026,8 +2026,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2070,8 +2070,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2114,8 +2114,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2158,8 +2158,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2202,8 +2202,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2246,8 +2246,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2290,8 +2290,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2334,8 +2334,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2378,8 +2378,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2422,8 +2422,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2466,8 +2466,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2510,8 +2510,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2554,8 +2554,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2598,8 +2598,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2642,8 +2642,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2686,8 +2686,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2730,8 +2730,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2774,8 +2774,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2818,8 +2818,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2862,8 +2862,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2906,8 +2906,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2950,8 +2950,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -2994,8 +2994,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -3038,8 +3038,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -4289,8 +4289,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -4340,8 +4340,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -4391,8 +4391,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -4442,8 +4442,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -4493,8 +4493,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -4544,8 +4544,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -4595,8 +4595,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -4646,8 +4646,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -4697,8 +4697,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -4748,8 +4748,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -4799,8 +4799,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -4850,8 +4850,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -4901,8 +4901,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -4952,8 +4952,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -5003,8 +5003,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -5054,8 +5054,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -5105,8 +5105,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -5156,8 +5156,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -5207,8 +5207,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -5258,8 +5258,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -5309,8 +5309,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -5360,8 +5360,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -5411,8 +5411,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -5462,8 +5462,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -5513,8 +5513,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -5564,8 +5564,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -5615,8 +5615,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -5666,8 +5666,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -5717,8 +5717,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -5768,8 +5768,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -5819,8 +5819,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -5870,8 +5870,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -5921,8 +5921,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -5972,8 +5972,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -6023,8 +6023,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -6074,8 +6074,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -6125,8 +6125,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -6176,8 +6176,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -6227,8 +6227,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -6278,8 +6278,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -6329,8 +6329,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -6380,8 +6380,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -6431,8 +6431,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -6482,8 +6482,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -6533,8 +6533,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -6584,8 +6584,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -6635,8 +6635,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -6686,8 +6686,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -6737,8 +6737,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -6788,8 +6788,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -6839,8 +6839,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -6890,8 +6890,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -6941,8 +6941,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -6992,8 +6992,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -7043,8 +7043,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -7094,8 +7094,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -7145,8 +7145,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -7196,8 +7196,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -7247,8 +7247,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -7298,8 +7298,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -7363,8 +7363,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -7428,8 +7428,8 @@ }, { "span": { - "start": 2895, - "end": 2936 + "start": 2752, + "end": 2793 }, "file": 81 }, @@ -26182,7 +26182,7 @@ "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 = 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 = 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/lasse/aztec3-packages/yarn-project/noir-contracts/src/contracts/ecdsa_account_contract/src/main" + "path": "/mnt/user-data/jan/aztec-packages/yarn-project/noir-contracts/src/contracts/ecdsa_account_contract/src/main" }, "3": { "source": "mod poseidon;\n\n#[foreign(sha256)]\nfn sha256(_input : [u8; N]) -> [u8; 32] {}\n\n#[foreign(blake2s)]\nfn blake2s(_input : [u8; N]) -> [u8; 32] {}\n\nfn pedersen(input : [Field; N]) -> [Field; 2] {\n pedersen_with_separator(input, 0)\n}\n\n#[foreign(pedersen)]\nfn pedersen_with_separator(_input : [Field; N], _separator : u32) -> [Field; 2] {}\n\n#[foreign(hash_to_field_128_security)]\nfn hash_to_field(_input : [Field; N]) -> Field {}\n\n#[foreign(keccak256)]\nfn keccak256(_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(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(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", @@ -26194,47 +26194,47 @@ }, "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 = 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 = 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 = 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 = 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(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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/abi" + "path": "/mnt/user-data/jan/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,\n\n read_requests: BoundedVec,\n\n new_commitments: BoundedVec,\n new_nullifiers: BoundedVec,\n nullified_commitments: BoundedVec,\n\n private_call_stack : BoundedVec,\n public_call_stack : BoundedVec,\n new_l2_to_l1_msgs : BoundedVec,\n\n block_data: HistoricBlockData,\n\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n // encrypted_logs_preimages: Vec,\n // unencrypted_logs_preimages: Vec,\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(&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(&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(\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(\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,\n\n contract_storage_update_requests: BoundedVec,\n contract_storage_read: BoundedVec,\n public_call_stack: BoundedVec,\n\n new_commitments: BoundedVec,\n new_nullifiers: BoundedVec,\n\n new_l2_to_l1_msgs: BoundedVec,\n\n unencrypted_logs_hash: BoundedVec,\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(&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(&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(\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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/context" + "path": "/mnt/user-data/jan/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 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(\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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/log" + "path": "/mnt/user-data/jan/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(\n context: &mut PrivateContext,\n storage_slot: Field,\n note: &mut Note,\n note_interface: NoteInterface,\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(\n context: &mut PublicContext,\n storage_slot: Field,\n note: &mut Note,\n note_interface: NoteInterface,\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(\n context: &mut PrivateContext,\n storage_slot: Field,\n note: Note,\n note_interface: NoteInterface,\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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/note/lifecycle" + "path": "/mnt/user-data/jan/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(\n context: PrivateContext,\n storage_slot: Field,\n note_interface: NoteInterface,\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(\n context: &mut PrivateContext,\n storage_slot: Field,\n note_interface: NoteInterface,\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(\n context: &mut PrivateContext,\n storage_slot: Field,\n note_interface: NoteInterface,\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(\n context: &mut PrivateContext,\n storage_slot: Field,\n note_interface: NoteInterface,\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(\n context: &mut PrivateContext,\n storage_slot: Field,\n note_interface: NoteInterface,\n options: NoteGetterOptions,\n) -> [Option; 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(\n storage_slot: Field,\n note_interface: NoteInterface,\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(\n storage_slot: Field,\n note_interface: NoteInterface,\n options: NoteGetterOptions,\n) -> [Option; 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(\n storage_slot: Field,\n note_interface: NoteInterface,\n options: NoteViewerOptions,\n) -> [Option; 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(\n selects: BoundedVec, N>,\n sorts: BoundedVec, 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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/note/note_getter" + "path": "/mnt/user-data/jan/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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/note/note_hash" + "path": "/mnt/user-data/jan/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(\n note_interface: NoteInterface,\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(\n note_interface: NoteInterface,\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(\n note_interface: NoteInterface,\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(\n note_interface: NoteInterface,\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(\n note_interface: NoteInterface,\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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/note/utils" + "path": "/mnt/user-data/jan/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 {\n storage_slot: Field,\n note_interface: NoteInterface,\n}\n\nimpl ImmutableSingleton {\n fn new(storage_slot: Field, note_interface: NoteInterface) -> 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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/state_vars/immutable_singleton" + "path": "/mnt/user-data/jan/aztec-packages/yarn-project/noir-libs/noir-aztec/src/state_vars/immutable_singleton" }, "55": { "source": "\nstruct BoundedVec {\n storage: [T; MaxLen],\n len: Field,\n}\n\nimpl BoundedVec {\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(&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 = 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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/types/vec" + "path": "/mnt/user-data/jan/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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/oracle/get_public_key" + "path": "/mnt/user-data/jan/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 = 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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/entrypoint" + "path": "/mnt/user-data/jan/aztec-packages/yarn-project/noir-libs/noir-aztec/src/entrypoint" } } } diff --git a/yarn-project/aztec.js/src/abis/schnorr_account_contract.json b/yarn-project/aztec.js/src/abis/schnorr_account_contract.json index f1f476d8e87..d5d13802c56 100644 --- a/yarn-project/aztec.js/src/abis/schnorr_account_contract.json +++ b/yarn-project/aztec.js/src/abis/schnorr_account_contract.json @@ -48,7 +48,7 @@ } } ], - "bytecode": "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", + "bytecode": "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", "verificationKey": "0000000200000800000000740000000f00000003515f3109623eb3c25aa5b16a1a79fd558bac7a7ce62c4560a8c537c77ce80dd339128d1d37b6582ee9e6df9567efb64313471dfa18f520f9ce53161b50dbf7731bc5f900000003515f322bc4cce83a486a92c92fd59bd84e0f92595baa639fc2ed86b00ffa0dfded2a092a669a3bdb7a273a015eda494457cc7ed5236f26cee330c290d45a33b9daa94800000003515f332729426c008c085a81bd34d8ef12dd31e80130339ef99d50013a89e4558eee6d0fa4ffe2ee7b7b62eb92608b2251ac31396a718f9b34978888789042b790a30100000003515f342be6b6824a913eb7a57b03cb1ee7bfb4de02f2f65fe8a4e97baa7766ddb353a82a8a25c49dc63778cd9fe96173f12a2bc77f3682f4c4448f98f1df82c75234a100000003515f351f85760d6ab567465aadc2f180af9eae3800e6958fec96aef53fd8a7b195d7c000c6267a0dd5cfc22b3fe804f53e266069c0e36f51885baec1e7e67650c62e170000000c515f41524954484d455449430d9d0f8ece2aa12012fa21e6e5c859e97bd5704e5c122064a66051294bc5e04213f61f54a0ebdf6fee4d4a6ecf693478191de0c2899bcd8e86a636c8d3eff43400000003515f43224a99d02c86336737c8dd5b746c40d2be6aead8393889a76a18d664029096e90f7fe81adcc92a74350eada9622ac453f49ebac24a066a1f83b394df54dfa0130000000c515f46495845445f42415345060e8a013ed289c2f9fd7473b04f6594b138ddb4b4cf6b901622a14088f04b8d2c83ff74fce56e3d5573b99c7b26d85d5046ce0c6559506acb7a675e7713eb3a00000007515f4c4f4749430721a91cb8da4b917e054f72147e1760cfe0ef3d45090ac0f4961d84ec1996961a25e787b26bd8b50b1a99450f77a424a83513c2b33af268cd253b0587ff50c700000003515f4d05dbd8623b8652511e1eb38d38887a69eceb082f807514f09e127237c5213b401b9325b48c6c225968002318095f89d0ef9cf629b2b7f0172e03bc39aacf6ed800000007515f52414e474504b57a3805e41df328f5ca9aefa40fad5917391543b7b65c6476e60b8f72e9ad07c92f3b3e11c8feae96dedc4b14a6226ef3201244f37cfc1ee5b96781f48d2b000000075349474d415f3125001d1954a18571eaa007144c5a567bb0d2be4def08a8be918b8c05e3b27d312c59ed41e09e144eab5de77ca89a2fd783be702a47c951d3112e3de02ce6e47c000000075349474d415f3223994e6a23618e60fa01c449a7ab88378709197e186d48d604bfb6931ffb15ad11c5ec7a0700570f80088fd5198ab5d5c227f2ad2a455a6edeec024156bb7beb000000075349474d415f3300cda5845f23468a13275d18bddae27c6bb189cf9aa95b6a03a0cb6688c7e8d829639b45cf8607c525cc400b55ebf90205f2f378626dc3406cc59b2d1b474fba000000075349474d415f342d299e7928496ea2d37f10b43afd6a80c90a33b483090d18069ffa275eedb2fc2f82121e8de43dc036d99b478b6227ceef34248939987a19011f065d8b5cef5c0000000010000000000000000100000002000000030000000400000005000000060000000700000008000000090000000a0000000b0000000c0000000d0000000e0000000f" }, { @@ -155,8 +155,8 @@ "3": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -171,8 +171,8 @@ "4": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -187,8 +187,8 @@ "5": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -203,8 +203,8 @@ "6": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -219,8 +219,8 @@ "7": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -235,8 +235,8 @@ "8": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -251,8 +251,8 @@ "9": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -267,8 +267,8 @@ "10": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -283,8 +283,8 @@ "11": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -299,8 +299,8 @@ "12": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -315,8 +315,8 @@ "13": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -331,8 +331,8 @@ "14": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -347,8 +347,8 @@ "15": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -363,8 +363,8 @@ "16": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -379,8 +379,8 @@ "17": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -395,8 +395,8 @@ "18": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -411,8 +411,8 @@ "19": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -427,8 +427,8 @@ "20": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -443,8 +443,8 @@ "21": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -459,8 +459,8 @@ "22": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -475,8 +475,8 @@ "23": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -491,8 +491,8 @@ "24": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -507,8 +507,8 @@ "25": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -523,8 +523,8 @@ "26": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -539,8 +539,8 @@ "27": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -555,8 +555,8 @@ "28": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -571,8 +571,8 @@ "29": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -587,8 +587,8 @@ "30": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -603,8 +603,8 @@ "31": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -619,8 +619,8 @@ "32": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -635,8 +635,8 @@ "34": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -651,8 +651,8 @@ "35": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -667,8 +667,8 @@ "36": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -683,8 +683,8 @@ "37": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -699,8 +699,8 @@ "38": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -715,8 +715,8 @@ "39": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -731,8 +731,8 @@ "40": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -747,8 +747,8 @@ "41": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -763,8 +763,8 @@ "42": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -779,8 +779,8 @@ "43": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -795,8 +795,8 @@ "44": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -811,8 +811,8 @@ "45": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -827,8 +827,8 @@ "46": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -843,8 +843,8 @@ "47": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -859,8 +859,8 @@ "48": [ { "span": { - "start": 3043, - "end": 3096 + "start": 3105, + "end": 3158 }, "file": 0 }, @@ -875,8 +875,8 @@ "50": [ { "span": { - "start": 3255, - "end": 3324 + "start": 3317, + "end": 3386 }, "file": 0 }, @@ -898,8 +898,8 @@ "53": [ { "span": { - "start": 3255, - "end": 3324 + "start": 3317, + "end": 3386 }, "file": 0 }, @@ -942,8 +942,8 @@ "55": [ { "span": { - "start": 3255, - "end": 3324 + "start": 3317, + "end": 3386 }, "file": 0 }, @@ -965,8 +965,8 @@ "56": [ { "span": { - "start": 3255, - "end": 3324 + "start": 3317, + "end": 3386 }, "file": 0 }, @@ -988,8 +988,8 @@ "57": [ { "span": { - "start": 3255, - "end": 3324 + "start": 3317, + "end": 3386 }, "file": 0 }, @@ -1011,8 +1011,8 @@ "58": [ { "span": { - "start": 3255, - "end": 3324 + "start": 3317, + "end": 3386 }, "file": 0 }, @@ -1034,8 +1034,8 @@ "59": [ { "span": { - "start": 3255, - "end": 3324 + "start": 3317, + "end": 3386 }, "file": 0 }, @@ -1057,8 +1057,8 @@ "60": [ { "span": { - "start": 3473, - "end": 3492 + "start": 3535, + "end": 3554 }, "file": 0 }, @@ -1073,8 +1073,8 @@ "62": [ { "span": { - "start": 3473, - "end": 3492 + "start": 3535, + "end": 3554 }, "file": 0 }, @@ -1089,8 +1089,8 @@ "63": [ { "span": { - "start": 3473, - "end": 3492 + "start": 3535, + "end": 3554 }, "file": 0 }, @@ -1105,8 +1105,8 @@ "64": [ { "span": { - "start": 3473, - "end": 3492 + "start": 3535, + "end": 3554 }, "file": 0 }, @@ -1121,8 +1121,8 @@ "65": [ { "span": { - "start": 3473, - "end": 3492 + "start": 3535, + "end": 3554 }, "file": 0 }, @@ -1137,8 +1137,8 @@ "66": [ { "span": { - "start": 3473, - "end": 3492 + "start": 3535, + "end": 3554 }, "file": 0 }, @@ -1153,8 +1153,8 @@ "67": [ { "span": { - "start": 3344, - "end": 3541 + "start": 3406, + "end": 3603 }, "file": 0 }, @@ -1173,8 +1173,8 @@ "73": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1189,8 +1189,8 @@ "74": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1205,8 +1205,8 @@ "75": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1221,8 +1221,8 @@ "76": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1237,8 +1237,8 @@ "77": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1253,8 +1253,8 @@ "78": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1269,8 +1269,8 @@ "79": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1285,8 +1285,8 @@ "80": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1301,8 +1301,8 @@ "81": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1317,8 +1317,8 @@ "82": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1333,8 +1333,8 @@ "83": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1349,8 +1349,8 @@ "84": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1365,8 +1365,8 @@ "85": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1381,8 +1381,8 @@ "86": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1397,8 +1397,8 @@ "87": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1413,8 +1413,8 @@ "88": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1429,8 +1429,8 @@ "89": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1445,8 +1445,8 @@ "90": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1461,8 +1461,8 @@ "91": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1477,8 +1477,8 @@ "93": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1493,8 +1493,8 @@ "94": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1509,8 +1509,8 @@ "95": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1525,8 +1525,8 @@ "96": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1541,8 +1541,8 @@ "97": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1557,8 +1557,8 @@ "98": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1573,8 +1573,8 @@ "99": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1589,8 +1589,8 @@ "100": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1605,8 +1605,8 @@ "101": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1621,8 +1621,8 @@ "102": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1637,8 +1637,8 @@ "103": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1653,8 +1653,8 @@ "104": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1669,8 +1669,8 @@ "105": [ { "span": { - "start": 1906, - "end": 1933 + "start": 1936, + "end": 1963 }, "file": 0 }, @@ -1685,8 +1685,8 @@ "107": [ { "span": { - "start": 2042, - "end": 2090 + "start": 2072, + "end": 2120 }, "file": 0 }, @@ -1708,8 +1708,8 @@ "108": [ { "span": { - "start": 2042, - "end": 2090 + "start": 2072, + "end": 2120 }, "file": 0 }, @@ -1738,8 +1738,8 @@ "109": [ { "span": { - "start": 2042, - "end": 2090 + "start": 2072, + "end": 2120 }, "file": 0 }, @@ -1768,8 +1768,8 @@ "110": [ { "span": { - "start": 2042, - "end": 2090 + "start": 2072, + "end": 2120 }, "file": 0 }, @@ -1798,8 +1798,8 @@ "111": [ { "span": { - "start": 2042, - "end": 2090 + "start": 2072, + "end": 2120 }, "file": 0 }, @@ -1828,8 +1828,8 @@ "112": [ { "span": { - "start": 2042, - "end": 2090 + "start": 2072, + "end": 2120 }, "file": 0 }, @@ -1858,8 +1858,8 @@ "113": [ { "span": { - "start": 2042, - "end": 2090 + "start": 2072, + "end": 2120 }, "file": 0 }, @@ -1888,8 +1888,8 @@ "114": [ { "span": { - "start": 2042, - "end": 2090 + "start": 2072, + "end": 2120 }, "file": 0 }, @@ -1918,8 +1918,8 @@ "115": [ { "span": { - "start": 2042, - "end": 2090 + "start": 2072, + "end": 2120 }, "file": 0 }, @@ -1948,8 +1948,8 @@ "116": [ { "span": { - "start": 2042, - "end": 2090 + "start": 2072, + "end": 2120 }, "file": 0 }, @@ -1978,8 +1978,8 @@ "117": [ { "span": { - "start": 2042, - "end": 2090 + "start": 2072, + "end": 2120 }, "file": 0 }, @@ -2008,8 +2008,8 @@ "118": [ { "span": { - "start": 2042, - "end": 2090 + "start": 2072, + "end": 2120 }, "file": 0 }, @@ -2038,8 +2038,8 @@ "119": [ { "span": { - "start": 2042, - "end": 2090 + "start": 2072, + "end": 2120 }, "file": 0 }, @@ -2068,8 +2068,8 @@ "120": [ { "span": { - "start": 2042, - "end": 2090 + "start": 2072, + "end": 2120 }, "file": 0 }, @@ -2098,8 +2098,8 @@ "127": [ { "span": { - "start": 2042, - "end": 2090 + "start": 2072, + "end": 2120 }, "file": 0 }, @@ -2142,8 +2142,8 @@ "129": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2158,8 +2158,8 @@ "130": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2174,8 +2174,8 @@ "131": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2190,8 +2190,8 @@ "132": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2206,8 +2206,8 @@ "133": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2222,8 +2222,8 @@ "134": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2238,8 +2238,8 @@ "135": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2254,8 +2254,8 @@ "136": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2270,8 +2270,8 @@ "137": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2286,8 +2286,8 @@ "138": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2302,8 +2302,8 @@ "139": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2318,8 +2318,8 @@ "140": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2334,8 +2334,8 @@ "141": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2350,8 +2350,8 @@ "142": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2366,8 +2366,8 @@ "143": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2382,8 +2382,8 @@ "144": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2398,8 +2398,8 @@ "145": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2414,8 +2414,8 @@ "146": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2430,8 +2430,8 @@ "147": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2446,8 +2446,8 @@ "148": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2462,8 +2462,8 @@ "149": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2478,8 +2478,8 @@ "150": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2494,8 +2494,8 @@ "151": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2510,8 +2510,8 @@ "152": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2526,8 +2526,8 @@ "153": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2542,8 +2542,8 @@ "154": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2558,8 +2558,8 @@ "155": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2574,8 +2574,8 @@ "156": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2590,8 +2590,8 @@ "157": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2606,8 +2606,8 @@ "158": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2622,8 +2622,8 @@ "159": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2638,8 +2638,8 @@ "160": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2654,8 +2654,8 @@ "161": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2670,8 +2670,8 @@ "162": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2686,8 +2686,8 @@ "163": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2702,8 +2702,8 @@ "164": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2718,8 +2718,8 @@ "165": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2734,8 +2734,8 @@ "166": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2750,8 +2750,8 @@ "167": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2766,8 +2766,8 @@ "168": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2782,8 +2782,8 @@ "169": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2798,8 +2798,8 @@ "170": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2814,8 +2814,8 @@ "171": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2830,8 +2830,8 @@ "172": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2846,8 +2846,8 @@ "173": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2862,8 +2862,8 @@ "174": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2878,8 +2878,8 @@ "175": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2894,8 +2894,8 @@ "176": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2910,8 +2910,8 @@ "177": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2926,8 +2926,8 @@ "178": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2942,8 +2942,8 @@ "179": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2958,8 +2958,8 @@ "180": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2974,8 +2974,8 @@ "181": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -2990,8 +2990,8 @@ "182": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -3006,8 +3006,8 @@ "183": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -3022,8 +3022,8 @@ "184": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -3038,8 +3038,8 @@ "185": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -3054,8 +3054,8 @@ "186": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -3070,8 +3070,8 @@ "187": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -3086,8 +3086,8 @@ "188": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -3102,8 +3102,8 @@ "189": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -3118,8 +3118,8 @@ "190": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -3134,8 +3134,8 @@ "191": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -3150,8 +3150,8 @@ "192": [ { "span": { - "start": 2380, - "end": 2408 + "start": 2410, + "end": 2438 }, "file": 0 }, @@ -3166,8 +3166,8 @@ "194": [ { "span": { - "start": 2589, - "end": 2608 + "start": 2619, + "end": 2638 }, "file": 0 } @@ -3175,8 +3175,8 @@ "195": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3191,8 +3191,8 @@ "196": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3207,8 +3207,8 @@ "197": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3223,8 +3223,8 @@ "198": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3246,8 +3246,8 @@ "199": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3269,8 +3269,8 @@ "200": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3292,8 +3292,8 @@ "201": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3315,8 +3315,8 @@ "202": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3338,8 +3338,8 @@ "203": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3361,8 +3361,8 @@ "204": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3384,8 +3384,8 @@ "205": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3407,8 +3407,8 @@ "206": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3430,8 +3430,8 @@ "207": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3453,8 +3453,8 @@ "208": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3476,8 +3476,8 @@ "209": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3499,8 +3499,8 @@ "210": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3522,8 +3522,8 @@ "211": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3545,8 +3545,8 @@ "212": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3568,8 +3568,8 @@ "213": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3591,8 +3591,8 @@ "214": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3614,8 +3614,8 @@ "215": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3637,8 +3637,8 @@ "216": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3660,8 +3660,8 @@ "217": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3683,8 +3683,8 @@ "218": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3706,8 +3706,8 @@ "219": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3729,8 +3729,8 @@ "220": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3752,8 +3752,8 @@ "221": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3775,8 +3775,8 @@ "222": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3798,8 +3798,8 @@ "223": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3821,8 +3821,8 @@ "224": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3844,8 +3844,8 @@ "225": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3867,8 +3867,8 @@ "226": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3890,8 +3890,8 @@ "227": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3913,8 +3913,8 @@ "228": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3936,8 +3936,8 @@ "229": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3959,8 +3959,8 @@ "230": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -3982,8 +3982,8 @@ "231": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4005,8 +4005,8 @@ "232": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4028,8 +4028,8 @@ "233": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4051,8 +4051,8 @@ "234": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4074,8 +4074,8 @@ "235": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4097,8 +4097,8 @@ "236": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4120,8 +4120,8 @@ "237": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4143,8 +4143,8 @@ "238": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4166,8 +4166,8 @@ "239": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4189,8 +4189,8 @@ "240": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4212,8 +4212,8 @@ "241": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4235,8 +4235,8 @@ "242": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4258,8 +4258,8 @@ "243": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4281,8 +4281,8 @@ "244": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4304,8 +4304,8 @@ "245": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4327,8 +4327,8 @@ "246": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4350,8 +4350,8 @@ "247": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4373,8 +4373,8 @@ "248": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4396,8 +4396,8 @@ "249": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4419,8 +4419,8 @@ "250": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4442,8 +4442,8 @@ "251": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4465,8 +4465,8 @@ "252": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4488,8 +4488,8 @@ "253": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4511,8 +4511,8 @@ "254": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4534,8 +4534,8 @@ "255": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4557,8 +4557,8 @@ "256": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4580,8 +4580,8 @@ "257": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4603,8 +4603,8 @@ "258": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4626,8 +4626,8 @@ "259": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4649,8 +4649,8 @@ "260": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4672,8 +4672,8 @@ "261": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4695,8 +4695,8 @@ "262": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4718,8 +4718,8 @@ "263": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4741,8 +4741,8 @@ "264": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4764,8 +4764,8 @@ "265": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4787,8 +4787,8 @@ "266": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4810,8 +4810,8 @@ "267": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4833,8 +4833,8 @@ "268": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4856,8 +4856,8 @@ "269": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4879,8 +4879,8 @@ "270": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4902,8 +4902,8 @@ "271": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4925,8 +4925,8 @@ "272": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4948,8 +4948,8 @@ "273": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4971,8 +4971,8 @@ "274": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -4994,8 +4994,8 @@ "275": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5017,8 +5017,8 @@ "276": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5040,8 +5040,8 @@ "277": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5063,8 +5063,8 @@ "278": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5086,8 +5086,8 @@ "279": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5109,8 +5109,8 @@ "280": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5132,8 +5132,8 @@ "281": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5155,8 +5155,8 @@ "282": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5178,8 +5178,8 @@ "283": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5201,8 +5201,8 @@ "284": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5224,8 +5224,8 @@ "285": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5247,8 +5247,8 @@ "286": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5270,8 +5270,8 @@ "287": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5293,8 +5293,8 @@ "288": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5316,8 +5316,8 @@ "289": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5339,8 +5339,8 @@ "290": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5362,8 +5362,8 @@ "291": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5385,8 +5385,8 @@ "292": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5408,8 +5408,8 @@ "293": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5431,8 +5431,8 @@ "294": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5454,8 +5454,8 @@ "295": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5477,8 +5477,8 @@ "296": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5500,8 +5500,8 @@ "297": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5523,8 +5523,8 @@ "298": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5546,8 +5546,8 @@ "299": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5569,8 +5569,8 @@ "300": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5592,8 +5592,8 @@ "301": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5615,8 +5615,8 @@ "302": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5638,8 +5638,8 @@ "303": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5661,8 +5661,8 @@ "304": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5684,8 +5684,8 @@ "305": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5707,8 +5707,8 @@ "306": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5730,8 +5730,8 @@ "307": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5753,8 +5753,8 @@ "308": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5776,8 +5776,8 @@ "309": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5799,8 +5799,8 @@ "310": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5822,8 +5822,8 @@ "311": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5845,8 +5845,8 @@ "312": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5868,8 +5868,8 @@ "313": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5891,8 +5891,8 @@ "320": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5907,8 +5907,8 @@ "321": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5923,8 +5923,8 @@ "322": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5939,8 +5939,8 @@ "323": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5962,8 +5962,8 @@ "324": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -5985,8 +5985,8 @@ "325": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6008,8 +6008,8 @@ "326": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6031,8 +6031,8 @@ "327": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6054,8 +6054,8 @@ "328": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6077,8 +6077,8 @@ "329": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6100,8 +6100,8 @@ "330": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6123,8 +6123,8 @@ "331": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6146,8 +6146,8 @@ "332": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6169,8 +6169,8 @@ "333": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6192,8 +6192,8 @@ "334": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6215,8 +6215,8 @@ "335": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6238,8 +6238,8 @@ "336": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6261,8 +6261,8 @@ "337": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6284,8 +6284,8 @@ "338": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6307,8 +6307,8 @@ "339": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6330,8 +6330,8 @@ "340": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6353,8 +6353,8 @@ "341": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6376,8 +6376,8 @@ "342": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6399,8 +6399,8 @@ "343": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6422,8 +6422,8 @@ "344": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6445,8 +6445,8 @@ "345": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6468,8 +6468,8 @@ "346": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6491,8 +6491,8 @@ "347": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6514,8 +6514,8 @@ "348": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6537,8 +6537,8 @@ "349": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6560,8 +6560,8 @@ "350": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6583,8 +6583,8 @@ "351": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6606,8 +6606,8 @@ "352": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6629,8 +6629,8 @@ "353": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6652,8 +6652,8 @@ "354": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6675,8 +6675,8 @@ "355": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6698,8 +6698,8 @@ "356": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6721,8 +6721,8 @@ "357": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6744,8 +6744,8 @@ "358": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6767,8 +6767,8 @@ "359": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6790,8 +6790,8 @@ "360": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6813,8 +6813,8 @@ "361": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6836,8 +6836,8 @@ "362": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6859,8 +6859,8 @@ "363": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6882,8 +6882,8 @@ "364": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6905,8 +6905,8 @@ "365": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6928,8 +6928,8 @@ "366": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6951,8 +6951,8 @@ "367": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6974,8 +6974,8 @@ "368": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -6997,8 +6997,8 @@ "369": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7020,8 +7020,8 @@ "370": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7043,8 +7043,8 @@ "371": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7066,8 +7066,8 @@ "372": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7089,8 +7089,8 @@ "373": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7112,8 +7112,8 @@ "374": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7135,8 +7135,8 @@ "375": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7158,8 +7158,8 @@ "376": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7181,8 +7181,8 @@ "377": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7204,8 +7204,8 @@ "378": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7227,8 +7227,8 @@ "379": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7250,8 +7250,8 @@ "380": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7273,8 +7273,8 @@ "381": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7296,8 +7296,8 @@ "382": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7319,8 +7319,8 @@ "383": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7342,8 +7342,8 @@ "384": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7365,8 +7365,8 @@ "385": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7388,8 +7388,8 @@ "386": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7411,8 +7411,8 @@ "387": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7434,8 +7434,8 @@ "388": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7457,8 +7457,8 @@ "389": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7480,8 +7480,8 @@ "390": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7503,8 +7503,8 @@ "391": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7526,8 +7526,8 @@ "392": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7549,8 +7549,8 @@ "393": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7572,8 +7572,8 @@ "394": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7595,8 +7595,8 @@ "395": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7618,8 +7618,8 @@ "396": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7641,8 +7641,8 @@ "397": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7664,8 +7664,8 @@ "398": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7687,8 +7687,8 @@ "399": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7710,8 +7710,8 @@ "400": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7733,8 +7733,8 @@ "401": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7756,8 +7756,8 @@ "402": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7779,8 +7779,8 @@ "403": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7802,8 +7802,8 @@ "404": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7825,8 +7825,8 @@ "405": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7848,8 +7848,8 @@ "406": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7871,8 +7871,8 @@ "407": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7894,8 +7894,8 @@ "408": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7917,8 +7917,8 @@ "409": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7940,8 +7940,8 @@ "410": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7963,8 +7963,8 @@ "411": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -7986,8 +7986,8 @@ "412": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8009,8 +8009,8 @@ "413": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8032,8 +8032,8 @@ "414": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8055,8 +8055,8 @@ "415": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8078,8 +8078,8 @@ "416": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8101,8 +8101,8 @@ "417": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8124,8 +8124,8 @@ "418": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8147,8 +8147,8 @@ "419": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8170,8 +8170,8 @@ "420": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8193,8 +8193,8 @@ "421": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8216,8 +8216,8 @@ "422": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8239,8 +8239,8 @@ "423": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8262,8 +8262,8 @@ "424": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8285,8 +8285,8 @@ "425": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8308,8 +8308,8 @@ "426": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8331,8 +8331,8 @@ "427": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8354,8 +8354,8 @@ "428": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8377,8 +8377,8 @@ "429": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8400,8 +8400,8 @@ "430": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8423,8 +8423,8 @@ "431": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8446,8 +8446,8 @@ "432": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8469,8 +8469,8 @@ "433": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8492,8 +8492,8 @@ "434": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8515,8 +8515,8 @@ "435": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8538,8 +8538,8 @@ "436": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8561,8 +8561,8 @@ "437": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8584,8 +8584,8 @@ "438": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8607,8 +8607,8 @@ "444": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8637,8 +8637,8 @@ "445": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8667,8 +8667,8 @@ "446": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8697,8 +8697,8 @@ "447": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8727,8 +8727,8 @@ "448": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8757,8 +8757,8 @@ "449": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8787,8 +8787,8 @@ "450": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8817,8 +8817,8 @@ "451": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8847,8 +8847,8 @@ "452": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8877,8 +8877,8 @@ "453": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8907,8 +8907,8 @@ "454": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8937,8 +8937,8 @@ "455": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8967,8 +8967,8 @@ "456": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -8997,8 +8997,8 @@ "457": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9027,8 +9027,8 @@ "458": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9057,8 +9057,8 @@ "459": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9087,8 +9087,8 @@ "460": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9117,8 +9117,8 @@ "461": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9147,8 +9147,8 @@ "462": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9177,8 +9177,8 @@ "463": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9207,8 +9207,8 @@ "464": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9237,8 +9237,8 @@ "465": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9267,8 +9267,8 @@ "466": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9297,8 +9297,8 @@ "467": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9327,8 +9327,8 @@ "468": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9357,8 +9357,8 @@ "469": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9387,8 +9387,8 @@ "470": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9417,8 +9417,8 @@ "472": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9447,8 +9447,8 @@ "487": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9463,8 +9463,8 @@ "488": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9479,8 +9479,8 @@ "489": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9495,8 +9495,8 @@ "490": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9518,8 +9518,8 @@ "491": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9541,8 +9541,8 @@ "492": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9564,8 +9564,8 @@ "493": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9587,8 +9587,8 @@ "494": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9610,8 +9610,8 @@ "495": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9633,8 +9633,8 @@ "496": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9656,8 +9656,8 @@ "497": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9679,8 +9679,8 @@ "498": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9702,8 +9702,8 @@ "499": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9725,8 +9725,8 @@ "500": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9748,8 +9748,8 @@ "501": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9771,8 +9771,8 @@ "502": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9794,8 +9794,8 @@ "503": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9817,8 +9817,8 @@ "504": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9840,8 +9840,8 @@ "505": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9863,8 +9863,8 @@ "506": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9886,8 +9886,8 @@ "507": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9909,8 +9909,8 @@ "508": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9932,8 +9932,8 @@ "509": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9955,8 +9955,8 @@ "510": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -9978,8 +9978,8 @@ "511": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10001,8 +10001,8 @@ "512": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10024,8 +10024,8 @@ "513": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10047,8 +10047,8 @@ "514": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10070,8 +10070,8 @@ "515": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10093,8 +10093,8 @@ "516": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10116,8 +10116,8 @@ "517": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10139,8 +10139,8 @@ "518": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10162,8 +10162,8 @@ "519": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10185,8 +10185,8 @@ "520": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10208,8 +10208,8 @@ "521": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10231,8 +10231,8 @@ "522": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10254,8 +10254,8 @@ "523": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10277,8 +10277,8 @@ "524": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10300,8 +10300,8 @@ "525": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10323,8 +10323,8 @@ "526": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10346,8 +10346,8 @@ "527": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10369,8 +10369,8 @@ "528": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10392,8 +10392,8 @@ "529": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10415,8 +10415,8 @@ "530": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10438,8 +10438,8 @@ "531": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10461,8 +10461,8 @@ "532": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10484,8 +10484,8 @@ "533": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10507,8 +10507,8 @@ "534": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10530,8 +10530,8 @@ "535": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10553,8 +10553,8 @@ "536": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10576,8 +10576,8 @@ "537": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10599,8 +10599,8 @@ "538": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10622,8 +10622,8 @@ "539": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10645,8 +10645,8 @@ "540": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10668,8 +10668,8 @@ "541": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10691,8 +10691,8 @@ "542": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10714,8 +10714,8 @@ "543": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10737,8 +10737,8 @@ "544": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10760,8 +10760,8 @@ "545": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10783,8 +10783,8 @@ "546": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10806,8 +10806,8 @@ "547": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10829,8 +10829,8 @@ "548": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10852,8 +10852,8 @@ "549": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10875,8 +10875,8 @@ "550": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10898,8 +10898,8 @@ "551": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10921,8 +10921,8 @@ "552": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10944,8 +10944,8 @@ "553": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10967,8 +10967,8 @@ "554": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -10990,8 +10990,8 @@ "555": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11013,8 +11013,8 @@ "556": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11036,8 +11036,8 @@ "557": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11059,8 +11059,8 @@ "558": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11082,8 +11082,8 @@ "559": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11105,8 +11105,8 @@ "560": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11128,8 +11128,8 @@ "561": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11151,8 +11151,8 @@ "562": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11174,8 +11174,8 @@ "563": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11197,8 +11197,8 @@ "564": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11220,8 +11220,8 @@ "565": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11243,8 +11243,8 @@ "566": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11266,8 +11266,8 @@ "567": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11289,8 +11289,8 @@ "568": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11312,8 +11312,8 @@ "569": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11335,8 +11335,8 @@ "570": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11358,8 +11358,8 @@ "571": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11381,8 +11381,8 @@ "572": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11404,8 +11404,8 @@ "573": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11427,8 +11427,8 @@ "574": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11450,8 +11450,8 @@ "575": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11473,8 +11473,8 @@ "576": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11496,8 +11496,8 @@ "577": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11519,8 +11519,8 @@ "578": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11542,8 +11542,8 @@ "579": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11565,8 +11565,8 @@ "580": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11588,8 +11588,8 @@ "581": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11611,8 +11611,8 @@ "582": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11634,8 +11634,8 @@ "583": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11657,8 +11657,8 @@ "584": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11680,8 +11680,8 @@ "585": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11703,8 +11703,8 @@ "586": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11726,8 +11726,8 @@ "587": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11749,8 +11749,8 @@ "588": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11772,8 +11772,8 @@ "589": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11795,8 +11795,8 @@ "590": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11818,8 +11818,8 @@ "591": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11841,8 +11841,8 @@ "592": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11864,8 +11864,8 @@ "593": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11887,8 +11887,8 @@ "596": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11931,8 +11931,8 @@ "597": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -11975,8 +11975,8 @@ "598": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12019,8 +12019,8 @@ "600": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12063,8 +12063,8 @@ "601": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12107,8 +12107,8 @@ "602": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12151,8 +12151,8 @@ "604": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12195,8 +12195,8 @@ "605": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12239,8 +12239,8 @@ "606": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12283,8 +12283,8 @@ "608": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12327,8 +12327,8 @@ "609": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12371,8 +12371,8 @@ "610": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12415,8 +12415,8 @@ "612": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12459,8 +12459,8 @@ "613": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12503,8 +12503,8 @@ "614": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12547,8 +12547,8 @@ "616": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12591,8 +12591,8 @@ "617": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12635,8 +12635,8 @@ "618": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12679,8 +12679,8 @@ "620": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12723,8 +12723,8 @@ "621": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12767,8 +12767,8 @@ "622": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12811,8 +12811,8 @@ "624": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12855,8 +12855,8 @@ "625": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12899,8 +12899,8 @@ "626": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12943,8 +12943,8 @@ "628": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -12987,8 +12987,8 @@ "629": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13031,8 +13031,8 @@ "631": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13075,8 +13075,8 @@ "632": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13119,8 +13119,8 @@ "634": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13163,8 +13163,8 @@ "635": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13207,8 +13207,8 @@ "637": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13251,8 +13251,8 @@ "638": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13295,8 +13295,8 @@ "640": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13339,8 +13339,8 @@ "641": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13383,8 +13383,8 @@ "643": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13427,8 +13427,8 @@ "644": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13471,8 +13471,8 @@ "646": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13515,8 +13515,8 @@ "647": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13559,8 +13559,8 @@ "649": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13603,8 +13603,8 @@ "650": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13647,8 +13647,8 @@ "652": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13684,8 +13684,8 @@ "653": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13721,8 +13721,8 @@ "654": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13758,8 +13758,8 @@ "655": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13795,8 +13795,8 @@ "656": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13832,8 +13832,8 @@ "657": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13869,8 +13869,8 @@ "658": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13906,8 +13906,8 @@ "659": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13943,8 +13943,8 @@ "660": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -13980,8 +13980,8 @@ "661": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14017,8 +14017,8 @@ "662": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14054,8 +14054,8 @@ "663": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14091,8 +14091,8 @@ "664": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14128,8 +14128,8 @@ "665": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14165,8 +14165,8 @@ "666": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14202,8 +14202,8 @@ "667": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14239,8 +14239,8 @@ "668": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14276,8 +14276,8 @@ "669": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14313,8 +14313,8 @@ "670": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14350,8 +14350,8 @@ "671": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14387,8 +14387,8 @@ "672": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14424,8 +14424,8 @@ "673": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14461,8 +14461,8 @@ "674": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14498,8 +14498,8 @@ "675": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14535,8 +14535,8 @@ "676": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14572,8 +14572,8 @@ "677": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14609,8 +14609,8 @@ "678": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14646,8 +14646,8 @@ "679": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14683,8 +14683,8 @@ "680": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14720,8 +14720,8 @@ "684": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14736,8 +14736,8 @@ "685": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14752,8 +14752,8 @@ "686": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14768,8 +14768,8 @@ "687": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14791,8 +14791,8 @@ "688": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14814,8 +14814,8 @@ "689": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14837,8 +14837,8 @@ "690": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14860,8 +14860,8 @@ "691": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14883,8 +14883,8 @@ "692": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14906,8 +14906,8 @@ "693": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14929,8 +14929,8 @@ "694": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14952,8 +14952,8 @@ "695": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14975,8 +14975,8 @@ "696": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -14998,8 +14998,8 @@ "697": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15021,8 +15021,8 @@ "698": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15044,8 +15044,8 @@ "699": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15067,8 +15067,8 @@ "700": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15090,8 +15090,8 @@ "701": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15113,8 +15113,8 @@ "702": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15136,8 +15136,8 @@ "703": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15159,8 +15159,8 @@ "704": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15182,8 +15182,8 @@ "705": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15205,8 +15205,8 @@ "706": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15228,8 +15228,8 @@ "707": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15251,8 +15251,8 @@ "708": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15274,8 +15274,8 @@ "709": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15297,8 +15297,8 @@ "710": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15320,8 +15320,8 @@ "711": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15343,8 +15343,8 @@ "712": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15366,8 +15366,8 @@ "713": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15389,8 +15389,8 @@ "714": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15412,8 +15412,8 @@ "715": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15435,8 +15435,8 @@ "716": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15458,8 +15458,8 @@ "717": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15481,8 +15481,8 @@ "718": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15504,8 +15504,8 @@ "719": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15527,8 +15527,8 @@ "720": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15550,8 +15550,8 @@ "721": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15573,8 +15573,8 @@ "722": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15596,8 +15596,8 @@ "723": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15619,8 +15619,8 @@ "724": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15642,8 +15642,8 @@ "725": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15665,8 +15665,8 @@ "726": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15688,8 +15688,8 @@ "727": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15711,8 +15711,8 @@ "728": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15734,8 +15734,8 @@ "729": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15757,8 +15757,8 @@ "730": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15780,8 +15780,8 @@ "731": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15803,8 +15803,8 @@ "732": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15826,8 +15826,8 @@ "733": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15849,8 +15849,8 @@ "734": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15872,8 +15872,8 @@ "735": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15895,8 +15895,8 @@ "736": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15918,8 +15918,8 @@ "737": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15941,8 +15941,8 @@ "738": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15964,8 +15964,8 @@ "739": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -15987,8 +15987,8 @@ "740": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16010,8 +16010,8 @@ "741": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16033,8 +16033,8 @@ "742": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16056,8 +16056,8 @@ "743": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16079,8 +16079,8 @@ "744": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16102,8 +16102,8 @@ "745": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16125,8 +16125,8 @@ "746": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16148,8 +16148,8 @@ "747": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16171,8 +16171,8 @@ "748": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16194,8 +16194,8 @@ "749": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16217,8 +16217,8 @@ "750": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16240,8 +16240,8 @@ "751": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16263,8 +16263,8 @@ "752": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16286,8 +16286,8 @@ "753": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16309,8 +16309,8 @@ "754": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16332,8 +16332,8 @@ "755": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16355,8 +16355,8 @@ "756": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16378,8 +16378,8 @@ "757": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16401,8 +16401,8 @@ "758": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16424,8 +16424,8 @@ "759": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16447,8 +16447,8 @@ "760": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16470,8 +16470,8 @@ "761": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16493,8 +16493,8 @@ "762": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16516,8 +16516,8 @@ "763": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16539,8 +16539,8 @@ "764": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16562,8 +16562,8 @@ "765": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16585,8 +16585,8 @@ "766": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16608,8 +16608,8 @@ "767": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16631,8 +16631,8 @@ "768": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16654,8 +16654,8 @@ "769": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16677,8 +16677,8 @@ "770": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16700,8 +16700,8 @@ "771": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16723,8 +16723,8 @@ "772": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16746,8 +16746,8 @@ "773": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16769,8 +16769,8 @@ "774": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16792,8 +16792,8 @@ "775": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16815,8 +16815,8 @@ "776": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16838,8 +16838,8 @@ "777": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16861,8 +16861,8 @@ "778": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16884,8 +16884,8 @@ "779": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16907,8 +16907,8 @@ "780": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16930,8 +16930,8 @@ "781": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16953,8 +16953,8 @@ "782": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16976,8 +16976,8 @@ "783": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -16999,8 +16999,8 @@ "784": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17022,8 +17022,8 @@ "785": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17045,8 +17045,8 @@ "786": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17068,8 +17068,8 @@ "787": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17091,8 +17091,8 @@ "788": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17114,8 +17114,8 @@ "789": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17137,8 +17137,8 @@ "790": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17160,8 +17160,8 @@ "793": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17204,8 +17204,8 @@ "794": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17248,8 +17248,8 @@ "795": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17292,8 +17292,8 @@ "797": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17336,8 +17336,8 @@ "798": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17380,8 +17380,8 @@ "799": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17424,8 +17424,8 @@ "801": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17468,8 +17468,8 @@ "802": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17512,8 +17512,8 @@ "803": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17556,8 +17556,8 @@ "805": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17600,8 +17600,8 @@ "806": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17644,8 +17644,8 @@ "807": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17688,8 +17688,8 @@ "809": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17732,8 +17732,8 @@ "810": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17776,8 +17776,8 @@ "811": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17820,8 +17820,8 @@ "813": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17864,8 +17864,8 @@ "814": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17908,8 +17908,8 @@ "815": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17952,8 +17952,8 @@ "817": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -17996,8 +17996,8 @@ "818": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18040,8 +18040,8 @@ "819": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18084,8 +18084,8 @@ "821": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18128,8 +18128,8 @@ "822": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18172,8 +18172,8 @@ "823": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18216,8 +18216,8 @@ "825": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18260,8 +18260,8 @@ "826": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18304,8 +18304,8 @@ "828": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18348,8 +18348,8 @@ "829": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18392,8 +18392,8 @@ "831": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18436,8 +18436,8 @@ "832": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18480,8 +18480,8 @@ "834": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18524,8 +18524,8 @@ "835": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18568,8 +18568,8 @@ "837": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18612,8 +18612,8 @@ "838": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18656,8 +18656,8 @@ "840": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18700,8 +18700,8 @@ "841": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18744,8 +18744,8 @@ "843": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18788,8 +18788,8 @@ "844": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18832,8 +18832,8 @@ "846": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18876,8 +18876,8 @@ "847": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18920,8 +18920,8 @@ "849": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18957,8 +18957,8 @@ "850": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -18994,8 +18994,8 @@ "851": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19031,8 +19031,8 @@ "852": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19068,8 +19068,8 @@ "853": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19105,8 +19105,8 @@ "854": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19142,8 +19142,8 @@ "855": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19179,8 +19179,8 @@ "856": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19216,8 +19216,8 @@ "857": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19253,8 +19253,8 @@ "858": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19290,8 +19290,8 @@ "859": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19327,8 +19327,8 @@ "860": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19364,8 +19364,8 @@ "861": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19401,8 +19401,8 @@ "862": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19438,8 +19438,8 @@ "863": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19475,8 +19475,8 @@ "864": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19512,8 +19512,8 @@ "865": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19549,8 +19549,8 @@ "866": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19586,8 +19586,8 @@ "867": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19623,8 +19623,8 @@ "868": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19660,8 +19660,8 @@ "869": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19697,8 +19697,8 @@ "870": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19734,8 +19734,8 @@ "871": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19771,8 +19771,8 @@ "872": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19808,8 +19808,8 @@ "873": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19845,8 +19845,8 @@ "874": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19882,8 +19882,8 @@ "875": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19919,8 +19919,8 @@ "876": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19956,8 +19956,8 @@ "877": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -19993,8 +19993,8 @@ "880": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20023,8 +20023,8 @@ "881": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20053,8 +20053,8 @@ "882": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20083,8 +20083,8 @@ "883": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20113,8 +20113,8 @@ "884": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20143,8 +20143,8 @@ "885": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20173,8 +20173,8 @@ "886": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20203,8 +20203,8 @@ "887": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20233,8 +20233,8 @@ "888": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20263,8 +20263,8 @@ "889": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20293,8 +20293,8 @@ "890": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20323,8 +20323,8 @@ "891": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20353,8 +20353,8 @@ "892": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20383,8 +20383,8 @@ "893": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20413,8 +20413,8 @@ "894": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20443,8 +20443,8 @@ "895": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20473,8 +20473,8 @@ "896": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20503,8 +20503,8 @@ "897": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20533,8 +20533,8 @@ "898": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20563,8 +20563,8 @@ "899": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20593,8 +20593,8 @@ "900": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20623,8 +20623,8 @@ "901": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20653,8 +20653,8 @@ "902": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20683,8 +20683,8 @@ "903": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20713,8 +20713,8 @@ "904": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20743,8 +20743,8 @@ "905": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20773,8 +20773,8 @@ "906": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20803,8 +20803,8 @@ "908": [ { "span": { - "start": 2646, - "end": 2680 + "start": 2708, + "end": 2742 }, "file": 0 }, @@ -20835,8 +20835,8 @@ ], "fileMap": { "0": { - "source": "mod storage;\nmod public_key_note;\n\n// Account contract that uses Schnorr signatures for authentication.\n// The signing key is stored in an immutable private note and should be different from the encryption/nullifying key.\ncontract SchnorrAccount {\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::private_call_stack_item::PrivateCallStackItem;\n use dep::aztec::public_call_stack_item::PublicCallStackItem;\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::note::utils as note_utils;\n use dep::aztec::note::note_header::NoteHeader;\n use dep::aztec::constants_gen::MAX_NOTE_FIELDS_LENGTH;\n use dep::aztec::constants_gen::GENERATOR_INDEX__CONTRACT_ADDRESS;\n use dep::aztec::constants_gen::GENERATOR_INDEX__SIGNATURE_PAYLOAD;\n\n use crate::storage::Storage;\n use crate::public_key_note::PublicKeyNote;\n use crate::public_key_note::PublicKeyNoteMethods;\n use crate::public_key_note::PUBLIC_KEY_NOTE_LEN;\n\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], // schnorr signature of the payload hash\n ) -> distinct pub abi::PrivateCircuitPublicInputs {\n // Initialize context\n // ENTRYPOINT_PAYLOAD_SIZE(13) + 64\n let mut args: BoundedVec = 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.signing_public_key.get_note(&mut context);\n\n // Verify payload signature\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\n // Verify signature of the payload bytes\n let verification = std::schnorr::verify_signature(public_key.x, public_key.y, signature, message_bytes);\n assert(verification == true);\n\n // Execute calls\n payload.execute_calls(&mut context);\n\n context.finish()\n }\n\n // Constructs the contract\n fn constructor(\n inputs: pub PrivateContextInputs,\n signing_pub_key_x: pub Field,\n signing_pub_key_y: pub Field,\n ) -> distinct pub abi::PrivateCircuitPublicInputs {\n let storage = Storage::init();\n \n let mut context = PrivateContext::new(inputs, abi::hash_args([signing_pub_key_x, signing_pub_key_y]));\n \n let this = context.this_address();\n let mut pub_key_note = PublicKeyNote::new(signing_pub_key_x, signing_pub_key_y, this);\n storage.signing_public_key.initialise(&mut context, &mut pub_key_note);\n \n emit_encrypted_log(\n &mut context,\n this,\n storage.signing_public_key.storage_slot,\n get_public_key(this),\n pub_key_note.serialise(),\n );\n\n context.finish()\n }\n\n // Computes notes 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; 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(PublicKeyNoteMethods, note_header, preimage)\n }\n}\n", - "path": "/mnt/user-data/lasse/aztec3-packages/yarn-project/noir-contracts/src/contracts/schnorr_account_contract/src/main" + "source": "mod storage;\nmod public_key_note;\n\n// Account contract that uses Schnorr signatures for authentication.\n// The signing key is stored in an immutable private note and should be different from the encryption/nullifying key.\ncontract SchnorrAccount {\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::private_call_stack_item::PrivateCallStackItem;\n use dep::aztec::public_call_stack_item::PublicCallStackItem;\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::note::utils as note_utils;\n use dep::aztec::note::note_header::NoteHeader;\n use dep::aztec::constants_gen::MAX_NOTE_FIELDS_LENGTH;\n use dep::aztec::constants_gen::GENERATOR_INDEX__CONTRACT_ADDRESS;\n use dep::aztec::constants_gen::GENERATOR_INDEX__SIGNATURE_PAYLOAD;\n\n use crate::storage::Storage;\n use crate::public_key_note::PublicKeyNote;\n use crate::public_key_note::PublicKeyNoteMethods;\n use crate::public_key_note::PUBLIC_KEY_NOTE_LEN;\n\n // docs:start:entrypoint\n\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], // schnorr signature of the payload hash\n ) -> distinct pub abi::PrivateCircuitPublicInputs {\n // Initialize context\n // ENTRYPOINT_PAYLOAD_SIZE(13) + 64\n let mut args: BoundedVec = 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.signing_public_key.get_note(&mut context);\n\n // Verify payload signature\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\n // Verify signature of the payload bytes\n let verification = std::schnorr::verify_signature(public_key.x, public_key.y, signature, message_bytes);\n assert(verification == true);\n\n // docs:end:entrypoint\n\n // Execute calls\n payload.execute_calls(&mut context);\n\n context.finish()\n }\n\n // Constructs the contract\n fn constructor(\n inputs: pub PrivateContextInputs,\n signing_pub_key_x: pub Field,\n signing_pub_key_y: pub Field,\n ) -> distinct pub abi::PrivateCircuitPublicInputs {\n let storage = Storage::init();\n \n let mut context = PrivateContext::new(inputs, abi::hash_args([signing_pub_key_x, signing_pub_key_y]));\n \n let this = context.this_address();\n let mut pub_key_note = PublicKeyNote::new(signing_pub_key_x, signing_pub_key_y, this);\n storage.signing_public_key.initialise(&mut context, &mut pub_key_note);\n \n emit_encrypted_log(\n &mut context,\n this,\n storage.signing_public_key.storage_slot,\n get_public_key(this),\n pub_key_note.serialise(),\n );\n\n context.finish()\n }\n\n // Computes notes 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; 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(PublicKeyNoteMethods, note_header, preimage)\n }\n}\n", + "path": "/mnt/user-data/jan/aztec-packages/yarn-project/noir-contracts/src/contracts/schnorr_account_contract/src/main" }, "3": { "source": "mod poseidon;\n\n#[foreign(sha256)]\nfn sha256(_input : [u8; N]) -> [u8; 32] {}\n\n#[foreign(blake2s)]\nfn blake2s(_input : [u8; N]) -> [u8; 32] {}\n\nfn pedersen(input : [Field; N]) -> [Field; 2] {\n pedersen_with_separator(input, 0)\n}\n\n#[foreign(pedersen)]\nfn pedersen_with_separator(_input : [Field; N], _separator : u32) -> [Field; 2] {}\n\n#[foreign(hash_to_field_128_security)]\nfn hash_to_field(_input : [Field; N]) -> Field {}\n\n#[foreign(keccak256)]\nfn keccak256(_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(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(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", @@ -20848,47 +20848,47 @@ }, "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 = 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 = 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 = 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 = 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(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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/abi" + "path": "/mnt/user-data/jan/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,\n\n read_requests: BoundedVec,\n\n new_commitments: BoundedVec,\n new_nullifiers: BoundedVec,\n nullified_commitments: BoundedVec,\n\n private_call_stack : BoundedVec,\n public_call_stack : BoundedVec,\n new_l2_to_l1_msgs : BoundedVec,\n\n block_data: HistoricBlockData,\n\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n // encrypted_logs_preimages: Vec,\n // unencrypted_logs_preimages: Vec,\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(&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(&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(\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(\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,\n\n contract_storage_update_requests: BoundedVec,\n contract_storage_read: BoundedVec,\n public_call_stack: BoundedVec,\n\n new_commitments: BoundedVec,\n new_nullifiers: BoundedVec,\n\n new_l2_to_l1_msgs: BoundedVec,\n\n unencrypted_logs_hash: BoundedVec,\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(&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(&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(\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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/context" + "path": "/mnt/user-data/jan/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 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(\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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/log" + "path": "/mnt/user-data/jan/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(\n context: &mut PrivateContext,\n storage_slot: Field,\n note: &mut Note,\n note_interface: NoteInterface,\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(\n context: &mut PublicContext,\n storage_slot: Field,\n note: &mut Note,\n note_interface: NoteInterface,\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(\n context: &mut PrivateContext,\n storage_slot: Field,\n note: Note,\n note_interface: NoteInterface,\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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/note/lifecycle" + "path": "/mnt/user-data/jan/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(\n context: PrivateContext,\n storage_slot: Field,\n note_interface: NoteInterface,\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(\n context: &mut PrivateContext,\n storage_slot: Field,\n note_interface: NoteInterface,\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(\n context: &mut PrivateContext,\n storage_slot: Field,\n note_interface: NoteInterface,\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(\n context: &mut PrivateContext,\n storage_slot: Field,\n note_interface: NoteInterface,\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(\n context: &mut PrivateContext,\n storage_slot: Field,\n note_interface: NoteInterface,\n options: NoteGetterOptions,\n) -> [Option; 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(\n storage_slot: Field,\n note_interface: NoteInterface,\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(\n storage_slot: Field,\n note_interface: NoteInterface,\n options: NoteGetterOptions,\n) -> [Option; 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(\n storage_slot: Field,\n note_interface: NoteInterface,\n options: NoteViewerOptions,\n) -> [Option; 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(\n selects: BoundedVec, N>,\n sorts: BoundedVec, 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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/note/note_getter" + "path": "/mnt/user-data/jan/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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/note/note_hash" + "path": "/mnt/user-data/jan/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(\n note_interface: NoteInterface,\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(\n note_interface: NoteInterface,\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(\n note_interface: NoteInterface,\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(\n note_interface: NoteInterface,\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(\n note_interface: NoteInterface,\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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/note/utils" + "path": "/mnt/user-data/jan/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 {\n storage_slot: Field,\n note_interface: NoteInterface,\n}\n\nimpl ImmutableSingleton {\n fn new(storage_slot: Field, note_interface: NoteInterface) -> 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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/state_vars/immutable_singleton" + "path": "/mnt/user-data/jan/aztec-packages/yarn-project/noir-libs/noir-aztec/src/state_vars/immutable_singleton" }, "55": { "source": "\nstruct BoundedVec {\n storage: [T; MaxLen],\n len: Field,\n}\n\nimpl BoundedVec {\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(&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 = 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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/types/vec" + "path": "/mnt/user-data/jan/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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/oracle/get_public_key" + "path": "/mnt/user-data/jan/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 = 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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/entrypoint" + "path": "/mnt/user-data/jan/aztec-packages/yarn-project/noir-libs/noir-aztec/src/entrypoint" } } } diff --git a/yarn-project/aztec.js/src/abis/schnorr_single_key_account_contract.json b/yarn-project/aztec.js/src/abis/schnorr_single_key_account_contract.json index 7cc0f4e7c54..a0669719c32 100644 --- a/yarn-project/aztec.js/src/abis/schnorr_single_key_account_contract.json +++ b/yarn-project/aztec.js/src/abis/schnorr_single_key_account_contract.json @@ -19919,7 +19919,7 @@ "fileMap": { "0": { "source": "// Account contract that uses Schnorr signatures for authentication. The signing key is the same as the\n// encryption key, and as such is not stored in the contract but part of the address preimage, so it can\n// be verified by passing in the partial address.\ncontract SchnorrSingleKeyAccount {\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::private_call_stack_item::PrivateCallStackItem;\n use dep::aztec::public_call_stack_item::PublicCallStackItem;\n use dep::aztec::context::PrivateContext;\n use dep::aztec::types::vec::BoundedVec;\n use dep::aztec::types::point::Point;\n use dep::aztec::constants_gen::GENERATOR_INDEX__CONTRACT_ADDRESS;\n use dep::aztec::constants_gen::GENERATOR_INDEX__SIGNATURE_PAYLOAD;\n\n fn entrypoint(\n inputs: pub PrivateContextInputs,\n payload: pub EntrypointPayload, // contains a set of arguments, selectors, targets and a nonce\n owner: pub [u8;64], // pubkey x and y coordinates concatenated\n signature: pub [u8;64], // schnorr signature of the payload hash\n partial_address: pub Field,\n ) -> distinct pub abi::PrivateCircuitPublicInputs {\n // Initialize context\n // ENTRYPOINT_PAYLOAD_SIZE(13) + 64 + 64 + 1\n let mut args: BoundedVec = BoundedVec::new(0);\n args.push_array(payload.serialize());\n for byte in owner { args.push(byte as Field); }\n for byte in signature { args.push(byte as Field); }\n args.push(partial_address);\n let mut context = PrivateContext::new(inputs, abi::hash_args(args.storage));\n\n // Verify payload signature\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\n // Convert owner pubkey into fields\n let mut x: Field = 0;\n let mut y: Field = 0;\n let mut mul: Field = 1;\n for i in 0..32 {\n let bytex: Field = owner[31 - i] as Field;\n x = x + (bytex * mul);\n let bytey: Field = owner[63 - i] as Field;\n y = y + (bytey * mul);\n mul *= 256;\n }\n \n // Verify signature of the payload hash\n // TODO: Find out why this signature verification never fails\n let verification = std::schnorr::verify_signature(x, y, signature, message_bytes);\n assert(verification == true);\n\n // Verify public key against address\n let reproduced_address = dep::std::hash::pedersen_with_separator([x, y, partial_address], GENERATOR_INDEX__CONTRACT_ADDRESS)[0];\n assert(reproduced_address == context.this_address());\n\n // Execute calls\n payload.execute_calls(&mut context);\n\n context.finish()\n }\n\n // Constructs the contract\n fn constructor(\n inputs: pub PrivateContextInputs,\n ) -> distinct pub abi::PrivateCircuitPublicInputs {\n // Return private circuit public inputs. All private functions need to return this as it is part of the input of the private kernel.\n PrivateContext::new(inputs, 0).finish()\n }\n}\n", - "path": "/mnt/user-data/lasse/aztec3-packages/yarn-project/noir-contracts/src/contracts/schnorr_single_key_account_contract/src/main" + "path": "/mnt/user-data/jan/aztec-packages/yarn-project/noir-contracts/src/contracts/schnorr_single_key_account_contract/src/main" }, "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", @@ -19927,23 +19927,23 @@ }, "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 = 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 = 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 = 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 = 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(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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/abi" + "path": "/mnt/user-data/jan/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,\n\n read_requests: BoundedVec,\n\n new_commitments: BoundedVec,\n new_nullifiers: BoundedVec,\n nullified_commitments: BoundedVec,\n\n private_call_stack : BoundedVec,\n public_call_stack : BoundedVec,\n new_l2_to_l1_msgs : BoundedVec,\n\n block_data: HistoricBlockData,\n\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n // encrypted_logs_preimages: Vec,\n // unencrypted_logs_preimages: Vec,\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(&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(&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(\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(\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,\n\n contract_storage_update_requests: BoundedVec,\n contract_storage_read: BoundedVec,\n public_call_stack: BoundedVec,\n\n new_commitments: BoundedVec,\n new_nullifiers: BoundedVec,\n\n new_l2_to_l1_msgs: BoundedVec,\n\n unencrypted_logs_hash: BoundedVec,\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(&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(&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(\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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/context" + "path": "/mnt/user-data/jan/aztec-packages/yarn-project/noir-libs/noir-aztec/src/context" }, "55": { "source": "\nstruct BoundedVec {\n storage: [T; MaxLen],\n len: Field,\n}\n\nimpl BoundedVec {\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(&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 = 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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/types/vec" + "path": "/mnt/user-data/jan/aztec-packages/yarn-project/noir-libs/noir-aztec/src/types/vec" }, "61": { "source": "use crate::abi::FunctionData;\nuse crate::abi::PrivateCircuitPublicInputs;\nuse crate::constants_gen::GENERATOR_INDEX__CALL_STACK_ITEM;\n\nstruct PrivateCallStackItem {\n contract_address: Field,\n function_data: FunctionData,\n public_inputs: PrivateCircuitPublicInputs,\n is_execution_request: bool,\n}\n\nimpl PrivateCallStackItem {\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator([\n self.contract_address,\n self.function_data.hash(),\n self.public_inputs.hash(),\n ], GENERATOR_INDEX__CALL_STACK_ITEM)[0]\n }\n}", - "path": "/mnt/user-data/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/private_call_stack_item" + "path": "/mnt/user-data/jan/aztec-packages/yarn-project/noir-libs/noir-aztec/src/private_call_stack_item" }, "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 = 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/lasse/aztec3-packages/yarn-project/noir-libs/noir-aztec/src/entrypoint" + "path": "/mnt/user-data/jan/aztec-packages/yarn-project/noir-libs/noir-aztec/src/entrypoint" } } } diff --git a/yarn-project/noir-contracts/src/contracts/ecdsa_account_contract/src/ecdsa_public_key_note.nr b/yarn-project/noir-contracts/src/contracts/ecdsa_account_contract/src/ecdsa_public_key_note.nr index d4221124f49..7ecf11df45b 100644 --- a/yarn-project/noir-contracts/src/contracts/ecdsa_account_contract/src/ecdsa_public_key_note.nr +++ b/yarn-project/noir-contracts/src/contracts/ecdsa_account_contract/src/ecdsa_public_key_note.nr @@ -3,7 +3,6 @@ use dep::aztec::note::note_interface::NoteInterface; use dep::aztec::note::note_header::NoteHeader; use dep::aztec::note::utils::compute_unique_siloed_note_hash; use dep::aztec::oracle::get_secret_key::get_secret_key; -use dep::aztec::oracle::get_public_key::get_public_key; global ECDSA_PUBLIC_KEY_NOTE_LEN: Field = 5; @@ -54,8 +53,7 @@ impl EcdsaPublicKeyNote { fn compute_nullifier(self) -> Field { let unique_siloed_note_hash = compute_unique_siloed_note_hash(EcdsaPublicKeyNoteInterface, self); - let owner_nullifying_public_key = get_public_key(self.owner); - let secret = get_secret_key(owner_nullifying_public_key); + let secret = get_secret_key(self.owner); dep::std::hash::pedersen([ unique_siloed_note_hash, secret, diff --git a/yarn-project/noir-contracts/src/contracts/escrow_contract/src/address_note.nr b/yarn-project/noir-contracts/src/contracts/escrow_contract/src/address_note.nr index 6d92fd93048..a623c5cf9d6 100644 --- a/yarn-project/noir-contracts/src/contracts/escrow_contract/src/address_note.nr +++ b/yarn-project/noir-contracts/src/contracts/escrow_contract/src/address_note.nr @@ -2,7 +2,6 @@ use dep::std::hash::pedersen; use dep::aztec::note::note_interface::NoteInterface; use dep::aztec::note::note_header::NoteHeader; use dep::aztec::oracle::get_secret_key::get_secret_key; -use dep::aztec::oracle::get_public_key::get_public_key; use dep::aztec::note::utils::compute_siloed_note_hash; global ADDRESS_NOTE_LEN: Field = 2; @@ -29,8 +28,7 @@ impl AddressNote { fn compute_nullifier(self) -> Field { let siloed_note_hash = compute_siloed_note_hash(AddressNoteMethods, self); - let owner_nullifying_public_key = get_public_key(self.owner); - let secret = get_secret_key(owner_nullifying_public_key); + let secret = get_secret_key(self.owner); dep::std::hash::pedersen([ siloed_note_hash, secret, diff --git a/yarn-project/noir-contracts/src/contracts/pokeable_token_contract/src/address_note.nr b/yarn-project/noir-contracts/src/contracts/pokeable_token_contract/src/address_note.nr index 678463b5a91..b2da2581c68 100644 --- a/yarn-project/noir-contracts/src/contracts/pokeable_token_contract/src/address_note.nr +++ b/yarn-project/noir-contracts/src/contracts/pokeable_token_contract/src/address_note.nr @@ -3,7 +3,6 @@ use dep::aztec::note::note_interface::NoteInterface; use dep::aztec::note::note_header::NoteHeader; use dep::aztec::note::utils::compute_unique_siloed_note_hash; use dep::aztec::oracle::get_secret_key::get_secret_key; -use dep::aztec::oracle::get_public_key::get_public_key; global ADDRESS_NOTE_LEN: Field = 1; @@ -28,8 +27,7 @@ impl AddressNote { fn compute_nullifier(self) -> Field { let unique_siloed_note_hash = compute_unique_siloed_note_hash(AddressNoteMethods, self); - let owner_nullifying_public_key = get_public_key(self.address); - let secret = get_secret_key(owner_nullifying_public_key); + let secret = get_secret_key(self.address); dep::std::hash::pedersen([ unique_siloed_note_hash, secret, diff --git a/yarn-project/noir-contracts/src/contracts/schnorr_account_contract/src/main.nr b/yarn-project/noir-contracts/src/contracts/schnorr_account_contract/src/main.nr index b8f311054d9..b45dcbd3bba 100644 --- a/yarn-project/noir-contracts/src/contracts/schnorr_account_contract/src/main.nr +++ b/yarn-project/noir-contracts/src/contracts/schnorr_account_contract/src/main.nr @@ -28,6 +28,8 @@ contract SchnorrAccount { use crate::public_key_note::PublicKeyNoteMethods; use crate::public_key_note::PUBLIC_KEY_NOTE_LEN; + // docs:start:entrypoint + fn entrypoint( inputs: pub PrivateContextInputs, payload: pub EntrypointPayload, // contains a set of arguments, selectors, targets and a nonce @@ -53,6 +55,8 @@ contract SchnorrAccount { let verification = std::schnorr::verify_signature(public_key.x, public_key.y, signature, message_bytes); assert(verification == true); + // docs:end:entrypoint + // Execute calls payload.execute_calls(&mut context); diff --git a/yarn-project/noir-contracts/src/contracts/schnorr_account_contract/src/public_key_note.nr b/yarn-project/noir-contracts/src/contracts/schnorr_account_contract/src/public_key_note.nr index 742a4fc134d..8b16de73d7c 100644 --- a/yarn-project/noir-contracts/src/contracts/schnorr_account_contract/src/public_key_note.nr +++ b/yarn-project/noir-contracts/src/contracts/schnorr_account_contract/src/public_key_note.nr @@ -2,7 +2,6 @@ use dep::std::hash::pedersen; use dep::aztec::note::note_interface::NoteInterface; use dep::aztec::note::note_header::NoteHeader; use dep::aztec::oracle::get_secret_key::get_secret_key; -use dep::aztec::oracle::get_public_key::get_public_key; use dep::aztec::note::utils::compute_unique_siloed_note_hash; global PUBLIC_KEY_NOTE_LEN: Field = 3; @@ -33,8 +32,7 @@ impl PublicKeyNote { fn compute_nullifier(self) -> Field { let unique_siloed_note_hash = compute_unique_siloed_note_hash(PublicKeyNoteMethods, self); - let owner_nullifying_public_key = get_public_key(self.owner); - let secret = get_secret_key(owner_nullifying_public_key); + let secret = get_secret_key(self.owner); dep::std::hash::pedersen([ unique_siloed_note_hash, secret, diff --git a/yarn-project/noir-libs/noir-aztec/src/oracle/get_secret_key.nr b/yarn-project/noir-libs/noir-aztec/src/oracle/get_secret_key.nr index b44d9ca1d57..b88d410665d 100644 --- a/yarn-project/noir-libs/noir-aztec/src/oracle/get_secret_key.nr +++ b/yarn-project/noir-libs/noir-aztec/src/oracle/get_secret_key.nr @@ -1,8 +1,10 @@ use crate::types::point::Point; +use crate::oracle::get_public_key::get_public_key; #[oracle(getSecretKey)] fn get_secret_key_oracle(_owner: Point) -> Field {} -unconstrained fn get_secret_key(owner: Point) -> Field { - get_secret_key_oracle(owner) +unconstrained fn get_secret_key(owner: Field) -> Field { + let owner_nullifying_public_key = get_public_key(owner); + get_secret_key_oracle(owner_nullifying_public_key) } \ No newline at end of file diff --git a/yarn-project/noir-libs/value-note/src/utils.nr b/yarn-project/noir-libs/value-note/src/utils.nr index 4428ac70284..23705ba43be 100644 --- a/yarn-project/noir-libs/value-note/src/utils.nr +++ b/yarn-project/noir-libs/value-note/src/utils.nr @@ -125,14 +125,22 @@ fn send_note( balance.insert(context, &mut note); // Emit the newly created encrypted note preimages via oracle calls. + // docs:start:encrypted + + let application_contract_address = (*context).this_address(); + let note_storage_slot = balance.storage_slot; let encryption_pub_key = get_public_key(recipient); + let encrypted_data = note.serialise(); + emit_encrypted_log( context, - (*context).this_address(), - balance.storage_slot, + application_contract_address, + note_storage_slot, encryption_pub_key, - note.serialise(), + encrypted_data, ); + + // docs:end:encrypted } /* diff --git a/yarn-project/noir-libs/value-note/src/value_note.nr b/yarn-project/noir-libs/value-note/src/value_note.nr index ebc1415be43..c721da0aa5f 100644 --- a/yarn-project/noir-libs/value-note/src/value_note.nr +++ b/yarn-project/noir-libs/value-note/src/value_note.nr @@ -6,7 +6,6 @@ use dep::aztec::note::{ use dep::aztec::oracle::{ rand::rand, get_secret_key::get_secret_key, - get_public_key::get_public_key, }; global VALUE_NOTE_LEN: Field = 3; // 3 plus a header. @@ -51,18 +50,19 @@ impl ValueNote { ])[0] } + // docs:start:nullifier + fn compute_nullifier(self) -> Field { let note_hash_for_nullify = compute_note_hash_for_read_or_nullify(ValueNoteMethods, self); - let owner_nullifying_public_key = get_public_key(self.owner); - // TODO: get_secret_key should just accept an address - // TODO! - let secret = get_secret_key(owner_nullifying_public_key); + let secret = get_secret_key(self.owner); dep::std::hash::pedersen([ note_hash_for_nullify, secret, ])[0] } + // docs:end:nullifier + fn set_header(&mut self, header: NoteHeader) { self.header = header; }