@aztec/protocol-contracts 4.0.0-nightly.20260209 → 4.0.0-nightly.20260210
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 +25 -25
- package/artifacts/ContractClassRegistry.json +15 -15
- package/artifacts/ContractInstanceRegistry.json +24 -24
- package/artifacts/FeeJuice.json +19 -19
- package/artifacts/MultiCallEntrypoint.json +14 -14
- package/artifacts/PublicChecks.json +13 -13
- package/dest/protocol_contract_data.js +14 -14
- package/package.json +4 -4
- package/src/protocol_contract_data.ts +14 -14
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"transpiled": true,
|
|
3
|
-
"noir_version": "1.0.0-beta.18+
|
|
3
|
+
"noir_version": "1.0.0-beta.18+f1db9754dd26736a9bdbfd41c5ce15fe5d62ba6b",
|
|
4
4
|
"name": "AuthRegistry",
|
|
5
5
|
"functions": [
|
|
6
6
|
{
|
|
@@ -75,8 +75,8 @@
|
|
|
75
75
|
}
|
|
76
76
|
}
|
|
77
77
|
},
|
|
78
|
-
"bytecode": "
|
|
79
|
-
"debug_symbols": "rZnRbts6DIbfxde5kCiJIvsqwzBkbToECNIiaw9wUPTdR8qknA6w0Sm9Sb78sX+RFC05ztv0cPj5+uvH8fz49Hu6+/Y2/bwcT6fjrx+np/v9y/HpLOrbFPSF83QHu4l5uiu7KQb5iPrO83us8zvAdBejQjVIaJCDQzEorhRX0BXMDmRQk4M7k49FOkQW4OhQHHgGCMmBDKIrGnsD0NNRAQ2SK8mVnB3EGWR0KMmBDNAVdKW6osE3oOiABhwcioMOIYElrfYMZBDBAQ00+BlcScFBT0cFNsiuFHCQwFIQQFFS2k1ZT09ZQeJJMum5oAHKWAkVikHVg6tCdmADcoVcYVeYZigBHKpBjA5oAMGhOJhhSVLeRAJYDUiPYQGt6gymYBAlB4VioE2bo0I1SK5o086gB4OCDJqlPliyAxnovDeo0UGCz1JD1OmewRUNLBeFYgezOdeQHVyJycHGqi3mBmooU1B1TnNVYAPtzEwKZICutAgboAG5otPUQKcpswLPQCE7iGGR0lELrCpUgxZYA1f0IpoBDVpVG+hyIuUlLWaR8lIFBzSg4FAc9CypIXFyoBk4JAdXoivRFdCxpHSsbVOKgoRapIacwaBIzKUq6KBSDdalaQY9nRXYoLpSXaFqwOBgSgzadjNFscTQqDhB1zRMjI14HjqGFvFM5JS7lquTXtZGUkYEJb1ojXS0pKSXrVHXKHUiJ3ZNQu2kzrrGRr1WjbrW8iiNio0bNY+ZdEUy6prmYUROmge2/UXXp5laHrUROtWu6RTMpOuOUdd0FhqBrjhIjapT7FrLg9t+Fm1caHk00pXRaNHYSa9DI3LqeUDPAzSP2rZKnY+ZdD6MukZdo65x11girdovSde1Gt7fd5Pv3j9eLoeDbt5X27ls8s/7y+H8Mt2dX0+n3fTf/vTaDvr9vD+395f9Rb4Vz8P5Qd7F8PF4Oii975azw/qphOBnE6bUDUr84BDXHZKuMs0gYe7nV/h8BLovWASlrkWQ1h0wEpmDZAOLA39wyOsOUN0AeCyHqyrKsCs5bDlU6lWgmNcc6rqD9HAxB2m10h0of3CgjSqQJ5GY+vk54gcD3ghB1ibwGHT96SaJ6GM/bZQCg97TzNMZMi4enw9D1qAljALrYcCGS6DicciqGsK6y0ZvpgK9pktvA9Onp1Xuiz2KFHBtWjXh1YJSNod6NSV/GXy2N2H1Co23N2e8uTvjl7Qn3Nye8Uv6E76kP+Hm/oy3NyhsNGihpaJLGoRDDZpXGxQ2swjLlKS4FgTQ5oSk3CeEcl7biGCjN0rvjAJXXZ7SP4RRuS5hRF4LI8Utk4L9UpHbUVo12ejQhNXrkWosA/tqlLb2KPjK4e/+
|
|
78
|
+
"bytecode": "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",
|
|
79
|
+
"debug_symbols": "rZnRbts6DIbfxde5kCiJIvsqwzBkbToECNIiaw9wUPTdR8qknA6w0Sm9Sb78sX+RFC05ztv0cPj5+uvH8fz49Hu6+/Y2/bwcT6fjrx+np/v9y/HpLOrbFPSF83QHu4l5uiu7KQb5iPrO83us8zvAdBejQjVIaJCDQzEorhRX0BXMDmRQk4M7k49FOkQW4OhQHHgGCMmBDKIrGnsD0NNRAQ2SK8mVnB3EGWR0KMmBDNAVdKW6osE3oOiABhwcioMOIYElrfYMZBDBAQ00+BlcScFBT0cFNsiuFHCQwFIQQFFS2k1ZT09ZQeJJMum5oAHKWAkVikHVg6tCdmADcoVcYVeYZigBHKpBjA5oAMGhOJhhSVLeRAJYDUiPYQGt6gymYBAlB4VioE2bo0I1SK5o086gB4OCDJqlPliyAxnovDeo0UGCz1JD1OmewRUNLBeFYgezOdeQHVyJycHGqi3mBmooU1B1TnNVYAPtzEwKZICutAgboAG5otPUQKcpswLPQCE7iGGR0lELrCpUgxZYA1f0IpoBDVpVG+hyIuUlLWaR8lIFBzSg4FAc9CypIXFyoBk4JAdXoivRFdCxpHSsbVOKgoRapIacwaBIzKUq6KBSDdalaQY9nRXYoLpSXaFqwOBgSgzadjNFscTQqDhB1zRMjI14HjqGFvFM5JS7lquTXtZGUkYEJb1ojXS0pKSXrVHXKHUiJ3ZNQu2kzrrGRr1WjbrW8iiNio0bNY+ZdEUy6prmYUROmge2/UXXp5laHrUROtWu6RTMpOuOUdd0FhqBrjhIjapT7FrLg9t+Fm1caHk00pXRaNHYSa9DI3LqeUDPAzSP2rZKnY+ZdD6MukZdo65x11girdovSde1Gt7fd5Pv3j9eLoeDbt5X27ls8s/7y+H8Mt2dX0+n3fTf/vTaDvr9vD+395f9Rb4Vz8P5Qd7F8PF4Oii975azw/qphOBnE6bUDUr84BDXHZKuMs0gYe7nV/h8BLovWASlrkWQ1h0wEpmDZAOLA39wyOsOUN0AeCyHqyrKsCs5bDlU6lWgmNcc6rqD9HAxB2m10h0of3CgjSqQJ5GY+vk54gcD3ghB1ibwGHT96SaJ6GM/bZQCg97TzNMZMi4enw9D1qAljALrYcCGS6DicciqGsK6y0ZvpgK9pktvA9Onp1Xuiz2KFHBtWjXh1YJSNod6NSV/GXy2N2H1Co23N2e8uTvjl7Qn3Nye8Uv6E76kP+Hm/oy3NyhsNGihpaJLGoRDDZpXGxQ2swjLlKS4FgTQ5oSk3CeEcl7biGCjN0rvjAJXXZ7SP4RRuS5hRF4LI8Utk4L9UpHbUVo12ejQhNXrkWosA/tqlLb2KPjK4e/+3LKgpT0ZeMiC9XeGWZQ6ZqG3gGZBMGIBAd1C7oPzkEUOXgvIMBZFTosFhiGLEnoiBXDMooRuUeKYRc6LBQxGgd2i0s1RjFr0BpffKUMNDpihW5SxSUXsM4J1MIrSa4EUbk5kzCJR9c1I9tE8aLFsqmFoUhOn2C1wvZxlY2uXx3q+l2RKS4dH/nwUjD0KrmOJ8HLbxmMNHvsmANc3bf+0dnJeLMYu9hh7a8mDiMFEcLG4PZFBi7is4DHXMYtSuwXyoEXfBGINNycyatGfHEDksa0IlkmFSIMWYbHgWxMZtVh+ogFQWv+tGsaWnO/yaX9/vHz4w+pdvS7H/c/TwT4+vp7vr759+f/Zv/E/vJ4vT/eHh9fLQZ2Wf73k5RvIXZY8cPuuz0HlY8UdRf0Q9Tt5xClb0/d3DeUP"
|
|
80
80
|
},
|
|
81
81
|
{
|
|
82
82
|
"name": "consume",
|
|
@@ -151,8 +151,8 @@
|
|
|
151
151
|
}
|
|
152
152
|
}
|
|
153
153
|
},
|
|
154
|
-
"bytecode": "JwACBAEoAAABBIBNJwAABE0lAAAASScCAwQCJwIEBAAfCgADAAQASi0ISgEtCEsCJQAAAJEtAgFMJwICBEwnAgMEATsOAAMAAikAAEMAR9rNcywAAEQAMGROcuExoCm4UEW2gYFYXSgz6Eh5uXCRQ+H1k/
|
|
155
|
-
"debug_symbols": "
|
|
154
|
+
"bytecode": "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",
|
|
155
|
+
"debug_symbols": "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"
|
|
156
156
|
},
|
|
157
157
|
{
|
|
158
158
|
"name": "is_consumable",
|
|
@@ -224,8 +224,8 @@
|
|
|
224
224
|
}
|
|
225
225
|
}
|
|
226
226
|
},
|
|
227
|
-
"bytecode": "
|
|
228
|
-
"debug_symbols": "
|
|
227
|
+
"bytecode": "JwACBAEoAAABBIBJJwAABEklAAAASScCAwQCJwIEBAAfCgADAAQARi0IRgEtCEcCJQAAAFktAgFIJwICBEgnAgMEATsOAAMAAicAQwQDJwBEAAAnAEUBASYlAAABfB4CAAMJJAIAAwAAAHAlAAABoicCAwACKQIABADvUlNNLQgBBScCBgQEAAgBBgEnAwUEAQAiBQIGLQoGBy0OBAcAIgcCBy0OAwcAIgcCBy0OAQcnAgMEBi0IAAYtCgUHLQhDCAAIAAMAJQAAAbQtAgAALQoHAQoiAUQDJwIFAQAKKgMFBiQCAAYAAADvJQAABSgtCAEDJwIGBAQACAEGAScDAwQBACIDAgYtCgYHLQ4EBwAiBwIHLQ4BBwAiBwIHLQ4CBycCAgQGLQgABi0KAwctCEMIAAgAAgAlAAABtC0CAAAtCgcBCiIBRAIKKgIFAyQCAAMAAAFbJQAABSgeAgACAC8qAAEAAgADHAoDAgEcCgIBABwKAQIBLQoCASYoAAAEBHhJDAAABAMkAAADAAABoSoBAAEF2sX11rRKMm08BAIBJioBAAEF8EPlofqiLDQ8BAIBJiUAAAF8HAoCBAArAgAFAAAAAAAAAAABAAAAAAAAAAAEKgQFBi0IAQQAAAECAS0IAQUnAgcEBQAIAQcBJwMFBAEAIgUCBy0KBwgtDEQIACIIAggtDEQIACIIAggtDEQIACIIAggtDgYILQ4FBAYiAkMFJwIGBAAnAgcEAScCCAQCLQoGAyMAAAI9DCoDBQkkAgAJAAADvSMAAAJPBiICQwUEIgVDCQIqAgkDCioDBgUWCgUJJAIABQAAA1cjAAACdAIqAgMFDioDAgokAgAKAAACiyUAAAU6LQsECgAqCgcMLQsMCwwiBUMMJAIADAAAAqolAAAFTAAiAQINACoNBQ4tCw4MACoLDA0tAgoDJwAEBAUlAAAFXi0IBQsAKgsHDC0ODQwtDgsEDCoHAwokAgAKAAAC7iMAAANXACoLCAotCwoDACoFBwoOKgUKDCQCAAwAAAMOJQAABb0MIgpDBSQCAAUAAAMgJQAABUwAIgECDAAqDAoNLQsNBQAqAwUBLQILAycABAQFJQAABV4tCAUDACoDCAUtDgEFLQ4DBCMAAANXCioCBgESKgEJAiQCAAIAAANuIwAAA6stCwQBLQsBAgAiAgICLQ4CAS0IAQInAgMEBQAIAQMBJwMCBAEAIgECAwAiAgIFPw8AAwAFLQ4CBCMAAAOrLQsEAQAqAQcDLQsDAi0KAgEmLQsECQAqCQcLLQsLCgQiA0MLBiILQw0KKg0DDCQCAAwAAAPmJQAABc8MIgtDDCQCAAwAAAP4JQAABUwAIgECDQAqDQsOLQsODAAqCgwNLQIJAycABAQFJQAABV4tCAUKACoKBwwtDg0MACoKCAwtCwwJACoLBwwOKgsMDSQCAA0AAARGJQAABb0MIgxDDSQCAA0AAARYJQAABUwAIgECDgAqDgwPLQsPDQAqCQ0MLQIKAycABAQFJQAABV4tCAUJACoJCA0tDgwNACIJQwwtCwwKACoLCAwOKgsMDSQCAA0AAASmJQAABb0MIgxDCyQCAAsAAAS4JQAABUwAIgECDQAqDQwOLQsOCwAqCgsMLQIJAycABAQFJQAABV4tCAUKACIKQwstDgwLLQsKCQAiCQIJLQ4JCi0IAQknAgsEBQAIAQsBJwMJBAEAIgoCCwAiCQIMPw8ACwAMLQ4JBAAqAwcJLQoJAyMAAAI9KgEAAQW6uyHXgjMYZDwEAgEmKgEAAQUbvGXQP9zq3DwEAgEmKgEAAQXkCFBFArWMHzwEAgEmLQEDBgoABgIHJAAABwAABXQjAAAFfS0AAwUjAAAFvC0AAQUAAAEEAQAAAwQJLQADCi0ABQsKAAoJDCQAAAwAAAW3LQEKCC0ECAsAAAoCCgAACwILIwAABZMnAQUEASYqAQABBdAH6/TLxmeQPAQCASYqAQABBQUEG5kgr2BMPAQCASY=",
|
|
228
|
+
"debug_symbols": "rZndTis5DMffZa65SBzHSXiVI4QKlKNKVUE9sNIK8e5rJ3ZSVpoRJ+Wm+Y2n84/tOB+dfixP+4f33/eH0/PLn+X218fycD4cj4ff98eXx93b4eXE1o/FyUfB5TbcLKUst3izeJda62G5LdKm1gK1NjhtY2tRr1Gvo15H1Da3loK2qpdUP7GuB4bsDaJBUSjBIDcAFwySgpfHUYAUwCxgloAGosy9AwaDrBDNEs1CZhHXKyRvQArZGUQD7gLEMclvg9wgODAgBXG+gVnAGcjjKFAUglkQDNix4BgiW4I8Rfx4kFsUFZJaELmvEAW4r0AMElcFGZOQBEhBBiVkgahQnIFaonMG3VIUfDDICgAGSSF4A1JAE0QpTU5mTEGh8JfRCVADct5ALJ5BklkBuFPkbFAIBmaR2CtE+XIQYOeR80OSugZoUBRSUsgcBUaBpFDMUh3jZKbqGAqocvLOoFtUOQEaZIUggjwESSYUZoFoIE9xNlL1sIJZqocC1cMKZpHxEsgyXtEJRAVvFs+C0QuU1leGYJAVgllCUpA6bEAK4mrk9GZJZuT05pQVxLEGpCBj2kCeigKlQXFoYBZvFm8WMIusTBEF5BYPQZHZHZNAVojsc2QPC0mnRYAUZIKQE4gK2SzZLLIQNcgNvHPBSOpOiTXJC8kapNRt4idBpdj6ZipGUvNK3SZrklI2Is4jhUrJSNYlaos4GeVukxWpkSxJSmar634jWfkpVkpG0G01DhKSiVv7rXtBI5m6SsNWjGRPUJL8JSFZXZWkt1y3HOjUbXUMKskKpGS2uh8oiXLdsGTxUeo2iSO5Skn7hRpHIzLCbqtxVJKJqISdLA7ocdRtIsn41n1CiYxyt+VuK91WzFY3ieQric1/ft4stnnfv533e9m7L3Zz3uNfd+f96W25Pb0fjzfLP7vje/3Sn9fdqbZvuzPf5ej3pyduWfD5cNwLfd6Mp936o1wvZI8zZ+gS0X/R8OsahYBUohCmoVC+KMCWFxnNCS7brpBgNg5ci2NLg7vO3Q2emWsacUMDZMtoElCGAjt0qUDrCnzwUIFQcn8ePX0RSNthwEUYvouEnL+I5HURciGoBjmkIfF9L3hJGF5EWPXCbw5rjmEMq3PrKhsFGiL0lI7i4tPbt0fVl2Je8ORdG1UfNhLaKzxdjMj/BL5fnLA+Ua+vTn91efofqU9/dYH6H6lQ+JEKhasr1F9forBRojGPjI4wMk2WKPq1EoWNOIqckNtekmDNCaCtAYFIfUAgre9HW7XhnE9dxAVcFdkqUZ8tHQQOViXKxmzrCeUfnWvb4lYgpYy55hzmNSfCZnGiFUaIG25sDwpeDEpZTUbYWkL7kFAYAhjCtwuUp6c5UXxcnWdbEnlMswJlSqKM+uRfL3MSco5UiYsz219IgCOT4DcuOCWBznIBCHNeYBgS5KYkouuBRKA5iei6RPRzEohDAia9oC6R8tVezEr0AgfyUwUOhNAl4tygUj/N84+vSS9izwVld3UgcxIhp7525oyTEuNw4KYGNZTguwStp1MytqaB/LpJNTBfrL++fN+LQt2LkuYCKeP4WeYK3PdNAC4Pn3+1dhYcEnOT3fteWvyGYzIQGhLXBzIp4ccK7jHNScTUJahMSvRNwCd3dSCzEv3AB77MbUUwBpXlJiXckCjXBjIrMX5qAuSwKpH83JJzx1e7x8P5y99fn6J1Puwejnu9fH4/PV7cffv31e7Y32ev55fH/dP7eS9K4z80/vgFvPDym7w7ea3Kl3wWz0EuvNzjN6a8Kdx9iiv/AQ=="
|
|
229
229
|
},
|
|
230
230
|
{
|
|
231
231
|
"name": "is_reject_all",
|
|
@@ -274,8 +274,8 @@
|
|
|
274
274
|
}
|
|
275
275
|
}
|
|
276
276
|
},
|
|
277
|
-
"bytecode": "
|
|
278
|
-
"debug_symbols": "
|
|
277
|
+
"bytecode": "JwACBAEoAAABBIBGJwAABEYlAAAARScCAgQBJwIDBAAfCgACAAMARC0IRAElAAAARi0CAUUnAgIERScCAwQBOw4AAwACJiUAAAFAHgIAAgknAgMBASQCAAIAAABiJQAAAWYpAgACAO9SU00nAgMAASsCAAQAAAAAAAAAAAMAAAAAAAAAAC0IAQUnAgYEBQAIAQYBJwMFBAEAIgUCBi0KBgctDgIHACIHAgctDgMHACIHAgctDgEHACIHAgctDgQHLQsFAQAiAQIBLQ4BBS0IAQEnAgIEBQAIAQIBJwMBBAEAIgUCAgAiAQIDPw8AAgADJwICBAEAKgECBC0LBAMnAgEAAAoqAwECJwIBAQAKKgIBBCQCAAQAAAEfJQAAAXgeAgABAC8qAAMAAQACHAoCAwEcCgMBABwKAQIBLQoCASYoAAAEBHhGDAAABAMkAAADAAABZSoBAAEF2sX11rRKMm08BAIBJioBAAEFoj+MFkXsKv88BAIBJioBAAEFursh14IzGGQ8BAIBJg==",
|
|
278
|
+
"debug_symbols": "nZbbjuIwDIbfJde9iJ2jeZURQgXKqFJVUKddaYX67ptA3MNKiUZwQf469Kud3wl9imtznr5PbX+7/4jD11Och7br2u9Td7/UY3vvQ/QpZPxyRhxUJXy40GEwr4HUe/DiAFAJkC4JwCSUYsFTmqc0RwxHDEcssDBJOMlCs6AkPD/CcxrEQLJvgRJYRKCKgpIAzYIjyBHkiOKIjmnoKEwShiMm/sZGQUlYjliOOI54ZBFKRgwi5oyBo2QAoo3CJAGvyDxXgm05jUPTRFc2PgX3HvXQ9KM49FPXVeJP3U2vH/086v41jvUQZmUlmv4axgC8tV0T1Vytd8v8reQ0pLvJWbUADOwIUCDYWNKbYLVbCbQjYJ4A0utEgNBwC8HhZ1WYXBUlgjfEBO9ljmAKVYQO4iqQ1hy83hFsnoCejVTkl/s12B3AFVIInyWHIHGBKO93EF90wyiGSJIyC6E8RBlcSlkNRdoDoGAIhs2fEGEf288YqyWIXuUZhebUjpihvVpXFOjXaSii1diNs/+nUWouIG5PUNLmmgsKCOPZVbvx1NuPdghR9qQo9Cdpt+xSzKUAxd5EY5feRJc9bYBKEAlugUils0dWYTXs2p4WJWYRhYMT3dLgpHOHXqkQCqu41qF9NglV2qia20KZQhplU/TGFMovhimtJ1tiN5tMKzXPx3BZX9ph9wozR9TQ1ueuSZe3qb9sZse/D57hV6DHcL8012loIml9D4p/xl8WKmuP8T0nXDhZOTzO8dH/AA=="
|
|
279
279
|
},
|
|
280
280
|
{
|
|
281
281
|
"name": "public_dispatch",
|
|
@@ -350,8 +350,8 @@
|
|
|
350
350
|
}
|
|
351
351
|
}
|
|
352
352
|
},
|
|
353
|
-
"bytecode": "JwACBAEoAAABBIBSJwAABFIlAAAAQScCAgQBJwIDBAAfCgACAAMAUS0IUQElAAAAxCcCAQRSJwICBAA7DgACAAEpAABDALg53pEpAABEAIlV9fwpAABFACcWsWYpAABGAGGWa3wpAABHAEb7RNopAABIAPjUXpspAABJAEfazXMsAABKADBkTnLhMaApuFBFtoGBWF0oM+
|
|
354
|
-
"debug_symbols": "
|
|
353
|
+
"bytecode": "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",
|
|
354
|
+
"debug_symbols": "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"
|
|
355
355
|
},
|
|
356
356
|
{
|
|
357
357
|
"name": "set_authorized",
|
|
@@ -404,8 +404,8 @@
|
|
|
404
404
|
}
|
|
405
405
|
}
|
|
406
406
|
},
|
|
407
|
-
"bytecode": "
|
|
408
|
-
"debug_symbols": "
|
|
407
|
+
"bytecode": "JwACBAEoAAABBIBHJwAABEclAAAASicCAwQCJwIEBAAfCgADAAQARRwARkYBLQhFAS0IRgIlAAAAVScCAQRHJwICBAA7DgACAAEnAEMEAycARAAAJiUAAAFWHgIAAwEnAgQAAikCAAUA71JTTS0IAQYnAgcEBAAIAQcBJwMGBAEAIgYCBy0KBwgtDgUIACIIAggtDgQIACIIAggtDgMIJwIEBActCAAHLQoGCC0IQwkACAAEACUAAAF8LQIAAC0KCAMKIgNEBCcCBgEACioEBgckAgAHAAAA3iUAAAT1LQgBBCcCBwQEAAgBBwEnAwQEAQAiBAIHLQoHCC0OBQgAIggCCC0OAwgAIggCCC0OAQgnAgMEBy0IAActCgQILQhDCQAIAAMAJQAAAXwtAgAALQoIAQoiAUQDCioDBgQkAgAEAAABSiUAAAT1HAoCAwAwCgADAAEmKAAABAR4RwwAAAQDJAAAAwAAAXsqAQABBdrF9da0SjJtPAQCASYlAAABVhwKAgQAKwIABQAAAAAAAAAAAQAAAAAAAAAABCoEBQYtCAEEAAABAgEtCAEFJwIHBAUACAEHAScDBQQBACIFAgctCgcILQxECAAiCAIILQxECAAiCAIILQxECAAiCAIILQ4GCC0OBQQGIgJDBScCBgQAJwIHAQEnAggEAScCCQQCLQoGAyMAAAIKDCoDBQokAgAKAAADiiMAAAIcBiICQwUEIgVDCgIqAgoDCioDBgUWCgUKJAIABQAAAyQjAAACQQIqAgMFDioDAgskAgALAAACWCUAAAUHLQsECwAqCwgNLQsNDAwiBUMNJAIADQAAAnclAAAFGQAiAQIOACoOBQ8tCw8NACoMDQ4tAgsDJwAEBAUlAAAFKy0IBQwAKgwIDS0ODg0tDgwEDCoIAwskAgALAAACuyMAAAMkACoMCQstCwsDACoFCAsOKgULDSQCAA0AAALbJQAABYoMIgtDBSQCAAUAAALtJQAABRkAIgECBwAqBwsNLQsNBQAqAwUBLQIMAycABAQFJQAABSstCAUDACoDCQUtDgEFLQ4DBCMAAAMkCioCBgESKgEKAiQCAAIAAAM7IwAAA3gtCwQBLQsBAgAiAgICLQ4CAS0IAQInAgMEBQAIAQMBJwMCBAEAIgECAwAiAgIFPw8AAwAFLQ4CBCMAAAN4LQsEAQAqAQgDLQsDAi0KAgEmLQsECgAqCggMLQsMCwQiA0MMBiIMQw4KKg4DDSQCAA0AAAOzJQAABZwMIgxDDSQCAA0AAAPFJQAABRkAIgECDgAqDgwPLQsPDQAqCw0OLQIKAycABAQFJQAABSstCAULACoLCA0tDg4NACoLCQ0tCw0KACoMCA0OKgwNDiQCAA4AAAQTJQAABYoMIg1DDiQCAA4AAAQlJQAABRkAIgECDwAqDw0QLQsQDgAqCg4NLQILAycABAQFJQAABSstCAUKACoKCQ4tDg0OACIKQw0tCw0LACoMCQ0OKgwNDiQCAA4AAARzJQAABYoMIg1DDCQCAAwAAASFJQAABRkAIgECDgAqDg0PLQsPDAAqCwwNLQIKAycABAQFJQAABSstCAULACILQwwtDg0MLQsLCgAiCgIKLQ4KCy0IAQonAgwEBQAIAQwBJwMKBAEAIgsCDAAiCgINPw8ADAANLQ4KBAAqAwgKLQoKAyMAAAIKKgEAAQW6uyHXgjMYZDwEAgEmKgEAAQUbvGXQP9zq3DwEAgEmKgEAAQXkCFBFArWMHzwEAgEmLQEDBgoABgIHJAAABwAABUEjAAAFSi0AAwUjAAAFiS0AAQUAAAEEAQAAAwQJLQADCi0ABQsKAAoJDCQAAAwAAAWELQEKCC0ECAsAAAoCCgAACwILIwAABWAnAQUEASYqAQABBdAH6/TLxmeQPAQCASYqAQABBQUEG5kgr2BMPAQCASY=",
|
|
408
|
+
"debug_symbols": "rZnRbiI7DIbfhWsuYid2kn2VVVXRlq6QEK3Y9khHVd997YydgZVm1A29Yb4x5J/fjjMZ4GPztH94/3V/OD2//N78+PmxeTgfjsfDr/vjy+Pu7fBykujHJuhLlVfcbiptfuTtBkKwY52OEO1YpiPaOdp5tPOYp2MCO/J0JNMj0yfRhSDAyaEYZHRggwIOHlG3E+hwVKgTYEgOHoFsgKqcFdgggoNHkkeSR9T6BMmhGnB0KAZqHoNCNlDzE5BDNVDzE1gkhuigw8VzBHTwCJJB1CljBY1UAb1E1OFanwjbTQJwkHSijEoYHPTDUaEaxOTgkeSR5BGKDtmA0YENMjj4JUpwcMEiFYtpuyGdlAZJP0MKZEAe0a6JkilxMNDyRik4FXTwiLawAmsPx6KgF60K1UDbeYJioC3RQFsiBQU2SB5RY0mKyc2YfphcmVyZPcKunP1azbOCtkSSKWCd9yTVyOpwAhmVpBpZHU7gEXXYoDls4BGdpglUUCqW1dgEHtFeTaxQ7FraqxNkg+IRXWgNKjjQBKVZzQqqLOUtmA2asQZkoHM6gYyioFAMtJEm8Ah7hD2SPZL1WlK6om1DMgWlilVChTxBDeKZxGEFuSglBXKQ4SRFqJgcPBI9ktAhG5BHtOsmUEGpYc3BoUdUUMpStcPbRZtVhRodLCJ3V+yUnXSpUmnETrpYqTYip9hjsTil2KnHiJ1YlDk0YqfcY5oCg5Ku0um6LYmJqlPtsZaHEuj9ykjyYL0Rg96xjPRqUQmhU49p5Y2qU+oxLb6RKmuFQO80Rj3W8qBG7NfVPIzIqfaY5mFUjVDzMPI8sOeBLY+22+l8GJFT7LHYY6nHUo+ROuVGGuPPz+3G9+H7t/N+r9vwxcYs2/Xr7rw/vW1+nN6Px+3mv93xvX3o9+vu1I5vu7O8K7O4Pz3JUQSfD8e90ud2Hh2Wh0oaxUYjZugCBFcKsKwQdVk2gcipj8/4dQcxdAeUlxzEZQWtsSkAVuoKJV0ppBUPxS3EWvp42TKvBGjFgrQ/ugc5mQsZS7kS4WURDroxNg3ZsXiW+LoLWSyzC8JFF2VFJBRyG7LSQ1gUqStNQdgLOk8p1vLlOZW16SZi4KU5hZXG5JJMIV/Mx18CX23MTItL4/bOhJtbE76lN+Hm5oRv6U74lvaEm/sTbm9QXGlQKnNF5zQKDzVoXWxQXM0izFMSYckEptUJialPiDznzT7qtchKb1DvDMKLLo/xH2zkmmcbUBdt5DUR4r5U5KmpLIqsdGjk7PWIGWhgS5RnFZ9YqBcKf/fnmkSZ21OedYckqj7XmgTlMYkMXaLgiAQGdgl5NEtDEil4LTDhmIsUZwkOQxIUeiKEPCZBfcETwZhESrMEDrrgLpHLzS5GJXqDI8NQgyMn7BI0NqnMfUY4D7qgXgsu4eZExiSifNX2m1YpaVBi3lTD0KTGGqFL8HI508rWnuSXCtNIJc4dDvXrLip3FzWPJVLnx7Y61uDQNwG8fGj7p3tnTbPE2GIH6K0l340HE+FZ4vZEBiVgvoNDymMSlLsE10GJvglADjcnMipR+pd+qGNbEc6TilAGJebH18E7+EUioxLzVzTEEhclmMduOXdytns8nK/+cflUrfNh93Dc2+nz++nx4t23/1/9Hf/H5vX88rh/ej/vVWn+20ZefsrfEFsseKc/zcmpPHNl1hPQ96RnZa+8+1QrfwA="
|
|
409
409
|
},
|
|
410
410
|
{
|
|
411
411
|
"name": "set_authorized_private",
|
|
@@ -2226,9 +2226,9 @@
|
|
|
2226
2226
|
}
|
|
2227
2227
|
}
|
|
2228
2228
|
},
|
|
2229
|
-
"bytecode": "H4sIAAAAAAAA/+
|
|
2230
|
-
"debug_symbols": "
|
|
2231
|
-
"verification_key": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOQAAAAAAAAAAAAAAAAAAAAxbgTnS4stvk7kMsg4ERzSx4AAAAAAAAAAAAAAAAAAAAAABk0+UGfJVFgbmC4Lg0kiQAAAAAAAAAAAAAAAAAAAGqNWWdMsPiEegfpRu7+qCR4AAAAAAAAAAAAAAAAAAAAAAAIO1/
|
|
2229
|
+
"bytecode": "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",
|
|
2230
|
+
"debug_symbols": "tVrRbts6DP2XPOdBFClK7K8Mw5C12RAgSIusHXBR9N8vZVuy006cFqd9KGU7PKaoQ1KS9bp52H9/+fntcPrx+Gtz9+V18/18OB4PP78dH+93z4fHk9593bj8D2hzB/5tu4F8hXFz57cbTCr0ns/3PG7uSNs0ijAKHkUcRRqFbO6iartRwCgUJKnAUdAoFAWcSp5kzFLfiMMbVRNA8fwkcZI0yTDJrA2qRaUnqBfhDx3h4QdqHrzpVfHCt+fzfp+fLNyiznranfen583d6eV43G5+744vw49+Pe1Og3zenfWpWr0/PahUwB+H4z633raztmurUgyTMvtY1WPo1Q/RF31Y6Mde/RWmM5VXJ5fmV2Ovfkpx0hfnW/qhrY9cXIeRqj4RXwBwG8BTAfAcmwB9FiRsAhguEC/FBeRaLpC1PbDGUHACiAhX0AccFBKAW5jgsZtGQeYQcE4qRIALBECDSbUXguEaGxgc1TDyvmmDwQUiBxMEESz4iL7fipCqFYmbVkSDEMAFwvtFQuFLIyAZQ6p/ZUByc/YGpnSJIhYxUsDKDHGuieINj2Ao7EJZkEveIYCB4LAMizblOgyAwg5c+uMDBlp5XopTKeGMAdJvBnPxKHKE67qyxEjhOgyZXSpsuDR+rjtEXDVDUtMMK+A0RdTqy6kVcGgxVP+KFYRz2IfUDxFmeoXgWhBWP7QAln4QNhMHGvwULHlDeJH/LtMGkjGi7EusEse2I6xyWqsZwdIP13RiER/vO2HQMtboiHF2I/l+C4Rq0vNtE8TyY6GkxsicNCH121ALEbilGy9tIDNLuDlLtOmQ53/rqwjhLaoI0doqQmF9FTExOqsIrU+bphmdVaQbw6giJkZnFQnwue7orCJosjTESnWPrXAJBkUhurISgJjiVRDsa+7hhUPfQxgLIkCfKgZ6kVYWD+unoOEmU9Bwkykor56C8g3mbXyDORevn4LyDeZcNslw5joipRbJmE1/1MUWt9atf7GiLra03aY6Wzwl8BVEZ390HUiq/NC2NCeAvcGfFh55F/wRzOCvZug8dI5b9w8QaXaHi00IXJ09ouULcHVTTLOHg2bcR6MwsCOp2xJhJin+gx29WSzGW2SxmNZmsSjrs5iJ0ZnF0vqab5vRl8VsqsfYQXUzZhPXiXpK6Zqa712dqHsXqAWRzEya6r4VuOZyIcVbED2lWxA9yVqii1s/1zcxOuf64lcT3TSjM2ZtjFrikBeb1B9KvknTuqj1LjXXk2LQVFnKZW2fArRqpBg0DbU48WKPJEG/DVL3ekTaGzVizUl1i7vmDV1l8zW7PVKDXrfvoblN7MCqbrUrWui4Ud1MI6o3o1t8efpghFXrca71hNjcrHY3KbK6SrtF8tHPHGuzD7i4Pv3YIJ35B5ysTkC2IZ0ZqB/E2G6wQTrnHgD4yS5Zv28dZ45EF5v71gBrV1CmDVK4HgHbn+3MT03B141rbUszrQPcIqf+xRYUrrYEai4IwfooITwnI0xXfM+P6F39Irv8nqBu/apXu/vD+fLoBuSTD+pFyMccskyTlFF6p1I7nk9SDNLnpDCepMDpJAX68STFIDmH2XieY5BpkpKT4XikY5CQg2A81EHTqQ6ajnXkNJjPdQyS81eJ8VzHINMkFY913MjlaqISJukzuVTiJBUvr+dI8VKWipd3qUjxknqbUt74VymjDG6SkKcKKvPJEadAAUuDhkWiNkJpcGnE0ki5oa8JMjXYlcZwJEUt54ych4uxNDLy8P349+582H0/7vMQ5UF8Od2XEdPL5/+eypNyHOfp/Hi/f3g57/PoLs7k6P8vGsce8uiPB3P0jg9bDF+342NyWwr5sa8aurtPnG9h1ZAtygcN+viOYL+Dq4bGgdd3ZF7+Dw==",
|
|
2231
|
+
"verification_key": "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"
|
|
2232
2232
|
},
|
|
2233
2233
|
{
|
|
2234
2234
|
"name": "set_reject_all",
|
|
@@ -2258,8 +2258,8 @@
|
|
|
2258
2258
|
}
|
|
2259
2259
|
}
|
|
2260
2260
|
},
|
|
2261
|
-
"bytecode": "
|
|
2262
|
-
"debug_symbols": "nZXbjqMwDIbfJddcxM65rzKqKtrSERKiFVNWWlW8+
|
|
2261
|
+
"bytecode": "JwACBAEoAAABBIBFJwAABEUlAAAARicCAgQBJwIDBAAfCgACAAMARBwAREQBLQhEASUAAABHJwIBBEUnAgIEADsOAAIAASYlAAABGh4CAAIBKQIAAwDvUlNNJwIEAAErAgAFAAAAAAAAAAADAAAAAAAAAAAtCAEGJwIHBAUACAEHAScDBgQBACIGAgctCgcILQ4DCAAiCAIILQ4ECAAiCAIILQ4CCAAiCAIILQ4FCC0LBgIAIgICAi0OAgYtCAECJwIDBAUACAEDAScDAgQBACIGAgMAIgICBD8PAAMABCcCAwQBACoCAwUtCwUEJwICAAAKKgQCAycCAgEACioDAgUkAgAFAAABDiUAAAFAHAoBAgAwCgACAAQmKAAABAR4RQwAAAQDJAAAAwAAAT8qAQABBdrF9da0SjJtPAQCASYqAQABBbq7IdeCMxhkPAQCASY=",
|
|
2262
|
+
"debug_symbols": "nZXbjqMwDIbfJddcxM65rzKqKtrSERKiFVNWWlW8+5oSB1gp0cz0or9jyIfxgbzEtTmPn6e2v92/xOHjJc5D23Xt56m7X+pne+/J+xJy/nNWHLASHsQhVCLIRcxbAOyiKKNGv4prFdc6rrWO6hc1Kqpb1GLUyHUQNXJcWNRHjicOABkB2XCLgRLZYA+wB9iD9HjA2fDRUOxR8z2aDI1ssMewx7DHmmg4ek/ws0EehGmqBGf09ByaZk7oJsWU+Ec9NP1THPqx6yrxp+7G901fj7p/67Me6KqsRNNfSQl4a7tmtqZq3S3zW5UMKu5WIG0CGNgRoEDQgQFWp/0Ovx+BAwbIgLkIVJ4AqE0kAAaTCF7vCDpPQM8pVMGn/RrsDmAKIdAvxUDm+hrK+x3EFiDSGy4GyCBlFuIK6TSYXsUlAIY9wBdyQWMTCQjB/gqxFoRmR2URUGgL7QIztFdrPiF8NwoVwlrVTVn/j6LUWRC4uemjZXOdBQWE8VxSuymot78ZDwCVHdBic8q1NxXkgoByayqdWtPrddDNvh5QaE2TRsTgZsqU+kEYLrg1DOqFXBihBDEWE8SCz0GwVBbrOB/Kgdl99460qi/tsDsup5k1tPW5a+LyNvaXzdXn3wdf4eP2MdwvzXUcmpm0nrlA/x9GVyYc50OWFlZWFo/T/Oh/"
|
|
2263
2263
|
},
|
|
2264
2264
|
{
|
|
2265
2265
|
"name": "utility_is_consumable",
|
|
@@ -2326,8 +2326,8 @@
|
|
|
2326
2326
|
}
|
|
2327
2327
|
}
|
|
2328
2328
|
},
|
|
2329
|
-
"bytecode": "H4sIAAAAAAAA/+1cT2wcVxnf+
|
|
2330
|
-
"debug_symbols": "
|
|
2329
|
+
"bytecode": "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",
|
|
2330
|
+
"debug_symbols": "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"
|
|
2331
2331
|
}
|
|
2332
2332
|
],
|
|
2333
2333
|
"outputs": {
|
|
@@ -2638,7 +2638,7 @@
|
|
|
2638
2638
|
},
|
|
2639
2639
|
"19": {
|
|
2640
2640
|
"path": "std/hash/mod.nr",
|
|
2641
|
-
"source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3<let N: u32>(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars, true)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Decompose the input 'bn254 scalar' into two 128 bits limbs.\n// It is called 'unsafe' because it does not assert the limbs are 128 bits\n// Assuming the limbs are 128 bits:\n// Assert the decomposition does not overflow the field size.\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n // Check that the decomposition does not overflow the field size\n let (a, b) = if xhi == crate::field::bn254::PHI {\n (xlo, crate::field::bn254::PLO)\n } else {\n (xhi, crate::field::bn254::PHI)\n };\n crate::field::bn254::assert_lt(a, b);\n\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation<let N: u32>(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal<let N: u32>(input: [Field; N]) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher for BuildHasherDefault<H>\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u8 as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u16 as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u32 as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u64 as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash<H>(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl<T> Hash for [T]\nwhere\n T: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n"
|
|
2641
|
+
"source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3<let N: u32>(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n crate::assert_constant(separator);\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars, true)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n crate::assert_constant(starting_index);\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Decompose the input 'bn254 scalar' into two 128 bits limbs.\n// It is called 'unsafe' because it does not assert the limbs are 128 bits\n// Assuming the limbs are 128 bits:\n// Assert the decomposition does not overflow the field size.\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n // Check that the decomposition does not overflow the field size\n let (a, b) = if xhi == crate::field::bn254::PHI {\n (xlo, crate::field::bn254::PLO)\n } else {\n (xhi, crate::field::bn254::PHI)\n };\n crate::field::bn254::assert_lt(a, b);\n\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation<let N: u32>(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal<let N: u32>(input: [Field; N]) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher for BuildHasherDefault<H>\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u8 as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u16 as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u32 as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u64 as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash<H>(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl<T> Hash for [T]\nwhere\n T: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n"
|
|
2642
2642
|
},
|
|
2643
2643
|
"230": {
|
|
2644
2644
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/version.nr",
|
|
@@ -2654,15 +2654,15 @@
|
|
|
2654
2654
|
},
|
|
2655
2655
|
"309": {
|
|
2656
2656
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/abis/block_header.nr",
|
|
2657
|
-
"source": "use crate::{\n abis::{\n append_only_tree_snapshot::AppendOnlyTreeSnapshot, global_variables::GlobalVariables,\n state_reference::StateReference,\n },\n constants::{BLOCK_HEADER_LENGTH, DOM_SEP__BLOCK_HEADER_HASH, GENESIS_BLOCK_HEADER_HASH},\n hash::poseidon2_hash_with_separator,\n traits::{Deserialize, Empty, Hash, Serialize},\n};\nuse std::meta::derive;\n\n// docs:start:block-header\n#[derive(Deserialize, Eq, Serialize)]\npub struct BlockHeader {\n pub last_archive: AppendOnlyTreeSnapshot,\n pub state: StateReference,\n\n // The hash of the sponge blob for this block, which commits to the tx effects added in this block.\n // Note: it may also include tx effects from previous blocks within the same checkpoint.\n // When proving tx effects from this block only, we must refer to the `sponge_blob_hash` in the previous block\n // header to show that the effect was added after the previous block.\n // The previous block header can be validated using a membership proof of the last leaf in `last_archive`.\n pub sponge_blob_hash: Field,\n\n pub global_variables: GlobalVariables,\n pub total_fees: Field,\n pub total_mana_used: Field,\n}\n// docs:end:block-header\n\nimpl Empty for BlockHeader {\n fn empty() -> Self {\n Self {\n last_archive: AppendOnlyTreeSnapshot::empty(),\n state: StateReference::empty(),\n sponge_blob_hash: 0,\n global_variables: GlobalVariables::empty(),\n total_fees: 0,\n total_mana_used: 0,\n }\n }\n}\n\nimpl Hash for BlockHeader {\n fn hash(self) -> Field {\n poseidon2_hash_with_separator(self.serialize(), DOM_SEP__BLOCK_HEADER_HASH)\n }\n}\n\n#[test]\nfn serialization_of_empty() {\n let header = BlockHeader::empty();\n // We use the BLOCK_HEADER_LENGTH constant to ensure that there is a match\n // between the derived trait implementation and the constant.\n let serialized: [Field; BLOCK_HEADER_LENGTH] = header.serialize();\n let deserialized = BlockHeader::deserialize(serialized);\n assert(header.eq(deserialized));\n}\n\n#[test]\nfn hash_of_genesis_block_header() {\n let mut header = BlockHeader::empty();\n // The following values are taken from world_state.test.cpp > WorldStateTest.GetInitialTreeInfoForAllTrees.\n header.state.l1_to_l2_message_tree.root =\n 0x0d582c10ff8115413aa5b70564fdd2f3cefe1f33a1e43a47bc495081e91e73e5;\n header.state.partial.note_hash_tree.root =\n 0x2ac5dda169f6bb3b9ca09bbac34e14c94d1654597db740153a1288d859a8a30a;\n header.state.partial.nullifier_tree.root =\n 0x1ec3788cd1c32e54d889d67fe29e481114f9d4afe9b44b229aa29d8ad528dd31;\n header.state.partial.nullifier_tree.next_available_leaf_index = 128;\n header.state.partial.public_data_tree.root =\n 0x23c08a6b1297210c5e24c76b9a936250a1ce2721576c26ea797c7ec35f9e46a9;\n header.state.partial.public_data_tree.next_available_leaf_index = 128;\n\n let hash = header.hash();\n assert_eq(hash, GENESIS_BLOCK_HEADER_HASH);\n}\n\n#[test]\nfn hash_of_empty_block_header_match_typescript() {\n let header = BlockHeader::empty();\n let hash = header.hash();\n\n // Value from block_header.test.ts \"computes empty hash\" test\n let test_data_empty_hash =
|
|
2657
|
+
"source": "use crate::{\n abis::{\n append_only_tree_snapshot::AppendOnlyTreeSnapshot, global_variables::GlobalVariables,\n state_reference::StateReference,\n },\n constants::{BLOCK_HEADER_LENGTH, DOM_SEP__BLOCK_HEADER_HASH, GENESIS_BLOCK_HEADER_HASH},\n hash::poseidon2_hash_with_separator,\n traits::{Deserialize, Empty, Hash, Serialize},\n};\nuse std::meta::derive;\n\n// docs:start:block-header\n#[derive(Deserialize, Eq, Serialize)]\npub struct BlockHeader {\n pub last_archive: AppendOnlyTreeSnapshot,\n pub state: StateReference,\n\n // The hash of the sponge blob for this block, which commits to the tx effects added in this block.\n // Note: it may also include tx effects from previous blocks within the same checkpoint.\n // When proving tx effects from this block only, we must refer to the `sponge_blob_hash` in the previous block\n // header to show that the effect was added after the previous block.\n // The previous block header can be validated using a membership proof of the last leaf in `last_archive`.\n pub sponge_blob_hash: Field,\n\n pub global_variables: GlobalVariables,\n pub total_fees: Field,\n pub total_mana_used: Field,\n}\n// docs:end:block-header\n\nimpl Empty for BlockHeader {\n fn empty() -> Self {\n Self {\n last_archive: AppendOnlyTreeSnapshot::empty(),\n state: StateReference::empty(),\n sponge_blob_hash: 0,\n global_variables: GlobalVariables::empty(),\n total_fees: 0,\n total_mana_used: 0,\n }\n }\n}\n\nimpl Hash for BlockHeader {\n fn hash(self) -> Field {\n poseidon2_hash_with_separator(self.serialize(), DOM_SEP__BLOCK_HEADER_HASH)\n }\n}\n\n#[test]\nfn serialization_of_empty() {\n let header = BlockHeader::empty();\n // We use the BLOCK_HEADER_LENGTH constant to ensure that there is a match\n // between the derived trait implementation and the constant.\n let serialized: [Field; BLOCK_HEADER_LENGTH] = header.serialize();\n let deserialized = BlockHeader::deserialize(serialized);\n assert(header.eq(deserialized));\n}\n\n#[test]\nfn hash_of_genesis_block_header() {\n let mut header = BlockHeader::empty();\n // The following values are taken from world_state.test.cpp > WorldStateTest.GetInitialTreeInfoForAllTrees.\n header.state.l1_to_l2_message_tree.root =\n 0x0d582c10ff8115413aa5b70564fdd2f3cefe1f33a1e43a47bc495081e91e73e5;\n header.state.partial.note_hash_tree.root =\n 0x2ac5dda169f6bb3b9ca09bbac34e14c94d1654597db740153a1288d859a8a30a;\n header.state.partial.nullifier_tree.root =\n 0x1ec3788cd1c32e54d889d67fe29e481114f9d4afe9b44b229aa29d8ad528dd31;\n header.state.partial.nullifier_tree.next_available_leaf_index = 128;\n header.state.partial.public_data_tree.root =\n 0x23c08a6b1297210c5e24c76b9a936250a1ce2721576c26ea797c7ec35f9e46a9;\n header.state.partial.public_data_tree.next_available_leaf_index = 128;\n\n let hash = header.hash();\n assert_eq(hash, GENESIS_BLOCK_HEADER_HASH);\n}\n\n#[test]\nfn hash_of_empty_block_header_match_typescript() {\n let header = BlockHeader::empty();\n let hash = header.hash();\n\n // Value from block_header.test.ts \"computes empty hash\" test\n let test_data_empty_hash = 0x0bdc537052dea0f80db9698585dff9f32063b86b6d4934ac17c30c81e8e416d3;\n assert_eq(hash, test_data_empty_hash);\n}\n"
|
|
2658
2658
|
},
|
|
2659
2659
|
"388": {
|
|
2660
2660
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
|
|
2661
|
-
"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 hash_from_typescript = 0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n assert_eq(hash, hash_from_typescript);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n let separator = 42;\n\n // Hash using bounded vec version\n let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n // Hash using regular version\n let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n // Results should match\n assert_eq(bounded_result, regular_result);\n}\n"
|
|
2661
|
+
"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"
|
|
2662
2662
|
},
|
|
2663
2663
|
"416": {
|
|
2664
2664
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr",
|
|
2665
|
-
"source": "use crate::{\n constants::DOM_SEP__PUBLIC_STORAGE_MAP_SLOT, hash::poseidon2_hash_with_separator,\n traits::ToField,\n};\n\n// TODO: Move this to src/public_data/storage/map.nr\npub fn derive_storage_slot_in_map<K>(storage_slot: Field, key: K) -> Field\nwhere\n K: ToField,\n{\n poseidon2_hash_with_separator(\n [storage_slot, key.to_field()],\n DOM_SEP__PUBLIC_STORAGE_MAP_SLOT,\n )\n}\n\nmod test {\n use crate::{address::AztecAddress, storage::map::derive_storage_slot_in_map, traits::FromField};\n\n #[test]\n fn test_derive_storage_slot_in_map_matches_typescript() {\n let map_slot = 0x132258fb6962c4387ba659d9556521102d227549a386d39f0b22d1890d59c2b5;\n let key = AztecAddress::from_field(\n 0x302dbc2f9b50a73283d5fb2f35bc01eae8935615817a0b4219a057b2ba8a5a3f,\n );\n\n let slot = derive_storage_slot_in_map(map_slot, key);\n\n // The following value was generated by `map_slot.test.ts`\n let slot_from_typescript =\n
|
|
2665
|
+
"source": "use crate::{\n constants::DOM_SEP__PUBLIC_STORAGE_MAP_SLOT, hash::poseidon2_hash_with_separator,\n traits::ToField,\n};\n\n// TODO: Move this to src/public_data/storage/map.nr\npub fn derive_storage_slot_in_map<K>(storage_slot: Field, key: K) -> Field\nwhere\n K: ToField,\n{\n poseidon2_hash_with_separator(\n [storage_slot, key.to_field()],\n DOM_SEP__PUBLIC_STORAGE_MAP_SLOT,\n )\n}\n\nmod test {\n use crate::{address::AztecAddress, storage::map::derive_storage_slot_in_map, traits::FromField};\n\n #[test]\n fn test_derive_storage_slot_in_map_matches_typescript() {\n let map_slot = 0x132258fb6962c4387ba659d9556521102d227549a386d39f0b22d1890d59c2b5;\n let key = AztecAddress::from_field(\n 0x302dbc2f9b50a73283d5fb2f35bc01eae8935615817a0b4219a057b2ba8a5a3f,\n );\n\n let slot = derive_storage_slot_in_map(map_slot, key);\n\n // The following value was generated by `map_slot.test.ts`\n let slot_from_typescript =\n 0x2d225f361108379adc2da91378b9702675c5546b57e78bafc1e74ec7fec55967;\n\n assert_eq(slot, slot_from_typescript);\n }\n}\n"
|
|
2666
2666
|
},
|
|
2667
2667
|
"42": {
|
|
2668
2668
|
"path": "std/option.nr",
|
|
@@ -2686,7 +2686,7 @@
|
|
|
2686
2686
|
},
|
|
2687
2687
|
"449": {
|
|
2688
2688
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/type_impls.nr",
|
|
2689
|
-
"source": "use crate::{reader::Reader, serialization::{Deserialize, Serialize}, writer::Writer};\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint;\nuse dep::std::embedded_curve_ops::EmbeddedCurveScalar;\n\nglobal U1_SERIALIZED_LEN: u32 = 1;\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize for bool {\n let N: u32 = BOOL_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for bool {\n let N: u32 = BOOL_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> bool {\n reader.read() != 0\n }\n}\n\nimpl Serialize for u1 {\n let N: u32 = U1_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u1 {\n let N: u32 = U1_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u1\n }\n}\n\nimpl Serialize for u8 {\n let N: u32 = U8_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u8 {\n let N: u32 = U8_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u8\n }\n}\n\nimpl Serialize for u16 {\n let N: u32 = U16_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u16 {\n let N: u32 = U16_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u16\n }\n}\n\nimpl Serialize for u32 {\n let N: u32 = U32_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u32 {\n let N: u32 = U32_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u32\n }\n}\n\nimpl Serialize for u64 {\n let N: u32 = U64_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u64 {\n let N: u32 = U64_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u64\n }\n}\n\nimpl Serialize for u128 {\n let N: u32 = U128_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u128 {\n let N: u32 = U128_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u128\n }\n}\n\nimpl Serialize for Field {\n let N: u32 = FIELD_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self);\n }\n}\n\nimpl Deserialize for Field {\n let N: u32 = FIELD_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read()\n }\n}\n\nimpl Serialize for i8 {\n let N: u32 = I8_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as u8 as Field);\n }\n}\n\nimpl Deserialize for i8 {\n let N: u32 = I8_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u8 as i8\n }\n}\n\nimpl Serialize for i16 {\n let N: u32 = I16_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as u16 as Field);\n }\n}\n\nimpl Deserialize for i16 {\n let N: u32 = I16_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u16 as i16\n }\n}\n\nimpl Serialize for i32 {\n let N: u32 = I32_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as u32 as Field);\n }\n}\n\nimpl Deserialize for i32 {\n let N: u32 = I32_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u32 as i32\n }\n}\n\nimpl Serialize for i64 {\n let N: u32 = I64_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as u64 as Field);\n }\n}\n\nimpl Deserialize for i64 {\n let N: u32 = I64_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u64 as i64\n }\n}\n\nimpl<T, let M: u32> Serialize for [T; M]\nwhere\n T: Serialize,\n{\n let N: u32 = <T as Serialize>::N * M;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n for i in 0..M {\n self[i].stream_serialize(writer);\n }\n }\n}\n\nimpl<T, let M: u32> Deserialize for [T; M]\nwhere\n T: Deserialize,\n{\n let N: u32 = <T as Deserialize>::N * M;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n let mut result: [T; M] = std::mem::zeroed();\n for i in 0..M {\n result[i] = T::stream_deserialize(reader);\n }\n result\n }\n}\n\nimpl<T> Serialize for Option<T>\nwhere\n T: Serialize,\n{\n let N: u32 = <T as Serialize>::N + 1;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write_bool(self.is_some());\n if self.is_some() {\n self.unwrap_unchecked().stream_serialize(writer);\n } else {\n writer.advance_offset(<T as Serialize>::N);\n }\n }\n}\n\nimpl<T> Deserialize for Option<T>\nwhere\n T: Deserialize,\n{\n let N: u32 = <T as Deserialize>::N + 1;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n if reader.read_bool() {\n Option::some(<T as Deserialize>::stream_deserialize(reader))\n } else {\n reader.advance_offset(<T as Deserialize>::N);\n Option::none()\n }\n }\n}\n\nglobal SCALAR_SIZE: u32 = 2;\n\nimpl Serialize for EmbeddedCurveScalar {\n\n let N: u32 = SCALAR_SIZE;\n\n fn serialize(self) -> [Field; SCALAR_SIZE] {\n [self.lo, self.hi]\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self.lo);\n writer.write(self.hi);\n }\n}\n\nimpl Deserialize for EmbeddedCurveScalar {\n let N: u32 = SCALAR_SIZE;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n Self { lo: fields[0], hi: fields[1] }\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n Self { lo: reader.read(), hi: reader.read() }\n }\n}\n\nglobal POINT_SIZE: u32 = 3;\n\nimpl Serialize for EmbeddedCurvePoint {\n let N: u32 = POINT_SIZE;\n\n fn serialize(self) -> [Field; Self::N] {\n [self.x, self.y, self.is_infinite as Field]\n }\n\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self.x);\n writer.write(self.y);\n writer.write(self.is_infinite as Field);\n }\n}\n\nimpl Deserialize for EmbeddedCurvePoint {\n let N: u32 = POINT_SIZE;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n Self { x: fields[0], y: fields[1], is_infinite: fields[2] != 0 }\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n Self { x: reader.read(), y: reader.read(), is_infinite: reader.read_bool() }\n }\n}\n\nimpl<let M: u32> Deserialize for str<M> {\n let N: u32 = M;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n let u8_arr = <[u8; Self::N] as Deserialize>::stream_deserialize(reader);\n str::<Self::N>::from(u8_arr)\n }\n}\n\nimpl<let M: u32> Serialize for str<M> {\n let N: u32 = M;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n self.as_bytes().stream_serialize(writer);\n }\n}\n\n// Note: Not deriving this because it's not supported to call derive_serialize on a \"remote\" struct (and it will never\n// be supported).\nimpl<T, let M: u32> Deserialize for BoundedVec<T, M>\nwhere\n T: Deserialize,\n{\n let N: u32 = <T as Deserialize>::N * M + 1;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n let mut new_bounded_vec: BoundedVec<T, M> = BoundedVec::new();\n let payload_len = Self::N - 1;\n\n // Length is stored in the last field as we need to match intrinsic Noir serialization and the `len` struct\n // field is after `storage` struct field (see `bounded_vec.nr` in noir-stdlib)\n let len = reader.peek_offset(payload_len) as u32;\n\n for i in 0..M {\n if i < len {\n new_bounded_vec.push(<T as Deserialize>::stream_deserialize(reader));\n }\n }\n\n // +1 for the length of the BoundedVec\n reader.advance_offset((M - len) * <T as Deserialize>::N + 1);\n\n new_bounded_vec\n }\n}\n\n// This may cause issues if used as program input, because noir disallows empty arrays for program input.\n// I think this is okay because I don't foresee a unit type being used as input. But leaving this comment as a hint\n// if someone does run into this in the future.\nimpl Deserialize for () {\n let N: u32 = 0;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(_reader: &mut Reader<K>) -> Self {\n ()\n }\n}\n\n// Note: Not deriving this because it's not supported to call derive_serialize on a \"remote\" struct (and it will never\n// be supported).\nimpl<T, let M: u32> Serialize for BoundedVec<T, M>\nwhere\n T: Serialize,\n{\n let N: u32 = <T as Serialize>::N * M + 1; // +1 for the length of the BoundedVec\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n self.storage().stream_serialize(writer);\n // Length is stored in the last field as we need to match intrinsic Noir serialization and the `len` struct\n // field is after `storage` struct field (see `bounded_vec.nr` in noir-stdlib)\n writer.write_u32(self.len() as u32);\n }\n}\n\n// Create a slice of the given length with each element made from `f(i)` where `i` is the current index\ncomptime fn make_slice<Env, T>(length: u32, f: fn[Env](u32) -> T) -> [T] {\n let mut slice = @[];\n for i in 0..length {\n slice = slice.push_back(f(i));\n }\n slice\n}\n\n// Implements Serialize and Deserialize for an arbitrary tuple type\ncomptime fn impl_serialize_for_tuple(_m: Module, length: u32) -> Quoted {\n // `T0`, `T1`, `T2`\n let type_names = make_slice(length, |i| f\"T{i}\".quoted_contents());\n\n // `result0`, `result1`, `result2`\n let result_names = make_slice(length, |i| f\"result{i}\".quoted_contents());\n\n // `T0, T1, T2`\n let field_generics = type_names.join(quote [,]);\n\n // `<T0 as Serialize>::N + <T1 as Serialize>::N + <T2 as Serialize>::N`\n let full_size_serialize = type_names\n .map(|type_name| quote {\n <$type_name as Serialize>::N\n })\n .join(quote [+]);\n\n // `<T0 as Deserialize>::N + <T1 as Deserialize>::N + <T2 as Deserialize>::N`\n let full_size_deserialize = type_names\n .map(|type_name| quote {\n <$type_name as Deserialize>::N\n })\n .join(quote [+]);\n\n // `T0: Serialize, T1: Serialize, T2: Serialize,`\n let serialize_constraints = type_names\n .map(|field_name| quote {\n $field_name: Serialize,\n })\n .join(quote []);\n\n // `T0: Deserialize, T1: Deserialize, T2: Deserialize,`\n let deserialize_constraints = type_names\n .map(|field_name| quote {\n $field_name: Deserialize,\n })\n .join(quote []);\n\n // Statements to serialize each field\n let serialized_fields = type_names\n .mapi(|i, _type_name| quote {\n $crate::serialization::Serialize::stream_serialize(self.$i, writer);\n })\n .join(quote []);\n\n // Statements to deserialize each field\n let deserialized_fields = type_names\n .mapi(|i, type_name| {\n let result_name = result_names[i];\n quote {\n let $result_name = <$type_name as $crate::serialization::Deserialize>::stream_deserialize(reader);\n }\n })\n .join(quote []);\n let deserialize_results = result_names.join(quote [,]);\n\n quote {\n impl<$field_generics> Serialize for ($field_generics) where $serialize_constraints {\n let N: u32 = $full_size_serialize;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: $crate::writer::Writer<Self::N> = $crate::writer::Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut $crate::writer::Writer<K>) {\n\n $serialized_fields\n }\n }\n\n impl<$field_generics> Deserialize for ($field_generics) where $deserialize_constraints {\n let N: u32 = $full_size_deserialize;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = $crate::reader::Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n \n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut $crate::reader::Reader<K>) -> Self {\n $deserialized_fields\n ($deserialize_results)\n }\n }\n }\n}\n\n// Keeping these manual impls. They are more efficient since they do not\n// require copying sub-arrays from any serialized arrays.\nimpl<T1> Serialize for (T1,)\nwhere\n T1: Serialize,\n{\n let N: u32 = <T1 as Serialize>::N;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: crate::writer::Writer<Self::N> = crate::writer::Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n self.0.stream_serialize(writer);\n }\n}\n\nimpl<T1> Deserialize for (T1,)\nwhere\n T1: Deserialize,\n{\n let N: u32 = <T1 as Deserialize>::N;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = crate::reader::Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n (<T1 as Deserialize>::stream_deserialize(reader),)\n }\n}\n\n#[impl_serialize_for_tuple(2)]\n#[impl_serialize_for_tuple(3)]\n#[impl_serialize_for_tuple(4)]\n#[impl_serialize_for_tuple(5)]\n#[impl_serialize_for_tuple(6)]\nmod impls {\n use crate::serialization::{Deserialize, Serialize};\n}\n"
|
|
2689
|
+
"source": "use crate::{reader::Reader, serialization::{Deserialize, Serialize}, writer::Writer};\nuse ::std::embedded_curve_ops::EmbeddedCurvePoint;\nuse ::std::embedded_curve_ops::EmbeddedCurveScalar;\n\nglobal U1_SERIALIZED_LEN: u32 = 1;\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize for bool {\n let N: u32 = BOOL_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for bool {\n let N: u32 = BOOL_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> bool {\n reader.read() != 0\n }\n}\n\nimpl Serialize for u1 {\n let N: u32 = U1_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u1 {\n let N: u32 = U1_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u1\n }\n}\n\nimpl Serialize for u8 {\n let N: u32 = U8_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u8 {\n let N: u32 = U8_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u8\n }\n}\n\nimpl Serialize for u16 {\n let N: u32 = U16_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u16 {\n let N: u32 = U16_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u16\n }\n}\n\nimpl Serialize for u32 {\n let N: u32 = U32_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u32 {\n let N: u32 = U32_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u32\n }\n}\n\nimpl Serialize for u64 {\n let N: u32 = U64_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u64 {\n let N: u32 = U64_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u64\n }\n}\n\nimpl Serialize for u128 {\n let N: u32 = U128_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u128 {\n let N: u32 = U128_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u128\n }\n}\n\nimpl Serialize for Field {\n let N: u32 = FIELD_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self);\n }\n}\n\nimpl Deserialize for Field {\n let N: u32 = FIELD_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read()\n }\n}\n\nimpl Serialize for i8 {\n let N: u32 = I8_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as u8 as Field);\n }\n}\n\nimpl Deserialize for i8 {\n let N: u32 = I8_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u8 as i8\n }\n}\n\nimpl Serialize for i16 {\n let N: u32 = I16_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as u16 as Field);\n }\n}\n\nimpl Deserialize for i16 {\n let N: u32 = I16_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u16 as i16\n }\n}\n\nimpl Serialize for i32 {\n let N: u32 = I32_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as u32 as Field);\n }\n}\n\nimpl Deserialize for i32 {\n let N: u32 = I32_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u32 as i32\n }\n}\n\nimpl Serialize for i64 {\n let N: u32 = I64_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as u64 as Field);\n }\n}\n\nimpl Deserialize for i64 {\n let N: u32 = I64_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u64 as i64\n }\n}\n\nimpl<T, let M: u32> Serialize for [T; M]\nwhere\n T: Serialize,\n{\n let N: u32 = <T as Serialize>::N * M;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n for i in 0..M {\n self[i].stream_serialize(writer);\n }\n }\n}\n\nimpl<T, let M: u32> Deserialize for [T; M]\nwhere\n T: Deserialize,\n{\n let N: u32 = <T as Deserialize>::N * M;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n let mut result: [T; M] = std::mem::zeroed();\n for i in 0..M {\n result[i] = T::stream_deserialize(reader);\n }\n result\n }\n}\n\nimpl<T> Serialize for Option<T>\nwhere\n T: Serialize,\n{\n let N: u32 = <T as Serialize>::N + 1;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write_bool(self.is_some());\n if self.is_some() {\n self.unwrap_unchecked().stream_serialize(writer);\n } else {\n writer.advance_offset(<T as Serialize>::N);\n }\n }\n}\n\nimpl<T> Deserialize for Option<T>\nwhere\n T: Deserialize,\n{\n let N: u32 = <T as Deserialize>::N + 1;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n if reader.read_bool() {\n Option::some(<T as Deserialize>::stream_deserialize(reader))\n } else {\n reader.advance_offset(<T as Deserialize>::N);\n Option::none()\n }\n }\n}\n\nglobal SCALAR_SIZE: u32 = 2;\n\nimpl Serialize for EmbeddedCurveScalar {\n\n let N: u32 = SCALAR_SIZE;\n\n fn serialize(self) -> [Field; SCALAR_SIZE] {\n [self.lo, self.hi]\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self.lo);\n writer.write(self.hi);\n }\n}\n\nimpl Deserialize for EmbeddedCurveScalar {\n let N: u32 = SCALAR_SIZE;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n Self { lo: fields[0], hi: fields[1] }\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n Self { lo: reader.read(), hi: reader.read() }\n }\n}\n\nglobal POINT_SIZE: u32 = 3;\n\nimpl Serialize for EmbeddedCurvePoint {\n let N: u32 = POINT_SIZE;\n\n fn serialize(self) -> [Field; Self::N] {\n [self.x, self.y, self.is_infinite as Field]\n }\n\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self.x);\n writer.write(self.y);\n writer.write(self.is_infinite as Field);\n }\n}\n\nimpl Deserialize for EmbeddedCurvePoint {\n let N: u32 = POINT_SIZE;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n Self { x: fields[0], y: fields[1], is_infinite: fields[2] != 0 }\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n Self { x: reader.read(), y: reader.read(), is_infinite: reader.read_bool() }\n }\n}\n\nimpl<let M: u32> Deserialize for str<M> {\n let N: u32 = M;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n let u8_arr = <[u8; Self::N] as Deserialize>::stream_deserialize(reader);\n str::<Self::N>::from(u8_arr)\n }\n}\n\nimpl<let M: u32> Serialize for str<M> {\n let N: u32 = M;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n self.as_bytes().stream_serialize(writer);\n }\n}\n\n// Note: Not deriving this because it's not supported to call derive_serialize on a \"remote\" struct (and it will never\n// be supported).\nimpl<T, let M: u32> Deserialize for BoundedVec<T, M>\nwhere\n T: Deserialize,\n{\n let N: u32 = <T as Deserialize>::N * M + 1;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n let mut new_bounded_vec: BoundedVec<T, M> = BoundedVec::new();\n let payload_len = Self::N - 1;\n\n // Length is stored in the last field as we need to match intrinsic Noir serialization and the `len` struct\n // field is after `storage` struct field (see `bounded_vec.nr` in noir-stdlib)\n let len = reader.peek_offset(payload_len) as u32;\n\n for i in 0..M {\n if i < len {\n new_bounded_vec.push(<T as Deserialize>::stream_deserialize(reader));\n }\n }\n\n // +1 for the length of the BoundedVec\n reader.advance_offset((M - len) * <T as Deserialize>::N + 1);\n\n new_bounded_vec\n }\n}\n\n// This may cause issues if used as program input, because noir disallows empty arrays for program input.\n// I think this is okay because I don't foresee a unit type being used as input. But leaving this comment as a hint\n// if someone does run into this in the future.\nimpl Deserialize for () {\n let N: u32 = 0;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(_reader: &mut Reader<K>) -> Self {\n ()\n }\n}\n\n// Note: Not deriving this because it's not supported to call derive_serialize on a \"remote\" struct (and it will never\n// be supported).\nimpl<T, let M: u32> Serialize for BoundedVec<T, M>\nwhere\n T: Serialize,\n{\n let N: u32 = <T as Serialize>::N * M + 1; // +1 for the length of the BoundedVec\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n self.storage().stream_serialize(writer);\n // Length is stored in the last field as we need to match intrinsic Noir serialization and the `len` struct\n // field is after `storage` struct field (see `bounded_vec.nr` in noir-stdlib)\n writer.write_u32(self.len() as u32);\n }\n}\n\n// Create a slice of the given length with each element made from `f(i)` where `i` is the current index\ncomptime fn make_slice<Env, T>(length: u32, f: fn[Env](u32) -> T) -> [T] {\n let mut slice = @[];\n for i in 0..length {\n slice = slice.push_back(f(i));\n }\n slice\n}\n\n// Implements Serialize and Deserialize for an arbitrary tuple type\ncomptime fn impl_serialize_for_tuple(_m: Module, length: u32) -> Quoted {\n // `T0`, `T1`, `T2`\n let type_names = make_slice(length, |i| f\"T{i}\".quoted_contents());\n\n // `result0`, `result1`, `result2`\n let result_names = make_slice(length, |i| f\"result{i}\".quoted_contents());\n\n // `T0, T1, T2`\n let field_generics = type_names.join(quote [,]);\n\n // `<T0 as Serialize>::N + <T1 as Serialize>::N + <T2 as Serialize>::N`\n let full_size_serialize = type_names\n .map(|type_name| quote {\n <$type_name as Serialize>::N\n })\n .join(quote [+]);\n\n // `<T0 as Deserialize>::N + <T1 as Deserialize>::N + <T2 as Deserialize>::N`\n let full_size_deserialize = type_names\n .map(|type_name| quote {\n <$type_name as Deserialize>::N\n })\n .join(quote [+]);\n\n // `T0: Serialize, T1: Serialize, T2: Serialize,`\n let serialize_constraints = type_names\n .map(|field_name| quote {\n $field_name: Serialize,\n })\n .join(quote []);\n\n // `T0: Deserialize, T1: Deserialize, T2: Deserialize,`\n let deserialize_constraints = type_names\n .map(|field_name| quote {\n $field_name: Deserialize,\n })\n .join(quote []);\n\n // Statements to serialize each field\n let serialized_fields = type_names\n .mapi(|i, _type_name| quote {\n $crate::serialization::Serialize::stream_serialize(self.$i, writer);\n })\n .join(quote []);\n\n // Statements to deserialize each field\n let deserialized_fields = type_names\n .mapi(|i, type_name| {\n let result_name = result_names[i];\n quote {\n let $result_name = <$type_name as $crate::serialization::Deserialize>::stream_deserialize(reader);\n }\n })\n .join(quote []);\n let deserialize_results = result_names.join(quote [,]);\n\n quote {\n impl<$field_generics> Serialize for ($field_generics) where $serialize_constraints {\n let N: u32 = $full_size_serialize;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: $crate::writer::Writer<Self::N> = $crate::writer::Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut $crate::writer::Writer<K>) {\n\n $serialized_fields\n }\n }\n\n impl<$field_generics> Deserialize for ($field_generics) where $deserialize_constraints {\n let N: u32 = $full_size_deserialize;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = $crate::reader::Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n \n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut $crate::reader::Reader<K>) -> Self {\n $deserialized_fields\n ($deserialize_results)\n }\n }\n }\n}\n\n// Keeping these manual impls. They are more efficient since they do not\n// require copying sub-arrays from any serialized arrays.\nimpl<T1> Serialize for (T1,)\nwhere\n T1: Serialize,\n{\n let N: u32 = <T1 as Serialize>::N;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: crate::writer::Writer<Self::N> = crate::writer::Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n self.0.stream_serialize(writer);\n }\n}\n\nimpl<T1> Deserialize for (T1,)\nwhere\n T1: Deserialize,\n{\n let N: u32 = <T1 as Deserialize>::N;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = crate::reader::Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n (<T1 as Deserialize>::stream_deserialize(reader),)\n }\n}\n\n#[impl_serialize_for_tuple(2)]\n#[impl_serialize_for_tuple(3)]\n#[impl_serialize_for_tuple(4)]\n#[impl_serialize_for_tuple(5)]\n#[impl_serialize_for_tuple(6)]\nmod impls {\n use crate::serialization::{Deserialize, Serialize};\n}\n"
|
|
2690
2690
|
},
|
|
2691
2691
|
"450": {
|
|
2692
2692
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/writer.nr",
|