@aztec/protocol-contracts 0.0.1-commit.f2ce05ee → 0.0.1-commit.f8ca9b2f3
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/artifacts/AuthRegistry.json +13 -13
- package/artifacts/ContractClassRegistry.json +25 -4007
- package/artifacts/ContractInstanceRegistry.json +17 -17
- package/artifacts/FeeJuice.json +10 -10
- package/artifacts/MultiCallEntrypoint.json +18 -18
- package/artifacts/PublicChecks.json +14 -14
- package/dest/protocol_contract_data.js +13 -13
- package/package.json +4 -4
- package/src/protocol_contract_data.ts +13 -13
|
@@ -36,7 +36,7 @@
|
|
|
36
36
|
}
|
|
37
37
|
},
|
|
38
38
|
"bytecode": "JwACBAEoAAABBIBFJwAABEUlAAAAQScCAQQAJwICBAAfCgABAAIARCUAAABCLQIBRCcCAgREJwIDBAE7DgADAAImJQAAAnUeAgACCScCAwEBJAIAAgAAAF4lAAACmx4CAAIBKQIAAwDvUlNNJwIEAAErAgAFAAAAAAAAAAADAAAAAAAAAAAtCAEGJwIHBAUACAEHAScDBgQBACIGAgctCgcILQ4DCAAiCAIILQ4ECAAiCAIILQ4CCAAiCAIILQ4FCC0LBgIAIgICAi0OAgYtCAECJwIDBAUACAEDAScDAgQBACIGAgMAIgICBD8PAAMABCcCAwQBACoCAwUtCwUEJwICAAAKKgQCAycCAgEACioDAgUkAgAFAAABICUAAAKtHgIAAgYeAgADAC8qAAQAAwAFHAoFBAQcCgQDAAIqBQMELAIAAwAtXgmLgro3tDuZoTFhGP0g1C9RZsnp8T+16mWpbR4KbQQqBAMFHAoFBgQcCgYEAAIqBQQGBCoGAwUcCgUHARwKBwYAHAoGBwECKgUGCCwCAAUAMDPqJG5QbomOl/Vwyv/XBMsLtGAxP7cgsp4TnlwQAAEEKggFCRwKCQoEHAoKCAACKgkICgQqCgMJHAoJCgEcCgoDABwKAwoBAioJAwsEKgsFCRwKCQsEHAoLBQAcCgUJBRYKCgUcCgMKBRwKBQMFBCoKCQUcCggJBRYKBwgcCgYHBRwKCAYFBCoHCQgcCgQJBQwqAgkEKQIAAgUAAVGAJAIABAAAAlwjAAACRAQqBwgDBCoGAgQAKgMEAi0KAgEjAAACdAQqCgUEBCoDAgUAKgQFAi0KAgEjAAACdCYoAAAEBHhFDAAABAMkAAADAAACmioBAAEF2sX11rRKMm08BAIBJioBAAEFT99KitfP8NM8BAIBJioBAAEFursh14IzGGQ8BAIBJg==",
|
|
39
|
-
"debug_symbols": "
|
|
39
|
+
"debug_symbols": "nZjbbtswDIbfxde5kEjqwLzKUBRp6w4BgrTIkgFDkXcfmZiSU0DCppv49+/4MylR9OFreptfLj+f98f3j1/T9sfX9HLaHw77n8+Hj9fdef9xFPdrcvqT/LTFzZTitKXNlP19w7cN07SNspE9L//xLi/C4yKQTNghskNkTjAnmBPBRFyERnEXYRHZmbBLZAuDDcjpLsCBCQUGEd6ZCIsAc8AcNAfNIQ0jqoiLCOYE/U8WEZ0Jc5I5yZyMJiRlABEaM6jD4qDbTKihohxC702oI1kgqCPjjzpiNxHldAwq8iKSOlGFOkmEXhSzirwINud2Ud5M5MQhuTqRMyExkxcRnAl1JB7STAlVqCNhkGZ6F+boNFFQoY7EQ6xOUhHuIjh1sorlrOB4cTyZMAfUYRV8Dz4gLo7W2E2QOVpjQbIIWmMBrtfNZBX+fD7Nsxb4quRlIXzuTvPxPG2Pl8NhM/3eHS63P/363B1v2/PuJEcFOR/fZCvA9/1hVnXd1LNd+1TvgXk5XdYJ+III/oHh2wyOEBcER0qVwA8E6EThMpUgXCUkGM0DW3l0GUSVQRFajNBmYCFgpKE8CFyNgXIrhtRhgJb4HQEcCiHTAyG3CZAtBlmL5Xzy8QHAvTS8LzGIrEOJOT3WleuWRUCjOHauTemUJwYoydTSks72SOiUJ/icFwR4jmOMOikgDbfNoDaDEhuDMtYx9fzPYSBzndrV3H4Po1devq40uS20ysv3EM4XhMMVAgfXSW73rU6VSssopeE8tcKAThxZ7i0LIhP7Zu/r1Gcsw5l8s/X10kBX+i+6Vcf4ngZ2EAnLSKSQmgjqzSmEWCYVUvs+EHoQp3WzQBxSExI7A1qXa5RnrSaiU6CQyoLnZhvvJcKcoOaxbuPfgujNayDrfhg6YXTnNZfSyMCteUXfWyRQGhdjTQQT/wcjlq4jMzzICFwXaxhioAu+MKIfZJQVL8/COMqgwoA0xvAhFUaMg4xaHuBH48hlPOQdZYwBNReIg3FALnOLfjSO+uCDQGMMLM8siKtnyP9j5NKOyQ8zyngQDK4XquuFRtdLQqq3lsExzaWbYubBNcfJ+gc5x03GP99pV3P7rZ2GXhuTu5q1U7d6WZIZv16fZHf3uj89fPi4Kuy0370c5mX3/XJ8XR09//m0I/bh5PP08Tq/XU6zkurXE/3M8EOepDfyyPSkH0Z0V978Pbinq17+Lw=="
|
|
40
40
|
},
|
|
41
41
|
{
|
|
42
42
|
"name": "public_dispatch",
|
|
@@ -108,7 +108,7 @@
|
|
|
108
108
|
}
|
|
109
109
|
},
|
|
110
110
|
"bytecode": "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",
|
|
111
|
-
"debug_symbols": "
|
|
111
|
+
"debug_symbols": "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"
|
|
112
112
|
},
|
|
113
113
|
{
|
|
114
114
|
"name": "publish_for_public_execution",
|
|
@@ -2094,9 +2094,9 @@
|
|
|
2094
2094
|
}
|
|
2095
2095
|
}
|
|
2096
2096
|
},
|
|
2097
|
-
"bytecode": "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",
|
|
2098
|
-
"debug_symbols": "
|
|
2099
|
-
"verification_key": "
|
|
2097
|
+
"bytecode": "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",
|
|
2098
|
+
"debug_symbols": "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",
|
|
2099
|
+
"verification_key": "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"
|
|
2100
2100
|
},
|
|
2101
2101
|
{
|
|
2102
2102
|
"name": "set_update_delay",
|
|
@@ -2153,7 +2153,7 @@
|
|
|
2153
2153
|
}
|
|
2154
2154
|
},
|
|
2155
2155
|
"bytecode": "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",
|
|
2156
|
-
"debug_symbols": "
|
|
2156
|
+
"debug_symbols": "tZvbbls7Dobfxde5kKgDxb7KRlGkbboRIEiL7HaAQdF3H5KSyJUMliaRMzf1Z9r+RepESqv5ffl69/nX35/uH799/+fy4a/fl89P9w8P939/evj+5fbn/fdHtv6+BPkn5nL5kG4usfDbIq9lvFK31zxe+T3yK+bxOt437K8E47VePsRwc4EQGVgJYpiQJ9AAmBaYljQtqQ3IMAEHlKlc6oAqTTSBMoEGYJqAAxpMmBaKE/jnwM4ncR6iAA0Q5wEEaABMS4IJLAjcCSnXAdKrHcqAOi11WnBapGs7tAEtTZjK0s0duInErmZxtUOZQANimtAGwLQADkjycxCoA/K0ZBpQZA6QAFsy90au/PPM0yIjTBBLZpDuzTwoRTpKQToqVwEaIKOcUUAs3PMli4UEaECZFmm0sKtFpmLh1quE3IF9LuxhjXGCWNifCmLJAmJhN6pE2mFaJNJSBcTC/lSZWqUJ1AFVLCQwfyXjpRYsA9q0NLZUdrVS6M5XytNCHTDkCWLhKFCmVs0CYmE3UH/FrbfInVlJAAfAtKQwoPDgIgu2miZMC9YBjaPAKiAWUZYmUH4ujslHJI7JRySNykckjSpIo/odmTb6ncSRNnaecpggFu4fkjnf5Msy5xXqtMgIdmgDZP50wAFtWsRVBenMhgIiyK3HEMRESmVSNJt06KA2SUIYhJOS2WRKdJJ4KCixMkUhiYhAqUyqZpOgBrVJEtYgnNTMJpF1ktAoKYkyT4IYJTYqSmVSNJvENqhNktgG4aRkNomtk8ZWlURZtmvd96kplUnVbBpbpzZJY+uEk5rZNDYljY2UZFcO0qkgwXHXCsoKnVgMk38huTW7NR+sZFiSYzOs4IiG6A1jNWzeRMuO3gRpE1URJ6YAjm6Nbo1uBbeCOikjkFJylO9GmXMpJ0cylDHiURbUnDewzC/kqCgzKoN+QVzXLX2iRCxJk+dAcNSfVUUylNGf6FZ0K7q1JUc0lHQ1sU4sWhoMtIaL1gkDs6N0VJTeKVoJdOzBN8ViiG5FtcrsKzqwHXXcJMHzFAdHt2r3ddTuk9TPKO5IhmckQx23gc1Q+7ej1imgxZNWKh2rW9V1kGHRpDJ+ht4aemvNrc1bI/ehxyaI2r8gA6sphSe/YI+ioypoGdej6OjWHoVij6KjW3VqDNQmpNexu97RrTo1gBSb+aBTYyBObAEcq2GMjsVQA5IihlFaSzJYTcvEjur6wGKoc2egKiTFZqgl40C3Nrc2t5JbSX2QAaCgX5CB1WTK61YRDaUo4XUrqBte0tJZN7yBKibdRzk7urW4VXe5gWiIbtUVMFCbkLHQtDrxYJUmshbwIQ93GJthTI5u1a1tIBpKyRWlYATNsAN1M8+gWAyLW3UH7yg1zUS36rbdsWkTSbEakls1NqlMQTNr9yFqbAPJMLpVY+sIyVFiy3qGkQQ7URuuesSJjm7VwRpIhtWtOlgDtQnpPs2qE93aY2uKdfrQE+vAYhjd2mPrSIY9to4WG3hsoLFJ+Q09CQ8shsWtxa3VrdWtmnmlLmYsE5NubVLPMzZDXVkD9eQno5l1fxjoVt0fBlZDcCu4Nbk1uVVXVkctJQZ6EzrP5EDBVYd+Vw+gOo3UWnSJyGmCz6eqgIrNENzafehYDbNbuzuKOnfkKAJ6EhpY3arrQo4fUHTnksMFo1jleMH1kFpBUa0SUOn9q1FQm9jTYil//txc5mXBp59Pd3dyV3C4PeA7hR+3T3ePPy8fHn89PNxc/nX78Eu/9M+P20d9/Xn7xJ+yL3ePX/mVBb/dP9wJ/bnxX4fznxJJ0a+/5pUboymU+EwinktwNs5DovIJ1RXomQKcKySZoiqQarbfI7zeAyn0uwd8yD3zIK88KEOAizvvxrLXjRDOurGeS6DMGFVArPb7DK91gc9XyX1IBc98aIuOjHLy6x3JOeasI+lcAXAKAJ0O5TIKvjryKGI6nZCL+cDb4ZxQkFI8CyMupmQtwaZUBfeCL4mea6RFLHJEnbHwm3iuspiaNaQ5MWrIPjPSG/zQA8j0o8C5H3U1Mq0kGxkK4VwFFwutzB7hhGMKQO31g5stGM4dp4s9LiYpFxBzx5JT2fXTtJ4u+KVGlgJ5aGSMWxrFQwl8eDvTgNX8ANv9+ATh3dHyc4nFJOWDvQ1r880r1ucK5T0WC9RrF8vaj9cuFmjvsViArl0sy6GNNHdCPsTVs6FNcRVKpMNMd4m0OUkP2e3FJE1pteyDZZacwpkbaZXkMVl/4iE/vpQoy3Uv1ecIBc6rnbTcSUM8VAvpdA9LeHWqTu3KXL0KhMiXLB9k22nhFVZzPM+FksrCjeW4tjkmiS8pzsY1L9I9EFhSoeSBJKQ3aFTbBMNx/3qTRrFSOMSypZFCiaZR46YGzv5I8VCEvVEjmwbgnoaez4ZGrZsaPj345L+rYf0Bh93nTRrgsfBN+aZGs7FNcdcPT9b8fHVPI1l6S6nCpoaVUCnHbQ3rjwyb6yX7esm76wVT9tSy2afNdtPEV557GoRz/8gh0KnGOtNWtEzbTrfTunCD74fncmmZTg9gdeFFtcIFD2v2ZVZYheEnOL4AOi0YalnNrow+y4+HwOdu1EWO5DvDuVL4JhbPNVZ+FN/BCtGWRm00NfjB+Z4GhjQrBuQ74VON9bDYqueLsHw2LBiX10W2YEs8rUgR3qGOw/QOdRzmq+s4LFfWcatAXlvHIV5dx63doHC4iyynbsSlG8XdOK3x26IiBX1a2PuTH9Ls7aEFo20+h5Xy0o3FFM3BUkrm4+SpxKpDbakR+cyi55fDbTE5iz7oVYUSy3l6XWtYScuLFTc1bKGViHFPI9g1NWvAngbYMYGfNKSr/YDFUWPtR3E/qO5ppDBXG+O2HxZLinB1f6S42aepWn9wKXa9H0ibfliS5e1wc1xytnHJue36Yf3Bj9qu7o+8KGnbMkMmONxOnm1BfMX0LvfOAa6+eA6rTd1TtTwV3hTxy1aAlhYii4yf0cY3t+TrLtLrHUmebRnbqSPLHBXtbpCv1MtZjopheVWK5FVUi3R6ox9oecdYfapxUXWqEleXUdWvLDCePhj4X540v9avh0vXF56sbkzJ9uZIBz9ejs1KovnNLx0uxd4iQV4jU8E9CauDIlcjOxIQqpVSfKO0JZGDPQ/MsOdFTi5xeNzzFokSvCaEuidRgkmUuCeRs0vAphfVJLBd7cWuhE1wqHFrgkPNfhYte4Na7dKX7/Q2vbAiCmoLVweyJ8HJ1M5vreVNCc+xYWtQE9kjUS6lzrtT/wvgldlx6YbVcYy4F8nr0uvyIGpZAI4PRN+0eZKfZcPeatf//zwkIGwGUl3i+kA2JaJv4THjnoRd4UOstClhWSBiuDqQXYnXlbIrCfBBhdg2JYJL0LWB7Eq8tiLP9P/cc/hGNfvlqtd88dWBoP5NwrgzP/rwIo6yuhgFS8zylx1bXtgaYaQtBbJr5l0frI7HeMiHb1AAK9YYcS8KcoV2rULc8gEATCGFa8fi8F/p3uJDKqZQ9qKwm9D/mg8f+d3tl/unZ391+0e0nu5vPz/cjbfffj1+OXz6898/5ifzr3Z/PH3/cvf119OdKPmf7vI/fxXepUqkjzeXKO8g3ZQc5J18KDdgXIrKW/k0c7A54cc/4tp/AA=="
|
|
2157
2157
|
},
|
|
2158
2158
|
{
|
|
2159
2159
|
"name": "update",
|
|
@@ -2217,7 +2217,7 @@
|
|
|
2217
2217
|
}
|
|
2218
2218
|
},
|
|
2219
2219
|
"bytecode": "JwACBAEoAAABBIBMJwAABEwlAAAAQScCAgQBJwIDBAAfCgACAAMASy0ISwElAAAAqicCAQRMJwICBAA7DgACAAEnAEMAAywAAEQALc/6U80Ocdp7SiJnezNCv8O5BD9Qgb6lg2itAI6qbzcsAABFADBkTnLhMaApuFBFtoGBWF0oM+hIeblwkUPh9ZPwAAAAJwBGBAMnAEcAACcASAEBJwBJBAEnAEoAASYlAAAGPh4CAAMBCiIDRQQWCgQFHAoFBgAEKgYDBScCAwEACioEAwYkAgAGAAAA4icCBwQAPAYHAR4CAAQAKQIABgADbVJ/LQgBBycCCAQEAAgBCAEnAwcEAQAiBwIILQoICS0OBgkAIgkCCS0OBAkAIgkCCS0OBQknAggECS0IAAktCgcKLQhGCwAIAAgAJQAABmQtAgAALQoKBDMKAAQAByQCAAcAAAFYJQAACdMtCAEEJwIHBAQACAEHAScDBAQBACIEAgctCgcILQ4GCAAiCAIILQxDCAAiCAIILQ4BCCcCBwQILQgACC0KBAktCEYKAAgABwAlAAAGZC0CAAAtCgkGMwoABgAEJAIABAAAAcAlAAAJ5SkCAAQA71JTTS0IAQYnAgcEBAAIAQcBJwMGBAEAIgYCBy0KBwgtDgQIACIIAggtDEoIACIIAggtDgUIJwIHBAgtCAAILQoGCS0IRgoACAAHACUAAAZkLQIAAC0KCQQKIgRHBgoqBgMHJAIABwAAAjUlAAAJ9x4CAAMALyoABAADAAYAIgRKAx4CAAcALyoAAwAHAAgnAgcAAgAqBAcJHgIACgAvKgAJAAoACxwKBgwEHAoMCgAcCgoGBR4CAAoALyoABAAKAAwcCgwNBBwKDQoAAioMCg0sAgAKAC1eCYuCuje0O5mhMWEY/SDUL1FmyenxP7XqZaltHgptBCoNCgwcCgwOBBwKDg0AAioMDQ4EKg4KDBwKDA8BHAoPDgAcCg4PAQIqDA4QLAIADAAwM+okblBuiY6X9XDK/9cEywu0YDE/tyCynhOeXBAAAQQqEAwRHAoREgQcChIQAAIqERASBCoSChEcChESARwKEgoAHAoKEgECKhEKEwQqEwwRHAoREwQcChMMABwKDBEFFgoSDBwKChIFHAoMEwUEKhIRDBwKEBEFFgoPEBwKDg8FHAoQFAUEKg8REBwKDREFHgIAFQYMKhURFikCABEFAAFRgCQCABYAAAO2IwAAA54EKg8QEgQqFBEPACoSDxEtChECIwAAA84EKhIMDwQqExESACoPEhEtChECIwAAA84AKhUCDw4qFQ8RJAIAEQAAA+UlAAAKCQwqFQYCFgoCBhwKAhEAHAoGAgAEKhEIBgQqAgsIACoGCAIcCg8GACcCCAAgJwIPBBEtCAARLQoHEi0KCBMACAAPACUAAAobLQIAAC0KEgsEKg0LCAAqBggLJwIIAEAnAg8EES0IABEtCgcSLQoIEwAIAA8AJQAAChstAgAALQoSDQQqDg0IACoLCA0cChAIACcCCwBIJwIPBBAtCAAQLQoHES0KCxIACAAPACUAAAobLQIAAC0KEQ4EKggOCwAqDQsIJwILAGgnAg4EDy0IAA8tCgcQLQoLEQAIAA4AJQAAChstAgAALQoQDQQqCg0LACoICwocCgwIACcCCwBwJwINBA4tCAAOLQoHDy0KCxAACAANACUAAAobLQIAAC0KDwwEKggMBwAqCgcIKwIABwAAAAAAAAAAAwAAAAAAAAAALQgBCicCCwQFAAgBCwEnAwoEAQAiCgILLQoLDC0OCAwAIgwCDC0OAgwAIgwCDC0OAQwAIgwCDC0OBwwtCwoHACIHAgctDgcKLQgBBycCCwQFAAgBCwEnAwcEAQAiCgILACIHAgw/DwALAAwAIgdJCy0LCwowCgAIAAQwCgACAAMwCgABAAkAIgRDAzAKAAoAAycCBAQFJwIIBAMAKgQIBy0IAQMACAEHAScDAwQBACIDAgctDgQHACIHAgctDgQHJwIHBAMAKgMHBC0KBActDEQHACIHAgctDgUHACIHAgctDgIHACIHAgctDgEHACIHAgctDgYHJwIBBAUAIgMCBS0LBQUtCgUEJwIGBAMAKgMGAjcOAAQAAiYoAAAEBHhMDAAABAMkAAADAAAGYyoBAAEF2sX11rRKMm08BAIBJiUAAAY+HAoCBAArAgAFAAAAAAAAAAABAAAAAAAAAAAEKgQFBi0IAQQAAAECAS0IAQUnAgcEBQAIAQcBJwMFBAEAIgUCBy0KBwgtDEcIACIIAggtDEcIACIIAggtDEcIACIIAggtDgYILQ4FBAYiAkYFJwIGBAAnAgcEAi0KBgMjAAAG6AwqAwUIJAIACAAACGgjAAAG+gYiAkYFBCIFRggCKgIIAwoqAwYFFgoFCCQCAAUAAAgCIwAABx8CKgIDBQ4qAwIJJAIACQAABzYlAAALCC0LBAkAIglJCy0LCwoMIgVGCyQCAAsAAAdVJQAACxoAIgECDAAqDAUNLQsNCwAqCgsMLQIJAycABAQFJQAACywtCAUKACIKSQstDgwLLQ4KBAwoSQMJJAIACQAAB5kjAAAIAgAqCgcJLQsJAwAiBUkJDioFCQskAgALAAAHuSUAAAoJDCIJRgUkAgAFAAAHyyUAAAsaACIBAgsAKgsJDC0LDAUAKgMFAS0CCgMnAAQEBSUAAAssLQgFAwAqAwcFLQ4BBS0OAwQjAAAIAgoqAgYBEioBCAIkAgACAAAIGSMAAAhWLQsEAS0LAQIAIgICAi0OAgEtCAECJwIDBAUACAEDAScDAgQBACIBAgMAIgICBT8PAAMABS0OAgQjAAAIVi0LBAEAIgFJAy0LAwItCgIBJi0LBAgAIghJCi0LCgkEIgNGCgYiCkYMCioMAwskAgALAAAIkSUAAAuLDCIKRgskAgALAAAIoyUAAAsaACIBAgwAKgwKDS0LDQsAKgkLDC0CCAMnAAQEBSUAAAssLQgFCQAiCUkLLQ4MCwAqCQcLLQsLCAAiCkkLDioKCwwkAgAMAAAI8SUAAAoJDCILRgwkAgAMAAAJAyUAAAsaACIBAg0AKg0LDi0LDgwAKggMCy0CCQMnAAQEBSUAAAssLQgFCAAqCAcMLQ4LDAAiCEYLLQsLCQAqCgcLDioKCwwkAgAMAAAJUSUAAAoJDCILRgokAgAKAAAJYyUAAAsaACIBAgwAKgwLDS0LDQoAKgkKCy0CCAMnAAQEBSUAAAssLQgFCQAiCUYKLQ4LCi0LCQgAIggCCC0OCAktCAEIJwIKBAUACAEKAScDCAQBACIJAgoAIggCCz8PAAoACy0OCAQAIgNJCC0KCAMjAAAG6CoBAAEF1RJ9KcLS6O08BAIBJioBAAEFrpKPa6mOkow8BAIBJioBAAEFursh14IzGGQ8BAIBJioBAAEF0Afr9MvGZ5A8BAIBJiUAAAY+LQgBBAAAAQIBLQxKBCcCBgQCJwIHAQEtCAEFJwIIBCEACAEIAScDBQQBACIFAggnAgkEIEMDqgACAAYACQAHAAgtAggDLQIJBCUAAAudJwICBCEnAgYEIC0ISQMjAAAKgQwqAwIHJAIABwAACpgjAAAKky0LBAEmLQsEBwQqBwcIAioGAwcOKgMGCSQCAAkAAAq4JQAACwgMKgcGCSQCAAkAAArKJQAACxoAIgUCCgAqCgcLLQsLCRwKCQcABCoIAQkEKgcJCgIoSgcJBCoJCAcAKgoHCC0OCAQAIgNJBy0KBwMjAAAKgSoBAAEFG7xl0D/c6tw8BAIBJioBAAEF5AhQRQK1jB88BAIBJi0BAwYKAAYCByQAAAcAAAtCIwAAC0stAAMFIwAAC4otAAEFAAABBAEAAAMECS0AAwotAAULCgAKCQwkAAAMAAALhS0BCggtBAgLAAAKAgoAAAsCCyMAAAthJwEFBAEmKgEAAQUFBBuZIK9gTDwEAgEmJwAGBAIGAAQGBS0ABAgnAAkEAA4ABQkKJAAACgAAC/ACAAgCCAAAAwkLLQELBgAAAwgLLQELBwAAAwkLLQQHCwAAAwgLLQQGCwAACQIJIwAAC7Am",
|
|
2220
|
-
"debug_symbols": "
|
|
2220
|
+
"debug_symbols": "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"
|
|
2221
2221
|
}
|
|
2222
2222
|
],
|
|
2223
2223
|
"outputs": {
|
|
@@ -2823,7 +2823,7 @@
|
|
|
2823
2823
|
},
|
|
2824
2824
|
"230": {
|
|
2825
2825
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/version.nr",
|
|
2826
|
-
"source": "/// The ORACLE_VERSION constant is used to check that the oracle interface is in sync between PXE and Aztec.nr. We need\n/// to version the oracle interface to ensure that developers get a reasonable error message if they use incompatible\n/// versions of Aztec.nr and PXE. The TypeScript counterpart is in `oracle_version.ts`.\n///\n/// @dev Whenever a contract function or Noir test is run, the `utilityAssertCompatibleOracleVersion` oracle is called\n/// and if the oracle version is incompatible an error is thrown.\npub global ORACLE_VERSION: Field =
|
|
2826
|
+
"source": "/// The ORACLE_VERSION constant is used to check that the oracle interface is in sync between PXE and Aztec.nr. We need\n/// to version the oracle interface to ensure that developers get a reasonable error message if they use incompatible\n/// versions of Aztec.nr and PXE. The TypeScript counterpart is in `oracle_version.ts`.\n///\n/// @dev Whenever a contract function or Noir test is run, the `utilityAssertCompatibleOracleVersion` oracle is called\n/// and if the oracle version is incompatible an error is thrown.\npub global ORACLE_VERSION: Field = 12;\n\n/// Asserts that the version of the oracle is compatible with the version expected by the contract.\npub fn assert_compatible_oracle_version() {\n // Safety: This oracle call returns nothing: we only call it to check Aztec.nr and Oracle interface versions are\n // compatible. It is therefore always safe to call.\n unsafe {\n assert_compatible_oracle_version_wrapper();\n }\n}\n\nunconstrained fn assert_compatible_oracle_version_wrapper() {\n assert_compatible_oracle_version_oracle(ORACLE_VERSION);\n}\n\n#[oracle(utilityAssertCompatibleOracleVersion)]\nunconstrained fn assert_compatible_oracle_version_oracle(version: Field) {}\n\nmod test {\n use super::{assert_compatible_oracle_version_oracle, ORACLE_VERSION};\n\n #[test]\n unconstrained fn compatible_oracle_version() {\n assert_compatible_oracle_version_oracle(ORACLE_VERSION);\n }\n\n #[test(should_fail_with = \"Incompatible oracle version. TXE is using version\")]\n unconstrained fn incompatible_oracle_version() {\n let arbitrary_incorrect_version = 318183437;\n assert_compatible_oracle_version_oracle(arbitrary_incorrect_version);\n }\n}\n"
|
|
2827
2827
|
},
|
|
2828
2828
|
"298": {
|
|
2829
2829
|
"path": "/home/aztec-dev/nargo/github.com/noir-lang/poseidon/v0.2.3/src/poseidon2.nr",
|
|
@@ -2845,26 +2845,26 @@
|
|
|
2845
2845
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/salted_initialization_hash.nr",
|
|
2846
2846
|
"source": "use crate::{\n address::aztec_address::AztecAddress, constants::DOM_SEP__PARTIAL_ADDRESS,\n hash::poseidon2_hash_with_separator, traits::ToField,\n};\n\n// Salted initialization hash. Used in the computation of a partial address.\n#[derive(Eq)]\npub struct SaltedInitializationHash {\n pub inner: Field,\n}\n\nimpl ToField for SaltedInitializationHash {\n fn to_field(self) -> Field {\n self.inner\n }\n}\n\nimpl SaltedInitializationHash {\n pub fn from_field(field: Field) -> Self {\n Self { inner: field }\n }\n\n pub fn compute(salt: Field, initialization_hash: Field, deployer: AztecAddress) -> Self {\n SaltedInitializationHash::from_field(poseidon2_hash_with_separator(\n [salt, initialization_hash, deployer.to_field()],\n DOM_SEP__PARTIAL_ADDRESS,\n ))\n }\n\n pub fn assert_is_zero(self) {\n assert(self.to_field() == 0);\n }\n}\n"
|
|
2847
2847
|
},
|
|
2848
|
-
"
|
|
2849
|
-
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
|
|
2850
|
-
"source": "// TODO: Expose other wrapped functions than debug (info, warn)\n// ['silent', 'fatal', 'error', 'warn', 'info', 'verbose', 'debug', 'trace']\n\npub global SILENT_LOG_LEVEL: u8 = 0;\npub global FATAL_LOG_LEVEL: u8 = 1;\npub global ERROR_LOG_LEVEL: u8 = 2;\npub global WARN_LOG_LEVEL: u8 = 3;\npub global INFO_LOG_LEVEL: u8 = 4;\npub global VERBOSE_LOG_LEVEL: u8 = 5;\npub global DEBUG_LOG_LEVEL: u8 = 6;\npub global TRACE_LOG_LEVEL: u8 = 7;\n\n/// Utility function to console.log data in the acir simulator.\n/// Example:\n/// debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n debug_log_format(msg, []);\n}\n\n/// Same as debug_log, but allows to customize the log level.\n/// Consider changing just to 'log'\npub fn debug_log_with_level<let N: u32>(log_level: u8, msg: str<N>) {\n debug_log_format_with_level(log_level, msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n/// debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n/// debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { debug_log_array_oracle_wrapper(DEBUG_LOG_LEVEL, msg, args) };\n}\n\n/// Same as debug_log_format, but allows to customize the log level.\n/// Consider changing just to 'log_format'\npub fn debug_log_format_with_level<let M: u32, let N: u32>(\n log_level: u8,\n msg: str<M>,\n args: [Field; N],\n) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { debug_log_array_oracle_wrapper(log_level, msg, args) };\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` slice.\n/// Examples:\n/// debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n/// debug_log_format(\"whole slice: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format_slice<let M: u32>(log_level: u8, msg: str<M>, args: [Field]) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { debug_log_slice_oracle_wrapper(log_level, msg, args) };\n}\n\n// We provide two versions of the debug log oracle: one that takes args as a slice and another one that takes args as an array.\n// We do this since conversion from array to slice generates overhead in public functions, since opcodes need to be emitted for the conversion.\n// By exposing the two flavors, we avoid conversions since the AVM is able to handle both arrays an slices in this oracle.\n\nunconstrained fn debug_log_slice_oracle_wrapper<let M: u32>(\n log_level: u8,\n msg: str<M>,\n args: [Field],\n) {\n debug_log_slice_oracle(log_level, msg, args);\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(utilityDebugLog)]\nunconstrained fn debug_log_slice_oracle<let M: u32>(log_level: u8, msg: str<M>, args: [Field]) {}\n\nunconstrained fn debug_log_array_oracle_wrapper<let M: u32, let N: u32>(\n log_level: u8,\n msg: str<M>,\n args: [Field; N],\n) {\n debug_log_array_oracle(log_level, msg, N, args);\n}\n\n#[oracle(utilityDebugLog)]\nunconstrained fn debug_log_array_oracle<let M: u32, let N: u32>(\n log_level: u8,\n msg: str<M>,\n length: u32,\n args: [Field; N],\n) {}\n"
|
|
2851
|
-
},
|
|
2852
|
-
"380": {
|
|
2848
|
+
"379": {
|
|
2853
2849
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/delayed_public_mutable/delayed_public_mutable_values.nr",
|
|
2854
2850
|
"source": "use crate::{\n delayed_public_mutable::{\n scheduled_delay_change::ScheduledDelayChange, scheduled_value_change::ScheduledValueChange,\n },\n hash::poseidon2_hash,\n traits::{Hash, Packable},\n utils::arrays,\n};\nuse std::meta::derive;\n\nmod test;\n\n/// DelayedPublicMutableValues is just a wrapper around ScheduledValueChange and ScheduledDelayChange that then allows us\n/// to wrap both of these values in WithHash. WithHash allows for efficient read of values in private.\n///\n/// Note that the WithHash optimization does not work in public (due to there being no unconstrained). But we also want\n/// to be able to read the values efficiently in public and we want to be able to read each value separately. Reading\n/// the values separately is tricky because ScheduledValueChange and ScheduledDelayChange are packed together (sdc and\n/// svc.timestamp_of_change are stored in the same slot). For that reason we expose `unpack_value_change` and\n/// `unpack_delay_change` functions that can be used to extract the values from the packed representation. This\n/// is \"hacky\" but there is no way around it.\n#[derive(Eq)]\npub struct DelayedPublicMutableValues<T, let INITIAL_DELAY: u64> {\n pub svc: ScheduledValueChange<T>,\n pub sdc: ScheduledDelayChange<INITIAL_DELAY>,\n}\n\nimpl<T, let INITIAL_DELAY: u64> DelayedPublicMutableValues<T, INITIAL_DELAY> {\n pub fn new(svc: ScheduledValueChange<T>, sdc: ScheduledDelayChange<INITIAL_DELAY>) -> Self {\n DelayedPublicMutableValues { svc, sdc }\n }\n}\n\n/// Extracts a ScheduledValueChange struct from the packed representation of the full DelayedPublicMutable.\n/// TODO: impl the packable trait for ScheduledValueChange.\npub fn unpack_value_change<T, let M: u32>(packed: [Field; 2 * M + 1]) -> ScheduledValueChange<T>\nwhere\n T: Packable<N = M>,\n{\n let svc_pre_packed = arrays::subarray(packed, 1);\n let svc_post_packed = arrays::subarray(packed, M + 1);\n\n // We first cast to u32 as the timestamp_of_change is packed into the same field as the delay change and it\n // occupies the first 32 bits of the field.\n let timestamp_of_change = (packed[0] as u32) as u64;\n ScheduledValueChange::new(\n T::unpack(svc_pre_packed),\n T::unpack(svc_post_packed),\n timestamp_of_change,\n )\n}\n\n/// Extracts a ScheduledDelayChange struct from 0th field of the packed representation of the full DelayedPublicMutable.\n/// This function expects to be called with just the first field of the packed representation, which contains sdc\n/// and svc timestamp_of_change. We'll discard the svc component.\npub fn unpack_delay_change<let INITIAL_DELAY: u64>(\n packed: Field,\n) -> ScheduledDelayChange<INITIAL_DELAY> {\n // This function expects to be called with just the first field of the packed representation, which contains sdc\n // and svc timestamp_of_change. We'll discard the svc component.\n let svc_timestamp_of_change = packed as u32;\n\n let mut tmp = (packed - svc_timestamp_of_change as Field) / TWO_POW_32;\n let sdc_timestamp_of_change = tmp as u32;\n\n tmp = (tmp - sdc_timestamp_of_change as Field) / TWO_POW_32;\n let sdc_post_is_some = (tmp as u1) != 0;\n\n tmp = (tmp - sdc_post_is_some as Field) / TWO_POW_8;\n let sdc_post_inner = tmp as u32;\n\n tmp = (tmp - sdc_post_inner as Field) / TWO_POW_32;\n let sdc_pre_is_some = (tmp as u1) != 0;\n\n tmp = (tmp - sdc_pre_is_some as Field) / TWO_POW_8;\n let sdc_pre_inner = tmp as u32;\n\n // Note that below we cast the values to u64 as that is the default type of timestamp in the system. Us packing\n // the values as u32 is a tech debt that is not worth tackling.\n ScheduledDelayChange {\n pre: if sdc_pre_is_some {\n Option::some(sdc_pre_inner as u64)\n } else {\n Option::none()\n },\n post: if sdc_post_is_some {\n Option::some(sdc_post_inner as u64)\n } else {\n Option::none()\n },\n timestamp_of_change: sdc_timestamp_of_change as u64,\n }\n}\n\n// Q: do these evaluate at comptime or runtime?\nglobal TWO_POW_32: Field = 2.pow_32(32);\nglobal TWO_POW_8: Field = 2.pow_32(8);\n\n// We pack to `2 * N + 1` fields because ScheduledValueChange contains T twice (hence `2 * N`) and we need one extra\n// field to store ScheduledDelayChange and the timestamp_of_change of ScheduledValueChange.\nimpl<T, let INITIAL_DELAY: u64> Packable for DelayedPublicMutableValues<T, INITIAL_DELAY>\nwhere\n T: Packable,\n{\n let N: u32 = 2 * <T as Packable>::N + 1;\n\n fn pack(self) -> [Field; Self::N] {\n let mut result = [0; Self::N];\n\n // We pack sdc.pre, sdc.post, sdc.timestamp_of_change and svc.timestamp_of_change into a single field as follows:\n // [ sdc.pre_inner: u32 | sdc.pre_is_some: u8 | sdc.post_inner: u32 | sdc.post_is_some: u8 | sdc.timestamp_of_change: u32 | svc.timestamp_of_change: u32 ]\n // Note that the code below no longer works after 2106 as by that time the timestamp will overflow u32. This is a tech debt that is not worth tackling.\n result[0] = self.svc.timestamp_of_change as Field\n + ((self.sdc.timestamp_of_change as Field) * 2.pow_32(32))\n + ((self.sdc.post.is_some() as Field) * 2.pow_32(64))\n + ((self.sdc.post.unwrap_unchecked() as Field) * 2.pow_32(72))\n + ((self.sdc.pre.is_some() as Field) * 2.pow_32(104))\n + ((self.sdc.pre.unwrap_unchecked() as Field) * 2.pow_32(112));\n\n // Pack the pre and post values from ScheduledValueChange\n let svc_pre_packed = self.svc.pre.pack();\n let svc_post_packed = self.svc.post.pack();\n for i in 0..<T as Packable>::N {\n result[i + 1] = svc_pre_packed[i];\n result[i + 1 + <T as Packable>::N] = svc_post_packed[i];\n }\n result\n }\n\n // Note: inefficient if all you want to unpack is the svc; use unpack_value_change instead.\n fn unpack(fields: [Field; Self::N]) -> Self {\n let svc = unpack_value_change::<T, _>(fields);\n let sdc = unpack_delay_change::<INITIAL_DELAY>(fields[0]);\n Self::new(svc, sdc)\n }\n}\n\nimpl<T, let INITIAL_DELAY: u64> Hash for DelayedPublicMutableValues<T, INITIAL_DELAY>\nwhere\n T: Packable,\n{\n fn hash(self) -> Field {\n poseidon2_hash(self.pack())\n }\n}\n"
|
|
2855
2851
|
},
|
|
2856
|
-
"
|
|
2852
|
+
"382": {
|
|
2857
2853
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/delayed_public_mutable/scheduled_delay_change.nr",
|
|
2858
2854
|
"source": "use crate::traits::Empty;\nuse std::cmp::min;\n\nmod test;\n\n// This data structure is used by DelayedPublicMutable to store the minimum delay with which a ScheduledValueChange object can\n// schedule a change.\n// This delay is initially equal to INITIAL_DELAY, and can be safely mutated to any other value over time. This mutation\n// is performed via `schedule_change` in order to satisfy ScheduleValueChange constraints: if e.g. we allowed for the\n// delay to be decreased immediately then it'd be possible for the state variable to schedule a value change with a\n// reduced delay, invalidating prior private reads.\npub struct ScheduledDelayChange<let INITIAL_DELAY: u64> {\n // Both pre and post are stored in public storage, so by default they are zeroed. By wrapping them in an Option,\n // they default to Option::none(), which we detect and replace with INITIAL_DELAY. The end result is that a\n // ScheduledDelayChange that has not been initialized has a delay equal to INITIAL_DELAY, which is the desired\n // effect. Once initialized, the Option will never be none again.\n pub(crate) pre: Option<u64>,\n pub(crate) post: Option<u64>,\n // Timestamp at which `post` value is used instead of `pre`\n pub(crate) timestamp_of_change: u64,\n}\n\nimpl<let INITIAL_DELAY: u64> ScheduledDelayChange<INITIAL_DELAY> {\n pub fn new(pre: Option<u64>, post: Option<u64>, timestamp_of_change: u64) -> Self {\n Self { pre, post, timestamp_of_change }\n }\n\n /// Returns the current value of the delay stored in the data structure.\n /// WARNING: This function only returns a meaningful value when called in public with the current timestamp - for\n /// historical private reads use `get_effective_minimum_delay_at` instead.\n pub fn get_current(self, current_timestamp: u64) -> u64 {\n // The post value becomes the current one at the timestamp of change, so any transaction that is included at or after\n // the timestamp of change will use the post value.\n if current_timestamp < self.timestamp_of_change {\n self.pre.unwrap_or(INITIAL_DELAY)\n } else {\n self.post.unwrap_or(INITIAL_DELAY)\n }\n }\n\n /// Returns the scheduled change, i.e. the post-change delay and the timestamp at which it will become the current\n /// delay. Note that this timestamp may be in the past if the change has already taken place.\n /// Additionally, further changes might be later scheduled, potentially canceling the one returned by this function.\n pub fn get_scheduled(self) -> (u64, u64) {\n (self.post.unwrap_or(INITIAL_DELAY), self.timestamp_of_change)\n }\n\n /// Schedules a change to the delay, given the `current_timestamp` and the `current` delay.\n /// This function is only meaningful when called in public with the current timestamp.\n /// The timestamp at which the new delay will become effective is determined automatically:\n /// - when increasing the delay, the change is effective immediately\n /// - when reducing the delay, the change will take effect after a delay equal to the difference between old and\n /// new delay. For example, if reducing from 3 days to 1 day, the reduction will be scheduled to happen after 2\n /// days.\n pub fn schedule_change(&mut self, new: u64, current_timestamp: u64) {\n let current = self.get_current(current_timestamp);\n\n // When changing the delay value we must ensure that it is not possible to produce a value change with a delay\n // shorter than the current one.\n let time_until_delay_change = if new > current {\n // Increasing the delay value can therefore be done immediately: this does not invalidate prior constraints\n // about how quickly a value might be changed (indeed it strengthens them).\n //\n //\n // Earliest `svc.timestamp_of_change`, Earliest `svc.timestamp_of_change`\n // `current_timestamp` if the delay had remained unchanged immediately after this scheduling fn.\n // v v v\n // ====|==========================================================|==============|==>\n // | | |\n // [------------------`current` delay-------------------------] |\n // | |\n // [-------------------------`new` (longer) delay----------------------------]\n // |\n // [] <--- `time_until_delay_change` is `0`; the change is immediate.\n // |\n // ^\n // The newly-calculated `self.timestamp_of_change` (unchanged)\n\n 0\n } else {\n // Decreasing the delay requires waiting for the difference between current and new delay in order to ensure\n // that overall the current delay is respected.\n //\n //\n // Earliest `svc.timestamp_of_change`,\n // if the delay had remained unchanged\n // AND\n // Earliest `svc.timestamp_of_change`,\n // `current_timestamp` immediately after this scheduling fn.\n // ====|============================|=============================|=================>\n // | |\n // [---------------------`current` delay----------------------]\n // | |\n // [- --`new` (shorter) delay----]\n // | ^\n // [-`time_until_delay_change`--] |\n // | |\n // ^ |\n // The newly-calculated |\n // `self.timestamp_of_change` |\n // |\n // The new `self.timestamp_of_change`\n // is calculated so that these ends\n // align.\n current - new\n };\n\n self.pre = Option::some(current);\n self.post = Option::some(new);\n self.timestamp_of_change = current_timestamp + time_until_delay_change;\n }\n\n /// Returns the minimum delay before a value might mutate due to a scheduled change, from the perspective of some\n /// historical timestamp. It only returns a meaningful value when called in private with historical timestamps.\n /// The output of this function can be passed into `ScheduledValueChange.get_time_horizon` to properly\n /// constrain the `include_by_timestamp` when reading delayed mutable state.\n /// This value typically equals the current delay at the timestamp following the historical one (the earliest one in\n /// which a value change could be scheduled), but it also considers scenarios in which a delay reduction is\n /// scheduled to happen in the near future, resulting in a way to schedule a change with an overall delay lower than\n /// the current one.\n ///\n /// Alternative explanation: returns the maximum amount of time (from the historical timestamp) that a state read\n /// (as at the historical timestamp) will remain valid.\n /// A read might end up being valid for less time in the case where a `svc.timestamp_of_change` has already been\n /// set and if it's sooner than the output of this function. In that case, the `scheduled_value_change.nr`'s\n /// `get_time_horizon` function will realize this.\n ///\n pub fn get_effective_minimum_delay_at(self, historical_timestamp: u64) -> u64 {\n // If a change is scheduled, then the effective delay might be lower than the current one (pre). At the\n // timestamp of change the current delay will be the scheduled one, with an overall delay from the historical\n // timestamp equal to the time until the change plus the new delay. If this value is lower\n // than the current delay, then that is the effective minimum delay.\n\n // If using some block as the anchor block of some tx, then note that if you\n // read a `delayed_mutable` from that anchor block, you're actually reading the\n // `delayed_mutable` _as at the very end_ of that block.\n // Therefore the `delayed_mutable` that you will read _as at the very start of the next\n // block_ will be _the very same_ `delayed_mutable` (nothing can possibly have changed).\n // Therefore the first opportunity to schedule a value change (from the anchor timestamp)\n // is the first tx of that next block, which takes place at least 1 second after the\n // anchor block.\n // So should you choose to go ahead and schedule a value change in the first tx of that\n // next block, it will only take effect after the \"current delay\" (as dictated by the\n // `delayed_mutable` of that tx, which is the same as the `delayed_mutable` as at the\n // anchor timestamp).\n // In all, the time between the anchor block's timestamp and the earliest-possible value\n // timestamp_of_change, is therefore: 1 second + the \"current\" delay (as at the time of\n // the anchor timestamp).\n // Reads must only be valid until _just before_ the earliest-possible value change --\n // i.e. 1 second before the earliest-possible value change.\n // That is, reads are only valid for the \"current\" delay (as at the time of the anchor\n // timestamp) _at most_.\n // (I.e. the read remains valid for 1 + \"current delay\" - 1 = \"current delay\", from the\n // anchor timestamp).\n //\n // ____________ ____________\n // | | | |\n // | Block |<--At least a 1 second gap-->| Block |\n // |____________| |____________|\n // ^ ^\n // | You can schedule a value change from here.\n // |\n // Suppose this is your anchor block.\n // The delayed_mutable (and hence the \"current\" delay) as at the end of this block will\n // be the same as at the start of the next block.\n //\n if self.timestamp_of_change <= historical_timestamp {\n //\n // `self.timestamp_of_change` <= `historical_timestamp`\n // v v\n // ===================|==============================|=========\n // ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n // `self.pre` is |`self.post` takes effect from here.\n // effective before. |\n //\n // So in this `if` case, `self.post` is in effect at the time of the `historical_timestamp`.\n //\n // If no delay changes are scheduled (as at the time of the anchor timestamp), then the\n // \"current delay\" (as at the time of the historical timestamp) is `self.post` (or the\n // INITIAL_DELAY if never set).\n self.post.unwrap_or(INITIAL_DELAY)\n } else {\n //\n // `historical_timestamp` < `self.timestamp_of_change`\n // v\n // ===================|======================|====================================\n // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n // `self.pre` is effective |`self.post` takes effect from here.\n // during this period. |\n //\n // So in this `else` case, `self.pre` is in effect at the time of the `historical_timestamp`.\n //\n // If a delay change _is_ already scheduled (as at the time of the historical timestamp):\n // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n // |________________\n // |\n // v Earliest possible\n // `historical_ Scheduled delay change: `svc.timestamp_of_change`\n // timestamp` < `self.timestamp_of_change` (if not already set [^1])\n // v v v\n // ===||=============================|====================================|================>\n // .| . .\n // .| . .\n // .|__ Earliest possible timestamp at which a .\n // . function could call `schedule_change` for a new .\n // . _value_ change..................................................And the earliest timestamp at\n // . . .which the new value would take effect.\n // .[---------------`self.pre` delay-----------------------------------]\n // . . .\n // [******************************************************************].\n // [ ].\n // [----------------`self.pre` delay----------------------------------].\n // [ ].\n // [ If reading a _value_ at that (<--) anchor timestamp, then the ].\n // [ read will remain valid for this duration, unless a shorter ].\n // [ delay has been scheduled (see just below in this diagram). ].\n // [ If a _deferred, longer_ delay has been scheduled, it might yet ].\n // [ still be cancelled, in which case this `pre` delay would ].\n // [ bite (see the `min` calc below) -- meaning reads would remain ].\n // [ valid for this duration. ].\n // [ ].\n // [******************************************************************].\n // . . .\n // . . .\n // [---`time_until_delay_change`--] .\n // . . .\n // . . .\n // . . .\n // SCENARIO 1: scheduled delay is shorter than the `self.pre` delay: .\n // . . .\n // . . .\n // . [-`self.post` delay-] .\n // . . (if shorter ^^ .\n // . . than `pre`) ||_ new values can take effect from here.\n // . . |\n // . . |_ reads are only valid until here:\n // . . . `historic_timestamp + time_until_delay_change + self.post - 1`\n // . . . .\n // [*************************************************] .\n // [ ] .\n // [----`time_until_delay_change + self.post - 1`----] .\n // [ ] .\n // [ If reading a _value_ at that (<--) anchor ] .\n // [ timestamp, then the read will remain valid ] .\n // [ for this duration: ] .\n // [ ] .\n // [*************************************************] .\n // . . .\n // . . .\n // . . .\n // SCENARIO 2: scheduled delay is longer than the `self.pre` delay, AND is deferred:\n // (note: scheduling deferred delay changes is not yet possible)\n // . . .\n // . . .\n // . [-`self.post` delay (if longer than `pre` & deferred)------------------]\n // . . (scheduling deferred delay changes is not yet possible) ^^\n // . . ||\n // . . reads would only be valid until here:___________________________||\n // . . `historic_timestamp + time_until_delay_change + self.post - 1` |\n // . . |\n // . . new values would take effect from here,_______|\n // . . but only once this longer delay takes effect .\n // . . . .\n // . . . .\n // [****************************************************************************************************].\n // [ ].\n // [----`time_until_delay_change + self.post - 1`-------------------------------------------------------].\n // [ ].\n // [ Given a longer, deferred delay, then if reading a _value_ at that (<--) historical timestamp, then ].\n // [ you might think the read would remain valid for this duration. ].\n // [ BUT, in this case of this deferred, longer-than-`self.pre` delay, the `pre` delay ends sooner (by ].\n // [ construction) (see above in this diagram). ].\n // [ And since this scheduled delay (`post`) can be cancelled up until the time it takes effect, ].\n // [ any reads as at that (<--) historical timestamp would cautiously only be valid until the earlier ].\n // [ `pre` delay expiry. ].\n // [ ].\n // [****************************************************************************************************].\n //\n //\n //\n // [^1] If a svc.timestamp_of_change has already been set, and if it's sooner than the\n // output of this function, then it will bite within `scheduled_value_change.nr`'s\n // `get_time_horizon` function.\n let time_until_delay_change = self.timestamp_of_change - historical_timestamp;\n\n min(\n self.pre.unwrap_or(INITIAL_DELAY), // in case the scheduled delay (`post`) gets cancelled before it takes effect.\n time_until_delay_change + self.post.unwrap_or(INITIAL_DELAY) - 1,\n )\n }\n }\n}\n\nimpl<let INITIAL_DELAY: u64> Eq for ScheduledDelayChange<INITIAL_DELAY> {\n fn eq(self, other: Self) -> bool {\n (self.pre == other.pre)\n & (self.post == other.post)\n & (self.timestamp_of_change == other.timestamp_of_change)\n }\n}\n\nimpl<let INITIAL_DELAY: u64> Empty for ScheduledDelayChange<INITIAL_DELAY> {\n fn empty() -> Self {\n Self { pre: Option::none(), post: Option::none(), timestamp_of_change: 0 }\n }\n}\n"
|
|
2859
2855
|
},
|
|
2860
|
-
"
|
|
2856
|
+
"384": {
|
|
2861
2857
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/delayed_public_mutable/scheduled_value_change.nr",
|
|
2862
2858
|
"source": "use crate::traits::Empty;\nuse std::cmp::min;\n\nmod test;\n\n// This data structure is used by DelayedPublicMutable to represent a value that changes from `pre` to `post` at some timestamp\n// called the `timestamp_of_change`. The value can only be made to change by scheduling a change event at some future\n// timestamp after some minimum delay measured in seconds has elapsed. This means that at any given timestamp we know\n// both the current value and the smallest timestamp at which the value might change - this is called the\n// 'time horizon'.\npub struct ScheduledValueChange<T> {\n pub(crate) pre: T,\n pub(crate) post: T,\n // Timestamp at which `post` value is used instead of `pre`\n pub(crate) timestamp_of_change: u64,\n}\n\nimpl<T> ScheduledValueChange<T> {\n pub fn new(pre: T, post: T, timestamp_of_change: u64) -> Self {\n Self { pre, post, timestamp_of_change }\n }\n\n /// Returns the value stored in the data structure at a given timestamp. This function can be called both in public\n /// (where `timestamp` is simply the current timestamp, i.e. the timestamp at which the current transaction will be\n /// included) and in private (where `timestamp` is the anchor block's timestamp). Reading in private is only safe\n /// if the transaction's `include_by_timestamp` property is set to a value lower or equal to the time horizon (see\n /// `get_time_horizon()`).\n pub fn get_current_at(self, timestamp: u64) -> T {\n // The post value becomes the current one at the timestamp of change. This means different things in each realm:\n // - in public, any transaction that is included at the timestamp of change will use the post value\n // - in private, any transaction that includes the timestamp of change as part of the historical state will use\n // the post value (barring any follow-up changes)\n if timestamp < self.timestamp_of_change {\n self.pre\n } else {\n self.post\n }\n }\n\n /// Returns the scheduled change, i.e. the post-change value and the timestamp at which it will become the current\n /// value. Note that this timestamp may be in the past if the change has already taken place.\n /// Additionally, further changes might be later scheduled, potentially canceling the one returned by this function.\n pub fn get_scheduled(self) -> (T, u64) {\n (self.post, self.timestamp_of_change)\n }\n\n // Returns the previous value. This is the value that is current up until the timestamp of change. Note that this\n // value might not be the current anymore since timestamp of change might have already passed.\n pub fn get_previous(self) -> (T, u64) {\n (self.pre, self.timestamp_of_change)\n }\n\n /// Returns the largest timestamp at which the value returned by `get_current_at` is known to remain the current\n /// value. This value is only meaningful in private where the proof is constructed against an anchor block, since\n /// due to its asynchronous nature private execution cannot know about any later scheduled changes.\n /// The caller of this function must know how quickly the value can change due to a scheduled change in the form of\n /// `minimum_delay`. If the delay itself is immutable, then this is just its duration. If the delay is mutable\n /// however, then this value is the 'effective minimum delay' (obtained by calling\n /// `ScheduledDelayChange.get_effective_minimum_delay_at`), which equals the minimum time in seconds that needs to\n /// elapse from the next block's timestamp until the value changes, regardless of further delay changes.\n /// The value returned by `get_current_at` in private when called with a anchor block's timestamp is only safe to use\n /// if the transaction's `include_by_timestamp` property is set to a value lower or equal to the time horizon\n /// computed using the same anchor timestamp.\n pub fn get_time_horizon(self, anchor_timestamp: u64, minimum_delay: u64) -> u64 {\n // The time horizon is the very last timestamp in which the current value is known. Any timestamp past the\n // horizon (i.e. with a timestamp larger than the time horizon) may have a different current value.\n // Reading the current value in private typically requires constraining the maximum valid timestamp to be equal\n // to the time horizon.\n if anchor_timestamp >= self.timestamp_of_change {\n // Once the timestamp of change has passed (block with timestamp >= timestamp_of_change was mined),\n // the current value (post) will not change unless a new value change is scheduled. This did not happen at\n // the anchor timestamp (or else it would not be greater or equal to the timestamp of change), and\n // therefore could only happen after the anchor timestamp. The earliest would be the immediate next\n // timestamp, and so the smallest possible next timestamp of change equals `anchor_timestamp + 1 +\n // minimum_delay`. Our time horizon is simply the previous timestamp to that one.\n //\n // timestamp of anchor\n // change timestamp time horizon\n // =======|=============N===================H===========>\n // ^ ^\n // ---------------------\n // minimum delay\n anchor_timestamp + minimum_delay\n } else {\n // If the timestamp of change has not yet been reached however, then there are two possible scenarios.\n // a) It could be so far into the future that the time horizon is actually determined by the minimum\n // delay, because a new change could be scheduled and take place _before_ the currently scheduled one.\n // This is similar to the scenario where the timestamp of change is in the past: the time horizon is\n // the timestamp prior to the earliest one in which a new timestamp of change might land.\n //\n // anchor\n // timestamp time horizon timestamp of change\n // =====N=================================H=================|=========>\n // ^ ^\n // | |\n // -----------------------------------\n // minimum delay\n //\n // b) It could be fewer than `minimum_delay` seconds away from the anchor timestamp, in which case\n // the timestamp of change would become the limiting factor for the time horizon, which would equal\n // the timestamp right before the timestamp of change (since by definition the value changes at the\n // timestamp of change).\n //\n // anchor time horizon\n // timestamp timestamp of change if not scheduled\n // =======N=============|===================H=================>\n // ^ ^ ^\n // | actual horizon |\n // -----------------------------------\n // minimum delay\n //\n // Note that the current implementation does not allow the caller to set the timestamp of change to an\n // arbitrary value, and therefore scenario a) is not currently possible. However implementing #5501 would\n // allow for this to happen.\n // Because anchor_timestamp < self.timestamp_of_change, then timestamp_of_change > 0 and we can safely\n // subtract 1.\n min(\n self.timestamp_of_change - 1,\n anchor_timestamp + minimum_delay,\n )\n }\n }\n\n /// Mutates the value by scheduling a change at the current timestamp. This function is only meaningful when\n /// called in public with the current timestamp.\n pub fn schedule_change(\n &mut self,\n new_value: T,\n current_timestamp: u64,\n minimum_delay: u64,\n timestamp_of_change: u64,\n ) {\n assert(timestamp_of_change >= current_timestamp + minimum_delay);\n\n self.pre = self.get_current_at(current_timestamp);\n self.post = new_value;\n self.timestamp_of_change = timestamp_of_change;\n }\n}\n\nimpl<T> Eq for ScheduledValueChange<T>\nwhere\n T: Eq,\n{\n fn eq(self, other: Self) -> bool {\n (self.pre == other.pre)\n & (self.post == other.post)\n & (self.timestamp_of_change == other.timestamp_of_change)\n }\n}\n\nimpl<T> Empty for ScheduledValueChange<T>\nwhere\n T: Empty,\n{\n fn empty() -> Self {\n Self { pre: T::empty(), post: T::empty(), timestamp_of_change: 0 }\n }\n}\n"
|
|
2863
2859
|
},
|
|
2864
|
-
"
|
|
2860
|
+
"387": {
|
|
2865
2861
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
|
|
2866
2862
|
"source": "mod poseidon2_chunks;\n\nuse crate::{\n abis::{\n contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n function_selector::FunctionSelector,\n note_hash::NoteHash,\n nullifier::Nullifier,\n private_log::{PrivateLog, PrivateLogData},\n transaction::tx_request::TxRequest,\n },\n address::{AztecAddress, EthAddress},\n constants::{\n CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, DOM_SEP__NOTE_HASH_NONCE,\n DOM_SEP__PRIVATE_LOG_FIRST_FIELD, DOM_SEP__SILOED_NOTE_HASH, DOM_SEP__SILOED_NULLIFIER,\n DOM_SEP__UNIQUE_NOTE_HASH, FUNCTION_TREE_HEIGHT, NULL_MSG_SENDER_CONTRACT_ADDRESS,\n TWO_POW_64,\n },\n merkle_tree::root_from_sibling_path,\n messaging::l2_to_l1_message::L2ToL1Message,\n poseidon2::Poseidon2Sponge,\n side_effect::{Counted, Scoped},\n traits::{FromField, Hash, ToField},\n utils::field::{field_from_bytes, field_from_bytes_32_trunc},\n};\n\npub use poseidon2_chunks::poseidon2_absorb_in_chunks_existing_sponge;\nuse poseidon2_chunks::poseidon2_absorb_in_chunks;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\n// TODO: refactor these into their own files: sha256, poseidon2, some protocol-specific hash computations, some merkle computations.\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n let sha256_hashed = sha256::digest(bytes_to_hash);\n let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n selector: FunctionSelector,\n vk_hash: Field,\n function_leaf_index: Field,\n function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n let function_leaf = function_leaf_preimage.hash();\n root_from_sibling_path(\n function_leaf,\n function_leaf_index,\n function_leaf_sibling_path,\n )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n // unique).\n poseidon2_hash_with_separator(\n [first_nullifier_in_tx, note_index_in_tx as Field],\n DOM_SEP__NOTE_HASH_NONCE,\n )\n}\n\npub fn compute_unique_note_hash(note_nonce: Field, siloed_note_hash: Field) -> Field {\n let inputs = [note_nonce, siloed_note_hash];\n poseidon2_hash_with_separator(inputs, DOM_SEP__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_note_nonce_and_unique_note_hash(\n siloed_note_hash: Field,\n first_nullifier: Field,\n note_index_in_tx: u32,\n) -> Field {\n let note_nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n compute_unique_note_hash(note_nonce, siloed_note_hash)\n}\n\npub fn compute_siloed_note_hash(contract_address: AztecAddress, note_hash: Field) -> Field {\n poseidon2_hash_with_separator(\n [contract_address.to_field(), note_hash],\n DOM_SEP__SILOED_NOTE_HASH,\n )\n}\n\n/// Computes unique, siloed note hashes from siloed note hashes.\n///\n/// The protocol injects uniqueness into every note_hash, so that every single note_hash in the\n/// tree is unique. This prevents faerie gold attacks, where a malicious sender could create\n/// two identical note_hashes for a recipient (meaning only one would be nullifiable in future).\n///\n/// Most privacy protocols will inject the note's leaf_index (its position in the Note Hashes Tree)\n/// into the note, but this requires the creator of a note to wait until their tx is included in\n/// a block to know the note's final note hash (the unique, siloed note hash), because inserting\n/// leaves into trees is the job of a block producer.\n///\n/// We took a different approach so that the creator of a note will know each note's unique, siloed\n/// note hash before broadcasting their tx to the network.\n/// (There was also a historical requirement relating to \"chained transactions\" -- a feature that\n/// Aztec Connect had to enable notes to be spent from distinct txs earlier in the same block,\n/// and hence before an archive block root had been established for that block -- but that feature\n/// was abandoned for the Aztec Network for having too many bad tradeoffs).\n///\n/// (\n/// Edit: it is no longer true that all final note_hashes will be known by the creator of a tx\n/// before they send it to the network. If a tx makes public function calls, then _revertible_\n/// note_hashes that are created in private will not be made unique in private by the Reset circuit,\n/// but will instead be made unique by the AVM, because the `note_index_in_tx` will not be known\n/// until the AVM has executed the public functions of the tx. (See an explanation in\n/// reset_output_composer.nr for why).\n/// For some such txs, the `note_index_in_tx` might still be predictable through simulation, but\n/// for txs whose public functions create a varying number of non-revertible notes (determined at\n/// runtime), the `note_index_in_tx` will not be deterministically derivable before submitting the\n/// tx to the network.\n/// )\n///\n/// We use the `first_nullifier` of a tx as a seed of uniqueness. We have a guarantee that there will\n/// always be at least one nullifier per tx, because the init circuit will create one if one isn't\n/// created naturally by any functions of the tx. (Search \"protocol_nullifier\").\n/// We combine the `first_nullifier` with the note's index (its position within this tx's new\n/// note_hashes array) (`note_index_in_tx`) to get a truly unique value to inject into a note, which\n/// we call a `note_nonce`.\npub fn compute_unique_siloed_note_hash(\n siloed_note_hash: Field,\n first_nullifier: Field,\n note_index_in_tx: u32,\n) -> Field {\n if siloed_note_hash == 0 {\n 0\n } else {\n compute_note_nonce_and_unique_note_hash(siloed_note_hash, first_nullifier, note_index_in_tx)\n }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: Scoped<Counted<NoteHash>>) -> Field {\n if note_hash.contract_address.is_zero() {\n 0\n } else {\n compute_siloed_note_hash(note_hash.contract_address, note_hash.innermost())\n }\n}\n\npub fn compute_siloed_nullifier(contract_address: AztecAddress, nullifier: Field) -> Field {\n poseidon2_hash_with_separator(\n [contract_address.to_field(), nullifier],\n DOM_SEP__SILOED_NULLIFIER,\n )\n}\n\npub fn silo_nullifier(nullifier: Scoped<Counted<Nullifier>>) -> Field {\n let value = nullifier.innermost().value;\n // Q: shouldn't we be checking whether the _whole_ scoped, counted, nullifier struct is empty?\n // A: We don't have to. The init and inner circuits add a contract address only to non-empty nullifiers.\n // So we know we should silo it if the contract address is not empty.\n if nullifier.contract_address.is_zero() {\n // Return `.value` instead of 0, because already-siloed nullifiers also have a zero\n // contract_address field, and we of course want to return that already-siloed nullifier\n // (we just don't want to silo it a second time).\n value\n } else {\n compute_siloed_nullifier(nullifier.contract_address, value)\n }\n}\n\npub fn create_protocol_nullifier(tx_request: TxRequest) -> Scoped<Counted<Nullifier>> {\n // The protocol nullifier is ascribed a special side-effect counter of 1. No other side-effect\n // can have counter 1 (see `validate_as_first_call` for that assertion).\n Nullifier { value: tx_request.hash(), note_hash: 0 }.count(1).scope(\n NULL_MSG_SENDER_CONTRACT_ADDRESS,\n )\n}\n\npub fn compute_siloed_private_log_first_field(\n contract_address: AztecAddress,\n field: Field,\n) -> Field {\n poseidon2_hash_with_separator(\n [contract_address.to_field(), field],\n DOM_SEP__PRIVATE_LOG_FIRST_FIELD,\n )\n}\n\npub fn silo_private_log(private_log: Scoped<Counted<PrivateLogData>>) -> PrivateLog {\n let log = private_log.innermost().log;\n if private_log.contract_address.is_zero() {\n log\n } else {\n let mut fields = log.fields;\n fields[0] = compute_siloed_private_log_first_field(private_log.contract_address, fields[0]);\n PrivateLog::new(fields, log.length)\n }\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n poseidon2_hash(log)\n}\n\npub fn compute_app_siloed_secret_key(\n master_secret_key: EmbeddedCurveScalar,\n app_address: AztecAddress,\n app_secret_key_domain_separator: Field,\n) -> Field {\n poseidon2_hash_with_separator(\n [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n app_secret_key_domain_separator,\n )\n}\n\npub fn compute_l2_to_l1_hash(\n contract_address: AztecAddress,\n recipient: EthAddress,\n content: Field,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n let contract_address_bytes: [u8; 32] = contract_address.to_field().to_be_bytes();\n let recipient_bytes: [u8; 20] = recipient.to_be_bytes();\n let content_bytes: [u8; 32] = content.to_be_bytes();\n let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n let mut bytes: [u8; 148] = std::mem::zeroed();\n for i in 0..32 {\n bytes[i] = contract_address_bytes[i];\n bytes[i + 32] = rollup_version_id_bytes[i];\n // 64 - 84 are for recipient.\n bytes[i + 84] = chain_id_bytes[i];\n bytes[i + 116] = content_bytes[i];\n }\n\n for i in 0..20 {\n bytes[64 + i] = recipient_bytes[i];\n }\n\n sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n msg: Scoped<L2ToL1Message>,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n if msg.contract_address.is_zero() {\n 0\n } else {\n compute_l2_to_l1_hash(\n msg.contract_address,\n msg.inner.recipient,\n msg.inner.content,\n rollup_version_id,\n chain_id,\n )\n }\n}\n\n// TODO: consider a variant that enables domain separation with a u32 (we seem to have standardised u32s for domain separators)\n/// Computes sha256 hash of 2 input fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256(v0: Field, v1: Field) -> Field {\n // Concatenate two fields into 32 x 2 = 64 bytes\n let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n let hash_input_flattened = v0_as_bytes.concat(v1_as_bytes);\n\n sha256_to_field(hash_input_flattened)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n T: ToField,\n{\n let inputs_with_separator = [separator.to_field()].concat(inputs);\n poseidon2_hash(inputs_with_separator)\n}\n\n/// Computes a Poseidon2 hash over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// The caller is responsible for ensuring that the input is padded with zeros if required.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n sponge.squeeze()\n}\n\n// NB the below is the same as poseidon::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n sponge.squeeze()\n}\n\n// This function is unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n inputs: BoundedVec<Field, N>,\n separator: T,\n) -> Field\nwhere\n T: ToField,\n{\n let in_len = inputs.len() + 1;\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n sponge.absorb(separator.to_field());\n\n for i in 0..inputs.len() {\n sponge.absorb(inputs.get(i));\n }\n\n sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n let mut fields = [0; (N + 30) / 31];\n let mut field_index = 0;\n let mut current_field = [0; 31];\n for i in 0..inputs.len() {\n let index = i % 31;\n current_field[index] = inputs[i];\n if index == 30 {\n fields[field_index] = field_from_bytes(current_field, false);\n current_field = [0; 31];\n field_index += 1;\n }\n }\n if field_index != fields.len() {\n fields[field_index] = field_from_bytes(current_field, false);\n }\n poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n let mut fixed_input = [3; 501];\n assert(in_len == fixed_input.len()); // sanity check\n for i in 0..in_len {\n input[i] = 3;\n }\n let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n for i in 0..in_len {\n input[i] = 3;\n }\n let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(input, in_len);\n assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n let full_buffer = [\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n ];\n let result = sha256_to_field(full_buffer);\n\n assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n let result_bytes = sha256::digest(full_buffer);\n let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n assert(truncated_field == result);\n let mod_res = result + (result_bytes[31] as Field);\n assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n // All zeroes\n let hash_result =\n compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n assert(hash_result == 0x3b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992);\n\n // Non-zero case\n let hash_result = compute_l2_to_l1_hash(\n AztecAddress::from_field(1),\n EthAddress::from_field(3),\n 5,\n 2,\n 4,\n );\n assert(hash_result == 0xaab2a5828156782b12a1dc6f336e2bc627eb1b9514b02d511f66296990c050);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n let version = 4;\n let chainId = 5;\n\n let hash = silo_l2_to_l1_message(\n L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n AztecAddress::from_field(3),\n ),\n version,\n chainId,\n );\n\n // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n let l2_to_l1_message_hash_from_ts =\n 0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n assert_eq(hash, l2_to_l1_message_hash_from_ts);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n let separator = 42;\n\n // Hash using bounded vec version\n let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n // Hash using regular version\n let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n // Results should match\n assert_eq(bounded_result, regular_result);\n}\n"
|
|
2867
2863
|
},
|
|
2864
|
+
"389": {
|
|
2865
|
+
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/logging.nr",
|
|
2866
|
+
"source": "// Log levels matching the JS logger:\n\n// global SILENT_LOG_LEVEL: u8 = 0;\nglobal FATAL_LOG_LEVEL: u8 = 1;\nglobal ERROR_LOG_LEVEL: u8 = 2;\nglobal WARN_LOG_LEVEL: u8 = 3;\nglobal INFO_LOG_LEVEL: u8 = 4;\nglobal VERBOSE_LOG_LEVEL: u8 = 5;\nglobal DEBUG_LOG_LEVEL: u8 = 6;\nglobal TRACE_LOG_LEVEL: u8 = 7;\n\n// --- Per-level log functions (no format args) ---\n\npub fn fatal_log<let N: u32>(msg: str<N>) {\n fatal_log_format(msg, []);\n}\n\npub fn error_log<let N: u32>(msg: str<N>) {\n error_log_format(msg, []);\n}\n\npub fn warn_log<let N: u32>(msg: str<N>) {\n warn_log_format(msg, []);\n}\n\npub fn info_log<let N: u32>(msg: str<N>) {\n info_log_format(msg, []);\n}\n\npub fn verbose_log<let N: u32>(msg: str<N>) {\n verbose_log_format(msg, []);\n}\n\npub fn debug_log<let N: u32>(msg: str<N>) {\n debug_log_format(msg, []);\n}\n\npub fn trace_log<let N: u32>(msg: str<N>) {\n trace_log_format(msg, []);\n}\n\n// --- Per-level log functions (with format args) ---\n\npub fn fatal_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n log_format(FATAL_LOG_LEVEL, msg, args);\n}\n\npub fn error_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n log_format(ERROR_LOG_LEVEL, msg, args);\n}\n\npub fn warn_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n log_format(WARN_LOG_LEVEL, msg, args);\n}\n\npub fn info_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n log_format(INFO_LOG_LEVEL, msg, args);\n}\n\npub fn verbose_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n log_format(VERBOSE_LOG_LEVEL, msg, args);\n}\n\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n log_format(DEBUG_LOG_LEVEL, msg, args);\n}\n\npub fn trace_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n log_format(TRACE_LOG_LEVEL, msg, args);\n}\n\nfn log_format<let M: u32, let N: u32>(log_level: u8, msg: str<M>, args: [Field; N]) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { log_oracle_wrapper(log_level, msg, args) };\n}\n\nunconstrained fn log_oracle_wrapper<let M: u32, let N: u32>(\n log_level: u8,\n msg: str<M>,\n args: [Field; N],\n) {\n log_oracle(log_level, msg, N, args);\n}\n\n#[oracle(utilityLog)]\nunconstrained fn log_oracle<let M: u32, let N: u32>(\n log_level: u8,\n msg: str<M>,\n length: u32,\n args: [Field; N],\n) {}\n"
|
|
2867
|
+
},
|
|
2868
2868
|
"403": {
|
|
2869
2869
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/point.nr",
|
|
2870
2870
|
"source": "pub use std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse crate::{hash::poseidon2_hash, traits::{Deserialize, Empty, Hash, Packable, Serialize}};\n\npub global POINT_LENGTH: u32 = 3;\n\nimpl Hash for Point {\n fn hash(self) -> Field {\n poseidon2_hash(self.serialize())\n }\n}\n\nimpl Empty for Point {\n /// Note: Does not return a valid point on curve - instead represents an empty/\"unpopulated\" point struct (e.g.\n /// empty/unpopulated value in an array of points).\n fn empty() -> Self {\n Point { x: 0, y: 0, is_infinite: false }\n }\n}\n\npub fn validate_on_curve(p: Point) {\n // y^2 == x^3 - 17\n let x = p.x;\n let y = p.y;\n if p.is_infinite {\n // Assert the canonical representation of infinity\n assert_eq(x, 0, \"Point at infinity should have canonical representation (0 0)\");\n assert_eq(y, 0, \"Point at infinity should have canonical representation (0 0)\");\n } else {\n assert_eq(y * y, x * x * x - 17, \"Point not on curve\");\n }\n}\n\n// TODO(#11356): use compact representation here.\nimpl Packable for Point {\n let N: u32 = POINT_LENGTH;\n\n fn pack(self) -> [Field; Self::N] {\n self.serialize()\n }\n\n fn unpack(packed: [Field; Self::N]) -> Self {\n Self::deserialize(packed)\n }\n}\n\nmod tests {\n use super::validate_on_curve;\n use std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\n #[test]\n unconstrained fn test_validate_on_curve_generator() {\n // The generator point should be on the curve\n let generator = Point::generator();\n validate_on_curve(generator);\n }\n\n #[test]\n unconstrained fn test_validate_on_curve_infinity() {\n // Canonical infinite point (x=0, y=0) should pass\n let infinity = Point { x: 0, y: 0, is_infinite: true };\n validate_on_curve(infinity);\n }\n\n #[test(should_fail_with = \"Point not on curve\")]\n unconstrained fn test_validate_on_curve_invalid_point() {\n // A point not on the curve should fail\n let invalid = Point { x: 1, y: 1, is_infinite: false };\n validate_on_curve(invalid);\n }\n\n #[test(should_fail_with = \"Point at infinity should have canonical representation (0 0)\")]\n unconstrained fn test_validate_on_curve_infinity_non_canonical_x() {\n // Infinite point with non-zero x should fail\n let invalid_infinity = Point { x: 1, y: 0, is_infinite: true };\n validate_on_curve(invalid_infinity);\n }\n\n #[test(should_fail_with = \"Point at infinity should have canonical representation (0 0)\")]\n unconstrained fn test_validate_on_curve_infinity_non_canonical_y() {\n // Infinite point with non-zero y should fail\n let invalid_infinity = Point { x: 0, y: 1, is_infinite: true };\n validate_on_curve(invalid_infinity);\n }\n}\n"
|
|
@@ -2911,7 +2911,7 @@
|
|
|
2911
2911
|
},
|
|
2912
2912
|
"51": {
|
|
2913
2913
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/contract_instance_registry_contract/src/main.nr",
|
|
2914
|
-
"source": "/**\n * @title ContractInstanceRegistry Contract\n * @notice Manages the registration and updating of contract instances\n * @dev This contract allows deploying new contract instances and updating their class IDs\n */\npub contract ContractInstanceRegistry {\n use aztec::{\n context::{PrivateContext, PublicContext},\n hash::hash_args,\n nullifier::utils::compute_nullifier_existence_request,\n oracle::{avm, debug_log::debug_log_format, version::assert_compatible_oracle_version},\n protocol::{\n abis::function_selector::FunctionSelector,\n address::{AztecAddress, PartialAddress},\n constants::{\n CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS, CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE, DEFAULT_UPDATE_DELAY, MINIMUM_UPDATE_DELAY,\n },\n contract_class_id::ContractClassId,\n point::validate_on_curve,\n public_keys::PublicKeys,\n traits::{Deserialize, Serialize, ToField},\n utils::reader::Reader,\n },\n state_vars::{DelayedPublicMutable, Map, StateVariable},\n };\n\n #[abi(events)]\n struct ContractInstancePublished {\n CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE: Field,\n address: AztecAddress,\n version: u8,\n salt: Field,\n contract_class_id: ContractClassId,\n initialization_hash: Field,\n public_keys: PublicKeys,\n deployer: AztecAddress,\n }\n\n // We need to impl this separately because ts deserializes a point as two fields only.\n // We had issues that:\n // Notice how the 'is_infinite' field is deserialized as the next point.\n // {\n // masterNullifierPublicKey: Point {\n // x: Fr<0x0000000000000000000000000000000000000000000000000000000000000012>,\n // y: Fr<0x0000000000000000000000000000000000000000000000000000000000000034>,\n // isInfinite: false,\n // kind: 'point'\n // },\n // masterIncomingViewingPublicKey: Point {\n // x: Fr<0x0000000000000000000000000000000000000000000000000000000000000000>,\n // y: Fr<0x0000000000000000000000000000000000000000000000000000000000000056>,\n // isInfinite: false,\n // kind: 'point'\n // },\n // masterOutgoingViewingPublicKey: Point {\n // x: Fr<0x0000000000000000000000000000000000000000000000000000000000000078>,\n // y: Fr<0x0000000000000000000000000000000000000000000000000000000000000000>,\n // isInfinite: false,\n // kind: 'point'\n // },\n // masterTaggingPublicKey: Point {\n // x: Fr<0x0000000000000000000000000000000000000000000000000000000000000910>,\n // y: Fr<0x0000000000000000000000000000000000000000000000000000000000001112>,\n // isInfinite: false,\n // kind: 'point'\n // }\n\n impl ContractInstancePublished {\n fn serialize_non_standard(self) -> [Field; 15] {\n [\n self.CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n self.address.to_field(),\n self.version.to_field(),\n self.salt,\n self.contract_class_id.to_field(),\n self.initialization_hash,\n self.public_keys.npk_m.serialize()[0],\n self.public_keys.npk_m.serialize()[1],\n self.public_keys.ivpk_m.serialize()[0],\n self.public_keys.ivpk_m.serialize()[1],\n self.public_keys.ovpk_m.serialize()[0],\n self.public_keys.ovpk_m.serialize()[1],\n self.public_keys.tpk_m.serialize()[0],\n self.public_keys.tpk_m.serialize()[1],\n self.deployer.to_field(),\n ]\n }\n }\n\n #[abi(events)]\n #[derive(Serialize)]\n struct ContractInstanceUpdated {\n CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE: Field,\n address: AztecAddress,\n prev_contract_class_id: ContractClassId,\n new_contract_class_id: ContractClassId,\n timestamp_of_change: u64,\n }\n\n struct Storage<Context> {\n updated_class_ids: Map<AztecAddress, DelayedPublicMutable<ContractClassId, DEFAULT_UPDATE_DELAY, Context>, Context>,\n }\n\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_private]\n fn publish_for_public_execution(\n inputs: aztec::context::inputs::PrivateContextInputs,\n salt: Field,\n contract_class_id: ContractClassId,\n initialization_hash: Field,\n public_keys: PublicKeys,\n universal_deploy: bool,\n ) -> return_data aztec::protocol::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {\n // MACRO CODE START\n // Note: The macros initially inserted a phase check here, but since there is no phase change in this function\n // body, I have removed that check.\n assert_compatible_oracle_version();\n\n let serialized_params: [Field; 16] = [\n salt,\n contract_class_id.to_field(),\n initialization_hash,\n ]\n .concat(public_keys.serialize())\n .concat([universal_deploy.to_field()]);\n\n let args_hash: Field = hash_args(serialized_params);\n let mut context: PrivateContext = PrivateContext::new(inputs, args_hash);\n // MACRO CODE END\n\n // Verify that the contract class is registered\n let nullifier_existence_request = compute_nullifier_existence_request(\n contract_class_id.to_field(),\n CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,\n );\n context.assert_nullifier_exists(nullifier_existence_request);\n\n // Determine the deployer based on universal_deploy flag\n let deployer = if universal_deploy {\n AztecAddress::zero()\n } else {\n context.maybe_msg_sender().unwrap()\n };\n\n let partial_address =\n PartialAddress::compute(contract_class_id, salt, initialization_hash, deployer);\n\n // Note: Out of all the public keys, only the Ivpk_m is checked to be on the curve\n // (implicitly as part of the `add` operation of deriving the address). This at least\n // protects the AVM against DoS attacks.\n // For thoroughness, we also ensure the other points are on the curve:\n validate_on_curve(public_keys.npk_m.inner);\n validate_on_curve(public_keys.ovpk_m.inner);\n validate_on_curve(public_keys.tpk_m.inner);\n\n let address = AztecAddress::compute(public_keys, partial_address);\n\n // Emit the address as a nullifier:\n // - to demonstrate that this contract instance hasn't been published before\n // - to enable apps to read that this contract instance has been published.\n context.push_nullifier(address.to_field());\n\n // Emit the deployment event\n let event = ContractInstancePublished {\n CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n contract_class_id,\n address,\n public_keys,\n initialization_hash,\n salt,\n deployer,\n version: 1,\n };\n let payload = event.serialize_non_standard();\n debug_log_format(\"ContractInstancePublished: {}\", payload);\n let padded_log = payload.concat([0; 3]);\n let length = payload.len();\n context.emit_private_log(padded_log, length);\n\n // MACRO CODE START\n context.finish()\n // MACRO CODE END\n }\n\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n unconstrained fn update(new_contract_class_id: ContractClassId) {\n // MACRO CODE START\n let context: PublicContext = PublicContext::new(\n || -> Field {\n let serialized_args: [Field; 1] =\n avm::calldata_copy(1, <ContractClassId as Serialize>::N);\n hash_args(serialized_args)\n },\n );\n let storage: Storage<PublicContext> = Storage::init(context);\n // MACRO CODE END\n\n let address = context.maybe_msg_sender().unwrap();\n\n // Safety: we're using the nullifier's existence as a guarantee of the availability of the contract's\n // information through publishing, which is safe - we just need this information to be _eventually_ available.\n assert(\n context.nullifier_exists_unsafe(address.to_field(), context.this_address()),\n \"msg.sender is not deployed\",\n );\n\n // Safety: we're using the nullifier's existence as a guarantee of the availability of the new contract class'\n // information through registration, which is safe - we just need this information to be _eventually_ available.\n assert(\n context.nullifier_exists_unsafe(\n new_contract_class_id.to_field(),\n CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,\n ),\n \"New contract class is not registered\",\n );\n\n let scheduled_value_update = storage\n .updated_class_ids\n .at(address)\n .schedule_and_return_value_change(new_contract_class_id);\n let (prev_contract_class_id, timestamp_of_change) = scheduled_value_update.get_previous();\n\n let event = ContractInstanceUpdated {\n CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE,\n address,\n prev_contract_class_id,\n new_contract_class_id,\n timestamp_of_change,\n };\n context.emit_public_log(event);\n }\n\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n unconstrained fn set_update_delay(new_update_delay: u64) {\n // MACRO CODE START\n let context: PublicContext = PublicContext::new(\n || -> Field {\n let serialized_args: [Field; 1] = avm::calldata_copy(1, <u64 as Serialize>::N);\n hash_args(serialized_args)\n },\n );\n let storage: Storage<PublicContext> = Storage::init(context);\n // MACRO CODE END\n\n let msg_sender = context.maybe_msg_sender().unwrap();\n\n // Safety: we're using the nullifier's existence as a guarantee of the availability of the contract's\n // information through publishing, which is safe - we just need this information to be _eventually_ available.\n assert(\n context.nullifier_exists_unsafe(msg_sender.to_field(), context.this_address()),\n \"msg.sender is not deployed\",\n );\n\n assert(new_update_delay >= MINIMUM_UPDATE_DELAY, \"New update delay is too low\");\n\n storage.updated_class_ids.at(msg_sender).schedule_delay_change(new_update_delay);\n }\n\n /**\n * Gets the current update delay for the caller's contract instance.\n *\n * @return The current update delay value\n */\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_view]\n unconstrained fn get_update_delay() -> pub u64 {\n // MACRO CODE START\n let context: PublicContext = PublicContext::new(\n || -> Field {\n let serialized_args: [Field; 0] = avm::calldata_copy(1, 0);\n hash_args(serialized_args)\n },\n );\n let storage: Storage<PublicContext> = Storage::init(context);\n assert(context.is_static_call(), \"Function get_update_delay can only be called statically\");\n // MACRO CODE END\n\n storage.updated_class_ids.at(avm::sender()).get_current_delay()\n }\n\n // // THE REST OF THE CODE IN THIS CONTRACT WAS ORIGINALLY INJECTED BY THE #[aztec] MACRO.\n\n // Function selectors computed at comptime from function signatures\n global UPDATE_SELECTOR: Field =\n comptime { FunctionSelector::from_signature(\"update((Field))\").to_field() };\n global SET_UPDATE_DELAY_SELECTOR: Field =\n comptime { FunctionSelector::from_signature(\"set_update_delay(u64)\").to_field() };\n global GET_UPDATE_DELAY_SELECTOR: Field =\n comptime { FunctionSelector::from_signature(\"get_update_delay()\").to_field() };\n\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n pub unconstrained fn public_dispatch(selector: Field) {\n if selector == UPDATE_SELECTOR {\n let input_calldata: [Field; 1] =\n avm::calldata_copy(1, <ContractClassId as Serialize>::N);\n let mut reader: Reader<1> = Reader::new(input_calldata);\n let arg0: ContractClassId =\n <ContractClassId as Deserialize>::stream_deserialize(&mut reader);\n update(arg0);\n avm::avm_return([].as_vector());\n };\n if selector == SET_UPDATE_DELAY_SELECTOR {\n let input_calldata: [Field; 1] = avm::calldata_copy(1, <u64 as Serialize>::N);\n let mut reader: Reader<1> = Reader::new(input_calldata);\n let arg0: u64 = <u64 as Deserialize>::stream_deserialize(&mut reader);\n set_update_delay(arg0);\n avm::avm_return([].as_vector());\n };\n if selector == GET_UPDATE_DELAY_SELECTOR {\n let return_value: [Field; 1] = <u64 as Serialize>::serialize(get_update_delay());\n avm::avm_return(return_value.as_vector());\n };\n panic(f\"Unknown selector {selector}\")\n }\n\n // THE REST OF THE CODE IN THIS CONTRACT WAS ORIGINALLY INJECTED BY THE #[aztec] MACRO.\n\n impl<Context> Storage<Context> {\n fn init(context: Context) -> Self {\n Self {\n updated_class_ids: <Map<AztecAddress, DelayedPublicMutable<ContractClassId, DEFAULT_UPDATE_DELAY, Context>, Context> as StateVariable<1, Context>>::new(\n context,\n 1,\n ),\n }\n }\n }\n\n // Parameter structs for ABI\n pub struct publish_for_public_execution_parameters {\n pub _salt: Field,\n pub _contract_class_id: ContractClassId,\n pub _initialization_hash: Field,\n pub _public_keys: PublicKeys,\n pub _universal_deploy: bool,\n }\n\n pub struct update_parameters {\n pub _new_contract_class_id: ContractClassId,\n }\n\n pub struct set_update_delay_parameters {\n pub _new_update_delay: u64,\n }\n\n pub struct get_update_delay_parameters {}\n\n // ABI structs\n #[abi(functions)]\n pub struct publish_for_public_execution_abi {\n parameters: publish_for_public_execution_parameters,\n }\n\n #[abi(functions)]\n pub struct update_abi {\n parameters: update_parameters,\n }\n\n #[abi(functions)]\n pub struct set_update_delay_abi {\n parameters: set_update_delay_parameters,\n }\n\n #[abi(functions)]\n pub struct get_update_delay_abi {\n parameters: get_update_delay_parameters,\n return_type: u64,\n }\n}\n"
|
|
2914
|
+
"source": "/**\n * @title ContractInstanceRegistry Contract\n * @notice Manages the registration and updating of contract instances\n * @dev This contract allows deploying new contract instances and updating their class IDs\n */\npub contract ContractInstanceRegistry {\n use aztec::{\n context::{PrivateContext, PublicContext},\n hash::hash_args,\n nullifier::utils::compute_nullifier_existence_request,\n oracle::{avm, logging::debug_log_format, version::assert_compatible_oracle_version},\n protocol::{\n abis::function_selector::FunctionSelector,\n address::{AztecAddress, PartialAddress},\n constants::{\n CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS, CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE, DEFAULT_UPDATE_DELAY, MINIMUM_UPDATE_DELAY,\n },\n contract_class_id::ContractClassId,\n point::validate_on_curve,\n public_keys::PublicKeys,\n traits::{Deserialize, Serialize, ToField},\n utils::reader::Reader,\n },\n state_vars::{DelayedPublicMutable, Map, StateVariable},\n };\n\n #[abi(events)]\n struct ContractInstancePublished {\n CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE: Field,\n address: AztecAddress,\n version: u8,\n salt: Field,\n contract_class_id: ContractClassId,\n initialization_hash: Field,\n public_keys: PublicKeys,\n deployer: AztecAddress,\n }\n\n // We need to impl this separately because ts deserializes a point as two fields only.\n // We had issues that:\n // Notice how the 'is_infinite' field is deserialized as the next point.\n // {\n // masterNullifierPublicKey: Point {\n // x: Fr<0x0000000000000000000000000000000000000000000000000000000000000012>,\n // y: Fr<0x0000000000000000000000000000000000000000000000000000000000000034>,\n // isInfinite: false,\n // kind: 'point'\n // },\n // masterIncomingViewingPublicKey: Point {\n // x: Fr<0x0000000000000000000000000000000000000000000000000000000000000000>,\n // y: Fr<0x0000000000000000000000000000000000000000000000000000000000000056>,\n // isInfinite: false,\n // kind: 'point'\n // },\n // masterOutgoingViewingPublicKey: Point {\n // x: Fr<0x0000000000000000000000000000000000000000000000000000000000000078>,\n // y: Fr<0x0000000000000000000000000000000000000000000000000000000000000000>,\n // isInfinite: false,\n // kind: 'point'\n // },\n // masterTaggingPublicKey: Point {\n // x: Fr<0x0000000000000000000000000000000000000000000000000000000000000910>,\n // y: Fr<0x0000000000000000000000000000000000000000000000000000000000001112>,\n // isInfinite: false,\n // kind: 'point'\n // }\n\n impl ContractInstancePublished {\n fn serialize_non_standard(self) -> [Field; 15] {\n [\n self.CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n self.address.to_field(),\n self.version.to_field(),\n self.salt,\n self.contract_class_id.to_field(),\n self.initialization_hash,\n self.public_keys.npk_m.serialize()[0],\n self.public_keys.npk_m.serialize()[1],\n self.public_keys.ivpk_m.serialize()[0],\n self.public_keys.ivpk_m.serialize()[1],\n self.public_keys.ovpk_m.serialize()[0],\n self.public_keys.ovpk_m.serialize()[1],\n self.public_keys.tpk_m.serialize()[0],\n self.public_keys.tpk_m.serialize()[1],\n self.deployer.to_field(),\n ]\n }\n }\n\n #[abi(events)]\n #[derive(Serialize)]\n struct ContractInstanceUpdated {\n CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE: Field,\n address: AztecAddress,\n prev_contract_class_id: ContractClassId,\n new_contract_class_id: ContractClassId,\n timestamp_of_change: u64,\n }\n\n struct Storage<Context> {\n updated_class_ids: Map<AztecAddress, DelayedPublicMutable<ContractClassId, DEFAULT_UPDATE_DELAY, Context>, Context>,\n }\n\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_private]\n fn publish_for_public_execution(\n inputs: aztec::context::inputs::PrivateContextInputs,\n salt: Field,\n contract_class_id: ContractClassId,\n initialization_hash: Field,\n public_keys: PublicKeys,\n universal_deploy: bool,\n ) -> return_data aztec::protocol::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {\n // MACRO CODE START\n // Note: The macros initially inserted a phase check here, but since there is no phase change in this function\n // body, I have removed that check.\n assert_compatible_oracle_version();\n\n let serialized_params: [Field; 16] = [\n salt,\n contract_class_id.to_field(),\n initialization_hash,\n ]\n .concat(public_keys.serialize())\n .concat([universal_deploy.to_field()]);\n\n let args_hash: Field = hash_args(serialized_params);\n let mut context: PrivateContext = PrivateContext::new(inputs, args_hash);\n // MACRO CODE END\n\n // Verify that the contract class is registered\n let nullifier_existence_request = compute_nullifier_existence_request(\n contract_class_id.to_field(),\n CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,\n );\n context.assert_nullifier_exists(nullifier_existence_request);\n\n // Determine the deployer based on universal_deploy flag\n let deployer = if universal_deploy {\n AztecAddress::zero()\n } else {\n context.maybe_msg_sender().unwrap()\n };\n\n let partial_address =\n PartialAddress::compute(contract_class_id, salt, initialization_hash, deployer);\n\n // Note: Out of all the public keys, only the Ivpk_m is checked to be on the curve\n // (implicitly as part of the `add` operation of deriving the address). This at least\n // protects the AVM against DoS attacks.\n // For thoroughness, we also ensure the other points are on the curve:\n validate_on_curve(public_keys.npk_m.inner);\n validate_on_curve(public_keys.ovpk_m.inner);\n validate_on_curve(public_keys.tpk_m.inner);\n\n let address = AztecAddress::compute(public_keys, partial_address);\n\n // Emit the address as a nullifier:\n // - to demonstrate that this contract instance hasn't been published before\n // - to enable apps to read that this contract instance has been published.\n context.push_nullifier(address.to_field());\n\n // Emit the deployment event\n let event = ContractInstancePublished {\n CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n contract_class_id,\n address,\n public_keys,\n initialization_hash,\n salt,\n deployer,\n version: 1,\n };\n let payload = event.serialize_non_standard();\n debug_log_format(\"ContractInstancePublished: {}\", payload);\n let padded_log = payload.concat([0; 3]);\n let length = payload.len();\n context.emit_private_log(padded_log, length);\n\n // MACRO CODE START\n context.finish()\n // MACRO CODE END\n }\n\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n unconstrained fn update(new_contract_class_id: ContractClassId) {\n // MACRO CODE START\n let context: PublicContext = PublicContext::new(\n || -> Field {\n let serialized_args: [Field; 1] =\n avm::calldata_copy(1, <ContractClassId as Serialize>::N);\n hash_args(serialized_args)\n },\n );\n let storage: Storage<PublicContext> = Storage::init(context);\n // MACRO CODE END\n\n let address = context.maybe_msg_sender().unwrap();\n\n // Safety: we're using the nullifier's existence as a guarantee of the availability of the contract's\n // information through publishing, which is safe - we just need this information to be _eventually_ available.\n assert(\n context.nullifier_exists_unsafe(address.to_field(), context.this_address()),\n \"msg.sender is not deployed\",\n );\n\n // Safety: we're using the nullifier's existence as a guarantee of the availability of the new contract class'\n // information through registration, which is safe - we just need this information to be _eventually_ available.\n assert(\n context.nullifier_exists_unsafe(\n new_contract_class_id.to_field(),\n CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,\n ),\n \"New contract class is not registered\",\n );\n\n let scheduled_value_update = storage\n .updated_class_ids\n .at(address)\n .schedule_and_return_value_change(new_contract_class_id);\n let (prev_contract_class_id, timestamp_of_change) = scheduled_value_update.get_previous();\n\n let event = ContractInstanceUpdated {\n CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE,\n address,\n prev_contract_class_id,\n new_contract_class_id,\n timestamp_of_change,\n };\n context.emit_public_log(event);\n }\n\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n unconstrained fn set_update_delay(new_update_delay: u64) {\n // MACRO CODE START\n let context: PublicContext = PublicContext::new(\n || -> Field {\n let serialized_args: [Field; 1] = avm::calldata_copy(1, <u64 as Serialize>::N);\n hash_args(serialized_args)\n },\n );\n let storage: Storage<PublicContext> = Storage::init(context);\n // MACRO CODE END\n\n let msg_sender = context.maybe_msg_sender().unwrap();\n\n // Safety: we're using the nullifier's existence as a guarantee of the availability of the contract's\n // information through publishing, which is safe - we just need this information to be _eventually_ available.\n assert(\n context.nullifier_exists_unsafe(msg_sender.to_field(), context.this_address()),\n \"msg.sender is not deployed\",\n );\n\n assert(new_update_delay >= MINIMUM_UPDATE_DELAY, \"New update delay is too low\");\n\n storage.updated_class_ids.at(msg_sender).schedule_delay_change(new_update_delay);\n }\n\n /**\n * Gets the current update delay for the caller's contract instance.\n *\n * @return The current update delay value\n */\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_view]\n unconstrained fn get_update_delay() -> pub u64 {\n // MACRO CODE START\n let context: PublicContext = PublicContext::new(\n || -> Field {\n let serialized_args: [Field; 0] = avm::calldata_copy(1, 0);\n hash_args(serialized_args)\n },\n );\n let storage: Storage<PublicContext> = Storage::init(context);\n assert(context.is_static_call(), \"Function get_update_delay can only be called statically\");\n // MACRO CODE END\n\n storage.updated_class_ids.at(avm::sender()).get_current_delay()\n }\n\n // // THE REST OF THE CODE IN THIS CONTRACT WAS ORIGINALLY INJECTED BY THE #[aztec] MACRO.\n\n // Function selectors computed at comptime from function signatures\n global UPDATE_SELECTOR: Field =\n comptime { FunctionSelector::from_signature(\"update((Field))\").to_field() };\n global SET_UPDATE_DELAY_SELECTOR: Field =\n comptime { FunctionSelector::from_signature(\"set_update_delay(u64)\").to_field() };\n global GET_UPDATE_DELAY_SELECTOR: Field =\n comptime { FunctionSelector::from_signature(\"get_update_delay()\").to_field() };\n\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n pub unconstrained fn public_dispatch(selector: Field) {\n if selector == UPDATE_SELECTOR {\n let input_calldata: [Field; 1] =\n avm::calldata_copy(1, <ContractClassId as Serialize>::N);\n let mut reader: Reader<1> = Reader::new(input_calldata);\n let arg0: ContractClassId =\n <ContractClassId as Deserialize>::stream_deserialize(&mut reader);\n update(arg0);\n avm::avm_return([].as_vector());\n };\n if selector == SET_UPDATE_DELAY_SELECTOR {\n let input_calldata: [Field; 1] = avm::calldata_copy(1, <u64 as Serialize>::N);\n let mut reader: Reader<1> = Reader::new(input_calldata);\n let arg0: u64 = <u64 as Deserialize>::stream_deserialize(&mut reader);\n set_update_delay(arg0);\n avm::avm_return([].as_vector());\n };\n if selector == GET_UPDATE_DELAY_SELECTOR {\n let return_value: [Field; 1] = <u64 as Serialize>::serialize(get_update_delay());\n avm::avm_return(return_value.as_vector());\n };\n panic(f\"Unknown selector {selector}\")\n }\n\n // THE REST OF THE CODE IN THIS CONTRACT WAS ORIGINALLY INJECTED BY THE #[aztec] MACRO.\n\n impl<Context> Storage<Context> {\n fn init(context: Context) -> Self {\n Self {\n updated_class_ids: <Map<AztecAddress, DelayedPublicMutable<ContractClassId, DEFAULT_UPDATE_DELAY, Context>, Context> as StateVariable<1, Context>>::new(\n context,\n 1,\n ),\n }\n }\n }\n\n // Parameter structs for ABI\n pub struct publish_for_public_execution_parameters {\n pub _salt: Field,\n pub _contract_class_id: ContractClassId,\n pub _initialization_hash: Field,\n pub _public_keys: PublicKeys,\n pub _universal_deploy: bool,\n }\n\n pub struct update_parameters {\n pub _new_contract_class_id: ContractClassId,\n }\n\n pub struct set_update_delay_parameters {\n pub _new_update_delay: u64,\n }\n\n pub struct get_update_delay_parameters {}\n\n // ABI structs\n #[abi(functions)]\n pub struct publish_for_public_execution_abi {\n parameters: publish_for_public_execution_parameters,\n }\n\n #[abi(functions)]\n pub struct update_abi {\n parameters: update_parameters,\n }\n\n #[abi(functions)]\n pub struct set_update_delay_abi {\n parameters: set_update_delay_parameters,\n }\n\n #[abi(functions)]\n pub struct get_update_delay_abi {\n parameters: get_update_delay_parameters,\n return_type: u64,\n }\n}\n"
|
|
2915
2915
|
},
|
|
2916
2916
|
"58": {
|
|
2917
2917
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/context/private_context.nr",
|