@aztec/protocol-contracts 0.0.1-commit.6d63667d → 0.0.1-commit.7cf39cb55
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 +28 -28
- package/artifacts/ContractClassRegistry.json +50 -4012
- package/artifacts/ContractInstanceRegistry.json +28 -28
- package/artifacts/FeeJuice.json +21 -21
- package/artifacts/MultiCallEntrypoint.json +27 -27
- package/artifacts/PublicChecks.json +22 -22
- package/dest/make_protocol_contract.js +2 -1
- package/dest/protocol_contract_data.js +14 -14
- package/dest/scripts/generate_data.js +7 -9
- package/package.json +4 -4
- package/src/make_protocol_contract.ts +1 -1
- 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+2db78f8894936db05c53430f364360ac9cc5c61f",
|
|
4
4
|
"name": "ContractInstanceRegistry",
|
|
5
5
|
"functions": [
|
|
6
6
|
{
|
|
@@ -35,8 +35,8 @@
|
|
|
35
35
|
}
|
|
36
36
|
}
|
|
37
37
|
},
|
|
38
|
-
"bytecode": "
|
|
39
|
-
"debug_symbols": "
|
|
38
|
+
"bytecode": "JwACBAEoAAABBIBFJwAABEUlAAAAQScCAQQAJwICBAAfCgABAAIARCUAAABCLQIBRCcCAgREJwIDBAE7DgADAAImJQAAAnUeAgACCScCAwEBJAIAAgAAAF4lAAACmx4CAAIBKQIAAwDvUlNNJwIEAAErAgAFAAAAAAAAAAADAAAAAAAAAAAtCAEGJwIHBAUACAEHAScDBgQBACIGAgctCgcILQ4DCAAiCAIILQ4ECAAiCAIILQ4CCAAiCAIILQ4FCC0LBgIAIgICAi0OAgYtCAECJwIDBAUACAEDAScDAgQBACIGAgMAIgICBD8PAAMABCcCAwQBACoCAwUtCwUEJwICAAAKKgQCAycCAgEACioDAgUkAgAFAAABICUAAAKtHgIAAgYeAgADAC8qAAQAAwAFHAoFBAQcCgQDAAIqBQMELAIAAwAtXgmLgro3tDuZoTFhGP0g1C9RZsnp8T+16mWpbR4KbQQqBAMFHAoFBgQcCgYEAAIqBQQGBCoGAwUcCgUHARwKBwYAHAoGBwECKgUGCCwCAAUAMDPqJG5QbomOl/Vwyv/XBMsLtGAxP7cgsp4TnlwQAAEEKggFCRwKCQoEHAoKCAACKgkICgQqCgMJHAoJCgEcCgoDABwKAwoBAioJAwsEKgsFCRwKCQsEHAoLBQAcCgUJBRYKCgUcCgMKBRwKBQMFBCoKCQUcCggJBRYKBwgcCgYHBRwKCAYFBCoHCQgcCgQJBQwqAgkEKQIAAgUAAVGAJAIABAAAAlwjAAACRAQqBwgDBCoGAgQAKgMEAi0KAgEjAAACdAQqCgUEBCoDAgUAKgQFAi0KAgEjAAACdCYoAAAEBHhFDAAABAMkAAADAAACmioBAAEF2sX11rRKMm08BAIBJioBAAEFT99KitfP8NM8BAIBJioBAAEFursh14IzGGQ8BAIBJg==",
|
|
39
|
+
"debug_symbols": "nZjdbtswDIXfxde5kEjqh3mVoSjS1h0CBGmRJQOGIu8+MjElp4CETTfxyXH8mZQoWvHX9Da/XH4+74/vH7+m7Y+v6eW0Pxz2P58PH6+78/7jKO7X5PQj+WmLmynFaUubKfv7gW8Hpmkb5SDfvPzGu7wIj4tAMmGnyE6ROcGcYE4EE3ERGsVdhEVkZ8JukS0MNiCnuwAHJhQYRHhnIiwCzAFz0Bw0hzSMqCIuIpgT9DdZRHQmzEnmJHMympCUAURozKAOi4NuM6GGinIKvTehjmSBoI6MP+qI3USUyzGoyItI6kQV6iQRelPMKvIi2JzbTXkzkROH5O5EzoTETF5EcCbUkXhIMyVUoY6EQZrpXZij00RBhToSD7E6SUW4i+DUySqWq4LjxfFkwhxQh1XwPfiAuDhaYzdB5miNBckiaI0FuF43k1X48/k0z1rgq5KXhfC5O83H87Q9Xg6HzfR7d7jcfvTrc3e8Hc+7k5wV5Hx8k6MA3/eHWdV1U6927Uu9B+blclkn4Asi+AeGbzM4QlwQHClVAj8QoBOFy1SCcJWQYDQPbOXRZRBVBkVoMUKbgYWAkYbyIHA1BsqtGFKHAVridwRwKIRMD4TcJkC2GGQtluvJxwcAd0rCcykJwDoZmNNjVXWGIjNaUWTOvs3olCYGKInUspKu9kjolCb4nBcESFJjjDohIM22zaA2gxIbgzLW0vT8z2Egc53W1bx+D6NXWr6uMnkktErL9xDOF4TDFQIH10hu96xOhUq7KKXhPLXCgF6BynPFCpTYN/tepz5jGc7km22vlwa60nvRrbrF9zSwg0hYRiKF1ERQb04hxDKpkNrPgNCDOK2bBeKQmpDYGdC6XKPss5qIToFCKguemy28lwhzgprHuoV/C6I3r0G3MvdJCZ0wuvOaS2lk4Na8ou8tEiiNi7Emgon/gxFL15EZHmQEros1DDHQBV8Y0Q8yyoqXfTCOMqgwII0xfEiFEeMgo5YH+NE4chkP+X8yxoCaC8TBOCCXuUU/Gkfd9CDQGANDWbW42j/+HyOXdkx+mFHGg2BwvVBdLzS6XlLZwsmjZXBMc+mmKFvCMQYn6x/kHDcZ//ykXc3tt3Yaem1MnmrWTt3qj5LM+PX6JF93r/vTw0uPq8JO+93LYV6+vl+Or6uz5z+fdsZemnyePl7nt8tpVlJ9c6KvGH54xxvZMj3pSxH9Kv/6Pbinq97+Lw=="
|
|
40
40
|
},
|
|
41
41
|
{
|
|
42
42
|
"name": "public_dispatch",
|
|
@@ -107,8 +107,8 @@
|
|
|
107
107
|
}
|
|
108
108
|
}
|
|
109
109
|
},
|
|
110
|
-
"bytecode": "JwACBAEoAAABBIBUJwAABFQlAAAAQScCAgQBJwIDBAAfCgACAAMAUy0IUwElAAAA8CcCAQRUJwICBAA7DgACAAEpAABDAPqRAsspAABEAMB7XhkpAABFAAVVe/
|
|
111
|
-
"debug_symbols": "
|
|
110
|
+
"bytecode": "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",
|
|
111
|
+
"debug_symbols": "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"
|
|
112
112
|
},
|
|
113
113
|
{
|
|
114
114
|
"name": "publish_for_public_execution",
|
|
@@ -2094,9 +2094,9 @@
|
|
|
2094
2094
|
}
|
|
2095
2095
|
}
|
|
2096
2096
|
},
|
|
2097
|
-
"bytecode": "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",
|
|
2098
|
-
"debug_symbols": "
|
|
2099
|
-
"verification_key": "
|
|
2097
|
+
"bytecode": "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",
|
|
2098
|
+
"debug_symbols": "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",
|
|
2099
|
+
"verification_key": "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"
|
|
2100
2100
|
},
|
|
2101
2101
|
{
|
|
2102
2102
|
"name": "set_update_delay",
|
|
@@ -2152,8 +2152,8 @@
|
|
|
2152
2152
|
}
|
|
2153
2153
|
}
|
|
2154
2154
|
},
|
|
2155
|
-
"bytecode": "JwACBAEoAAABBIBLJwAABEslAAAARicCAgQBJwIDBAAfCgACAAMAShwASkoFLQhKASUAAACMJwIBBEsnAgIEADsOAAIAASgAAEMFAlgsAABEADBkTnLhMaApuFBFtoGBWF0oM+
|
|
2156
|
-
"debug_symbols": "
|
|
2155
|
+
"bytecode": "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",
|
|
2156
|
+
"debug_symbols": "tZvbbls7Dobfxde5kChREvsqG0WRtulGgCAtstsBBkXefUhKIlcyWJpE7tzUn2mvX6ROpOTm9+Xr3edff3+6f/z2/Z/Lh79+Xz4/3T883P/96eH7l9uf998f2fr7EuSfmPHyId1cIvJblFccr9TtJY9Xfl/5tebxOt632l8Jxmu5fIjh5gIhMrASxDAhT6ABMC0wLWlaUhuQYUIdgFMZy4AiTTQBnEADappQBzSYMC0UJ/DjwM4ncR6iAA0Q5wEEaABMS4IJLAjcCSmXAdKrHXBAmZYyLXVapGs7tAEtTZjK0s0duInErmZxtQNOoAExTWgDYFqgDkjyOAiUAXlaMg1AmQMkwJbMvZELP555WuQKE8SSGaR7Mw8KSkcpSEflIkADZJRzFRAL9zxmsZAADcBpkUaRXUWZisitFwm5A/uM7GGJcYJY2J8CYskCYmE3ikTaYVokUiwCYmF/ikwtbAJlQBELCcynZLzUUnFAm5bGlsKuFgrd+UJ5WqhDDXmCWDiKKlOrZAGxsBtVn+LWW+TOLCRQB8C0pDAAeXArC7aSJkxLLQMaR1GLgFhEWZqo8rg4Jh+ROCYfkTQqH5E0qiCN6ndk2uh3Ekfa2HnKYYJYuH9I5nyTL8ucVyjTIiPYoQ2Q+dOhDmjTIq4qSGe2KiCC3HoMQUykhJOi2aRDB7VJEsKgOimZTaZEJ4mHghIrUxSSiAiUcFIxmwQ1qE2SsAbVSc1sElknCY2SkijzJIhRYiNUwknRbBLboDZJYhtUJyWzSWydNLaiJMqyXeu+T00JJxWzaWyd2iSNrVOd1MymsSlpbKQku3KQTgUJjrtWUFboRDRM/oXk1uzWfLCSISbHZljAsRpWb7gWw+ZNtOzoTZA2URTrxBTA0a3RrdGt4FZQJ2UEUkqO8t0ocy7l5EiGMkY8yoKa8wbi/EKOijKjMugXxHXd0idKxJI0eQ4ER32sKJKhjP5Et1a3Vre25FgNJV1NLBNRS4OB1jBqnTAwO0pHRekd1EqgYw++KaJhdWtVq8w+1IHtqOMmCZ6nODi6Vbuvo3afpH5GcUcyPCMZ6rgNbIbavx21TgEtnrRS6Vjcqq6DDIsmlfFY9daqt9bc2rw1ch96bIJV+xdkYDWl8OQX7FF0VAUt43oUHd3ao1DsUXR0q06NgdqE9Hrtrnd0q04NIMVmPujUGFgntgCOxTBGRzTUgKSIYZTWkgxW0zKxo7o+EA117gxUhaTYDLVkHOjW5tbmVnIrqQ8yABT0CzKwmkx53SpWQylKeN0K6oaXtHTWDW+gikn3Uc6ObkW36i43sBpWt+oKGKhNyFhoWp14sEoTWQv4kIc7jM0wJke36tY2sBpKyRWlYATNsAN1M8+giIboVt3BO0pNM9Gtum13bNpEUiyG5FaNTSpT0MzafYga20AyjG7V2DpCcpTYsp5hJMFO1IaLHnGio1t1sAaSYXGrDtZAbUK6T7PqRLf22JpimT70xDoQDaNbe2wdybDH1tFiA48NNDYpv6En4YFoiG5Ftxa3Frdq5pW6mBEnJt3apJ5nbIa6sgbqyU9GM+v+MNCtuj8MLIbgVnBrcmtyq66sjlpKDPQmdJ7JgYKrDv2uHkB1GqkVdYnIaYLPp6pQFZshuLX70LEYZrd2dxR17shRBPQkNLC4VdeFHD8AdeeSwwWjWOV4wfWQWkFRrRIQ9v7VKKhN7GkR8fn55jIvCz79fLq7k7uCw+0B3yn8uH26e/x5+fD46+Hh5vKv24df+qV/ftw+6uvP2yf+lH25e/zKryz47f7hTuj5xp8O548SSdGvT/PKjdEUML6QiOcSnI3zkCh8QnUFeqEA5wpJpqgKpJLt+Qpv90AK/e4BH3LPPMgrD3AIcHHn3Yh73QjhrBvLuUSVGaMKtRZ7PsNbXeDzVXIfEtYzH9qiI6Oc/HpHco4560g6V4A6BYBOh3IZBV8deRQxnU7IxXzg7XBOKEgpnoURF1MSKcwZwcvVx4MviV5qpMWk0F1NNYjTzLnGYmKWkJL5kQ9+vMMLOY12L7g3zr1YzE2uwOYSb9TiuUZdLDGc48qpxhSA2tuHNcc5Jpw1Tpd5XExPLh1mIHIeu36CltOlvtTIUhoPjVzjlgZ6KIGPbWcasJgbctCfGnwvaxItv5RYTFA+0tuwNt+2YnmpgNcvEyjXLpO1F29bJtCuXyZA1y6T5aBGmrsfH9zK2aCmuJpckQ5z3CXS5vQ8ZLRX0zOl1YIPlk1yCmdupFVir8n6sx5y4msJXK54LBYKnFc4qaxEQjxUCOl090r16vSc2pX5eRUI8ZnX48jttNgKqzme52pNuHBjOa5tjknii4mzcc2LFA8Elk4oeSCp0js0im1/PMKbGmjlb4i4pZECRtMocVOjzv5I8VB4vVMjmwbUPQ09kw2NUjY1fHrwaX9Xw/oDDrvPuzTAY+Hb8U2NZmOb4q4fnqb5N9U9jWR5OqUCmxpWPKUctzWsPzJsrpfs6yXvrpdq2Z5Ty2afNttNE1cPexpU5/6RQ6BTjXWmLdUybTvdTsvCDb4TnsulZTo9dJWFF8UKl3pYs6+zwioMDLM7+dLntGAouJpdufosP9aBL90oixzJ94RzpfDtaz3XWPmBvoMh0ZZGaVbT8o/lexo1pFkx1PCipn3PsNiq58uvfDYsNS6viGzBYjytSCv8gTqupj9Qx9V8dR1X8co6bhXIW+u4Wq+u49ZuUDjcP+KpG3HpBrobpzV+W1SkoL8Q9v7kH2b29lCs0Tafw0p57cZiiuZgKSXH0E4lVh1qS43IZxa9vBBui8mJ+uOuKmDE8/S61rCSlhdr3dSwhYaxxj2NYFfTrAF7GmDHBHxxMbDpByyOGms/0P2gsqeRwlxtjNt+WCwpwtX9keJmn6Zi/cGl2PV+VNr0w5Isb4eb45KzjUvObdcP6w/+ee3q/siLkrYtM2SCw73k2RbEV0x/4L45wNUXzmG1pXuilt+BN0X8khWgpYXIIt/naqObW/JVF+ntjiTPtYzt1JFlhop2M8hX6XiWoWJoqxlSyWuoFun0Jj/Q8oax+ETjkupUJa6uoopfWNR4+oPA//Kk+XV+OVy5vvJkdV9KtjNHOvjxemxWEs3vfelwJfYeCfIKmbDuSVgVFOlwm/8OCQjFCim+T9qSyMF+Acyw50VOLnH4mec9Ehi8IoSyJ4HBJDDuSeTsErDpRTGJ2q72YlfCJjiUuDXBoWQ/ieLeoBa78uUbvU0vrISC0sLVgexJcDK101treVPCc2zYGtRE9lMoF1Ln3an/6e/K7Lh0w6o4xroXydvS6/IYalmAcW+1B/KTbNhb7fo/nocEhM1AiktcH8imRPQtPOa6J2EX+BALbUpYFog1XB3IrsTbStmVBPigQmybEsEl6NpAdiXeWpFn+n/uOXyfmv1q1Wu++OZAqv4VwrgxP/rwKg5cXYuCJWb5W44tL2yNMNKWAtkl864PVsfXeMiH71AAK9YY614U5ArtWoW45QMAmEIK147F4T/PvceHhKaAe1HY+f+/5sNHfnf75f7pxd/ZPovW0/3t54e78fbbr8cvh09//vvH/GT+ne6Pp+9f7r7+eroTJf9jXf7nL+RdCiN9vLlEeQfpBnOQd/Kh3H9xKSpv5dPMweZUPz6La/8B"
|
|
2157
2157
|
},
|
|
2158
2158
|
{
|
|
2159
2159
|
"name": "update",
|
|
@@ -2216,8 +2216,8 @@
|
|
|
2216
2216
|
}
|
|
2217
2217
|
}
|
|
2218
2218
|
},
|
|
2219
|
-
"bytecode": "
|
|
2220
|
-
"debug_symbols": "
|
|
2219
|
+
"bytecode": "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",
|
|
2220
|
+
"debug_symbols": "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"
|
|
2221
2221
|
}
|
|
2222
2222
|
],
|
|
2223
2223
|
"outputs": {
|
|
@@ -2807,7 +2807,7 @@
|
|
|
2807
2807
|
},
|
|
2808
2808
|
"16": {
|
|
2809
2809
|
"path": "std/embedded_curve_ops.nr",
|
|
2810
|
-
"source": "use crate::cmp::Eq;\nuse crate::hash::Hash;\nuse crate::ops::arith::{Add, Neg, Sub};\n\n/// A point on the embedded elliptic curve\n/// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.\n/// x and y denotes the Weierstrass coordinates of the point, if is_infinite is false.\npub struct EmbeddedCurvePoint {\n pub x: Field,\n pub y: Field,\n pub is_infinite: bool,\n}\n\nimpl EmbeddedCurvePoint {\n /// Elliptic curve point doubling operation\n /// returns the doubled point of a point P, i.e P+P\n pub fn double(self) -> EmbeddedCurvePoint {\n embedded_curve_add(self, self)\n }\n\n /// Returns the null element of the curve; 'the point at infinity'\n pub fn point_at_infinity() -> EmbeddedCurvePoint {\n EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }\n }\n\n /// Returns the curve's generator point.\n pub fn generator() -> EmbeddedCurvePoint {\n // Generator point for the grumpkin curve (y^2 = x^3 - 17)\n EmbeddedCurvePoint {\n x: 1,\n y: 17631683881184975370165255887551781615748388533673675138860, // sqrt(-16)\n is_infinite: false,\n }\n }\n}\n\nimpl Add for EmbeddedCurvePoint {\n /// Adds two points P+Q, using the curve addition formula, and also handles point at infinity\n fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n embedded_curve_add(self, other)\n }\n}\n\nimpl Sub for EmbeddedCurvePoint {\n /// Points subtraction operation, using addition and negation\n fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n self + other.neg()\n }\n}\n\nimpl Neg for EmbeddedCurvePoint {\n /// Negates a point P, i.e returns -P, by negating the y coordinate.\n /// If the point is at infinity, then the result is also at infinity.\n fn neg(self) -> EmbeddedCurvePoint {\n EmbeddedCurvePoint { x: self.x, y: -self.y, is_infinite: self.is_infinite }\n }\n}\n\nimpl Eq for EmbeddedCurvePoint {\n /// Checks whether two points are equal\n fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {\n (self.is_infinite & b.is_infinite)\n | ((self.is_infinite == b.is_infinite) & (self.x == b.x) & (self.y == b.y))\n }\n}\n\nimpl Hash for EmbeddedCurvePoint {\n fn hash<H>(self, state: &mut H)\n where\n H: crate::hash::Hasher,\n {\n if self.is_infinite {\n self.is_infinite.hash(state);\n } else {\n self.x.hash(state);\n self.y.hash(state);\n }\n }\n}\n\n/// Scalar for the embedded curve represented as low and high limbs\n/// By definition, the scalar field of the embedded curve is base field of the proving system curve.\n/// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.\npub struct EmbeddedCurveScalar {\n pub lo: Field,\n pub hi: Field,\n}\n\nimpl EmbeddedCurveScalar {\n pub fn new(lo: Field, hi: Field) -> Self {\n EmbeddedCurveScalar { lo, hi }\n }\n\n #[field(bn254)]\n pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {\n let (a, b) = crate::field::bn254::decompose(scalar);\n EmbeddedCurveScalar { lo: a, hi: b }\n }\n\n //Bytes to scalar: take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value\n #[field(bn254)]\n pub(crate) fn from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n let mut v = 1;\n let mut lo = 0 as Field;\n let mut hi = 0 as Field;\n for i in 0..16 {\n lo = lo + (bytes[offset + 31 - i] as Field) * v;\n hi = hi + (bytes[offset + 15 - i] as Field) * v;\n v = v * 256;\n }\n let sig_s = crate::embedded_curve_ops::EmbeddedCurveScalar { lo, hi };\n sig_s\n }\n}\n\nimpl Eq for EmbeddedCurveScalar {\n fn eq(self, other: Self) -> bool {\n (other.hi == self.hi) & (other.lo == self.lo)\n }\n}\n\nimpl Hash for EmbeddedCurveScalar {\n fn hash<H>(self, state: &mut H)\n where\n H: crate::hash::Hasher,\n {\n self.hi.hash(state);\n self.lo.hash(state);\n }\n}\n\n// Computes a multi scalar multiplication over the embedded curve.\n// For bn254, We have Grumpkin and Baby JubJub.\n// For bls12-381, we have JubJub and Bandersnatch.\n//\n// The embedded curve being used is decided by the\n// underlying proof system.\n// docs:start:multi_scalar_mul\npub fn multi_scalar_mul<let N: u32>(\n points: [EmbeddedCurvePoint; N],\n scalars: [EmbeddedCurveScalar; N],\n) -> EmbeddedCurvePoint\n// docs:end:multi_scalar_mul\n{\n multi_scalar_mul_array_return(points, scalars, true)[0]\n}\n\n#[foreign(multi_scalar_mul)]\npub(crate) fn multi_scalar_mul_array_return<let N: u32>(\n points: [EmbeddedCurvePoint; N],\n scalars: [EmbeddedCurveScalar; N],\n predicate: bool,\n) -> [EmbeddedCurvePoint; 1] {}\n\n// docs:start:fixed_base_scalar_mul\npub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint\n// docs:end:fixed_base_scalar_mul\n{\n multi_scalar_mul([EmbeddedCurvePoint::generator()], [scalar])\n}\n\n///
|
|
2810
|
+
"source": "use crate::cmp::Eq;\nuse crate::hash::Hash;\nuse crate::ops::arith::{Add, Neg, Sub};\n\n/// A point on the embedded elliptic curve\n/// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.\n/// x and y denotes the Weierstrass coordinates of the point, if is_infinite is false.\npub struct EmbeddedCurvePoint {\n pub x: Field,\n pub y: Field,\n pub is_infinite: bool,\n}\n\nimpl EmbeddedCurvePoint {\n /// Elliptic curve point doubling operation\n /// returns the doubled point of a point P, i.e P+P\n pub fn double(self) -> EmbeddedCurvePoint {\n embedded_curve_add(self, self)\n }\n\n /// Returns the null element of the curve; 'the point at infinity'\n pub fn point_at_infinity() -> EmbeddedCurvePoint {\n EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }\n }\n\n /// Returns the curve's generator point.\n pub fn generator() -> EmbeddedCurvePoint {\n // Generator point for the grumpkin curve (y^2 = x^3 - 17)\n EmbeddedCurvePoint {\n x: 1,\n y: 17631683881184975370165255887551781615748388533673675138860, // sqrt(-16)\n is_infinite: false,\n }\n }\n}\n\nimpl Add for EmbeddedCurvePoint {\n /// Adds two points P+Q, using the curve addition formula, and also handles point at infinity\n fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n embedded_curve_add(self, other)\n }\n}\n\nimpl Sub for EmbeddedCurvePoint {\n /// Points subtraction operation, using addition and negation\n fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n self + other.neg()\n }\n}\n\nimpl Neg for EmbeddedCurvePoint {\n /// Negates a point P, i.e returns -P, by negating the y coordinate.\n /// If the point is at infinity, then the result is also at infinity.\n fn neg(self) -> EmbeddedCurvePoint {\n EmbeddedCurvePoint { x: self.x, y: -self.y, is_infinite: self.is_infinite }\n }\n}\n\nimpl Eq for EmbeddedCurvePoint {\n /// Checks whether two points are equal\n fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {\n (self.is_infinite & b.is_infinite)\n | ((self.is_infinite == b.is_infinite) & (self.x == b.x) & (self.y == b.y))\n }\n}\n\nimpl Hash for EmbeddedCurvePoint {\n fn hash<H>(self, state: &mut H)\n where\n H: crate::hash::Hasher,\n {\n if self.is_infinite {\n self.is_infinite.hash(state);\n } else {\n self.x.hash(state);\n self.y.hash(state);\n }\n }\n}\n\n/// Scalar for the embedded curve represented as low and high limbs\n/// By definition, the scalar field of the embedded curve is base field of the proving system curve.\n/// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.\npub struct EmbeddedCurveScalar {\n pub lo: Field,\n pub hi: Field,\n}\n\nimpl EmbeddedCurveScalar {\n pub fn new(lo: Field, hi: Field) -> Self {\n EmbeddedCurveScalar { lo, hi }\n }\n\n #[field(bn254)]\n pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {\n let (a, b) = crate::field::bn254::decompose(scalar);\n EmbeddedCurveScalar { lo: a, hi: b }\n }\n\n //Bytes to scalar: take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value\n #[field(bn254)]\n pub(crate) fn from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n let mut v = 1;\n let mut lo = 0 as Field;\n let mut hi = 0 as Field;\n for i in 0..16 {\n lo = lo + (bytes[offset + 31 - i] as Field) * v;\n hi = hi + (bytes[offset + 15 - i] as Field) * v;\n v = v * 256;\n }\n let sig_s = crate::embedded_curve_ops::EmbeddedCurveScalar { lo, hi };\n sig_s\n }\n}\n\nimpl Eq for EmbeddedCurveScalar {\n fn eq(self, other: Self) -> bool {\n (other.hi == self.hi) & (other.lo == self.lo)\n }\n}\n\nimpl Hash for EmbeddedCurveScalar {\n fn hash<H>(self, state: &mut H)\n where\n H: crate::hash::Hasher,\n {\n self.hi.hash(state);\n self.lo.hash(state);\n }\n}\n\n// Computes a multi scalar multiplication over the embedded curve.\n// For bn254, We have Grumpkin and Baby JubJub.\n// For bls12-381, we have JubJub and Bandersnatch.\n//\n// The embedded curve being used is decided by the\n// underlying proof system.\n//\n// IMPORTANT: Prefer `multi_scalar_mul()` over repeated `embedded_curve_add()`\n// for adding multiple points. This is significantly more efficient.\n// For adding exactly 2 points, use `embedded_curve_add()` directly.\n// docs:start:multi_scalar_mul\npub fn multi_scalar_mul<let N: u32>(\n points: [EmbeddedCurvePoint; N],\n scalars: [EmbeddedCurveScalar; N],\n) -> EmbeddedCurvePoint\n// docs:end:multi_scalar_mul\n{\n multi_scalar_mul_array_return(points, scalars, true)[0]\n}\n\n#[foreign(multi_scalar_mul)]\npub(crate) fn multi_scalar_mul_array_return<let N: u32>(\n points: [EmbeddedCurvePoint; N],\n scalars: [EmbeddedCurveScalar; N],\n predicate: bool,\n) -> [EmbeddedCurvePoint; 1] {}\n\n// docs:start:fixed_base_scalar_mul\npub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint\n// docs:end:fixed_base_scalar_mul\n{\n multi_scalar_mul([EmbeddedCurvePoint::generator()], [scalar])\n}\n\n/// Elliptic curve addition\n/// IMPORTANT: this function is expected to perform a full addition in order to handle all corner cases:\n/// - points on the curve\n/// - point doubling\n/// - point at infinity\n/// As a result, you may not get optimal performance, depending on the assumptions of your inputs.\n// docs:start:embedded_curve_add\npub fn embedded_curve_add(\n point1: EmbeddedCurvePoint,\n point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n // docs:end:embedded_curve_add\n if crate::runtime::is_unconstrained() {\n // avoid calling the black box function for trivial cases\n if point1.is_infinite {\n point2\n } else if point2.is_infinite {\n point1\n } else {\n embedded_curve_add_inner(point1, point2)\n }\n } else {\n embedded_curve_add_inner(point1, point2)\n }\n}\n\n#[foreign(embedded_curve_add)]\nfn embedded_curve_add_array_return(\n _point1: EmbeddedCurvePoint,\n _point2: EmbeddedCurvePoint,\n _predicate: bool,\n) -> [EmbeddedCurvePoint; 1] {}\n\n/// EC addition wrapper for the foreign function\nfn embedded_curve_add_inner(\n point1: EmbeddedCurvePoint,\n point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n embedded_curve_add_array_return(point1, point2, true)[0]\n}\n"
|
|
2811
2811
|
},
|
|
2812
2812
|
"17": {
|
|
2813
2813
|
"path": "std/field/bn254.nr",
|
|
@@ -2819,11 +2819,11 @@
|
|
|
2819
2819
|
},
|
|
2820
2820
|
"19": {
|
|
2821
2821
|
"path": "std/hash/mod.nr",
|
|
2822
|
-
"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"
|
|
2822
|
+
"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"
|
|
2823
2823
|
},
|
|
2824
2824
|
"230": {
|
|
2825
2825
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/version.nr",
|
|
2826
|
-
"source": "/// The ORACLE_VERSION constant is used to check that the oracle interface is in sync between PXE and Aztec.nr. We need\n/// to version the oracle interface to ensure that developers get a reasonable error message if they use incompatible\n/// versions of Aztec.nr and PXE. The TypeScript counterpart is in `oracle_version.ts`.\n///\n/// @dev Whenever a contract function or Noir test is run, the `utilityAssertCompatibleOracleVersion` oracle is called\n/// and if the oracle version is incompatible an error is thrown.\npub global ORACLE_VERSION: Field =
|
|
2826
|
+
"source": "/// The ORACLE_VERSION constant is used to check that the oracle interface is in sync between PXE and Aztec.nr. We need\n/// to version the oracle interface to ensure that developers get a reasonable error message if they use incompatible\n/// versions of Aztec.nr and PXE. The TypeScript counterpart is in `oracle_version.ts`.\n///\n/// @dev Whenever a contract function or Noir test is run, the `utilityAssertCompatibleOracleVersion` oracle is called\n/// and if the oracle version is incompatible an error is thrown.\npub global ORACLE_VERSION: Field = 12;\n\n/// Asserts that the version of the oracle is compatible with the version expected by the contract.\npub fn assert_compatible_oracle_version() {\n // Safety: This oracle call returns nothing: we only call it to check Aztec.nr and Oracle interface versions are\n // compatible. It is therefore always safe to call.\n unsafe {\n assert_compatible_oracle_version_wrapper();\n }\n}\n\nunconstrained fn assert_compatible_oracle_version_wrapper() {\n assert_compatible_oracle_version_oracle(ORACLE_VERSION);\n}\n\n#[oracle(utilityAssertCompatibleOracleVersion)]\nunconstrained fn assert_compatible_oracle_version_oracle(version: Field) {}\n\nmod test {\n use super::{assert_compatible_oracle_version_oracle, ORACLE_VERSION};\n\n #[test]\n unconstrained fn compatible_oracle_version() {\n assert_compatible_oracle_version_oracle(ORACLE_VERSION);\n }\n\n #[test(should_fail_with = \"Incompatible oracle version. TXE is using version\")]\n unconstrained fn incompatible_oracle_version() {\n let arbitrary_incorrect_version = 318183437;\n assert_compatible_oracle_version_oracle(arbitrary_incorrect_version);\n }\n}\n"
|
|
2827
2827
|
},
|
|
2828
2828
|
"298": {
|
|
2829
2829
|
"path": "/home/aztec-dev/nargo/github.com/noir-lang/poseidon/v0.2.3/src/poseidon2.nr",
|
|
@@ -2835,7 +2835,7 @@
|
|
|
2835
2835
|
},
|
|
2836
2836
|
"356": {
|
|
2837
2837
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
|
|
2838
|
-
"source": "use crate::{\n address::{\n partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n },\n constants::{AZTEC_ADDRESS_LENGTH, DOM_SEP__CONTRACT_ADDRESS_V1, MAX_FIELD_VALUE},\n contract_class_id::ContractClassId,\n hash::poseidon2_hash_with_separator,\n public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n utils::field::sqrt,\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n ops::Add,\n};\nuse std::meta::derive;\n\n// Aztec address\n#[derive(Deserialize, Eq, Packable, Serialize)]\npub struct AztecAddress {\n pub inner: Field,\n}\n\nimpl Empty for AztecAddress {\n fn empty() -> Self {\n Self { inner: 0 }\n }\n}\n\nimpl ToField for AztecAddress {\n fn to_field(self) -> Field {\n self.inner\n }\n}\n\nimpl FromField for AztecAddress {\n fn from_field(value: Field) -> AztecAddress {\n AztecAddress { inner: value }\n }\n}\n\nimpl AztecAddress {\n pub fn zero() -> Self {\n Self { inner: 0 }\n }\n\n /// Returns an address's `AddressPoint`, which can be used to create shared secrets with the owner\n /// of the address. If the address is invalid (i.e. it is not a properly derived Aztec address), then this\n /// returns `Option::none()`, and no shared secrets can be created.\n pub fn to_address_point(self) -> Option<AddressPoint> {\n // We compute the address point by taking our address as x, and then solving for y in the\n // equation which defines the grumpkin curve:\n // y^2 = x^3 - 17; x = address\n let x = self.inner;\n let y_squared = x * x * x - 17;\n\n // An invalid AztecAddress is one for which no y coordinate satisfies the curve equation, which we'll\n // identify by proving that the square root of y_squared does not exist.\n sqrt(y_squared).map(|y| {\n // If we get a negative y coordinate (y > (r - 1) / 2), we swap it to the\n // positive one (where y <= (r - 1) / 2) by negating it.\n let final_y = if Self::is_positive(y) { y } else { -y };\n\n AddressPoint { inner: Point { x: self.inner, y: final_y, is_infinite: false } }\n })\n }\n\n /// Determines whether a y-coordinate is in the lower (positive) or upper (negative) \"half\" of the field.\n /// I.e.\n /// y <= (r - 1)/2 => positive.\n /// y > (r - 1)/2 => negative.\n /// An AddressPoint always uses the \"positive\" y.\n fn is_positive(y: Field) -> bool {\n // Note: The field modulus r is MAX_FIELD_VALUE + 1.\n let MID = MAX_FIELD_VALUE / 2; // (r - 1) / 2\n let MID_PLUS_1 = MID + 1; // (r - 1)/2 + 1\n // Note: y <= m implies y < m + 1.\n y.lt(MID_PLUS_1)\n }\n\n pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n //\n // address = address_point.x\n // |\n // address_point = pre_address * G + Ivpk_m (always choose \"positive\" y-coord)\n // | ^\n // | |.....................\n // pre_address .\n // / \\ .\n // / \\ .\n // partial_address public_keys_hash .\n // / \\ / / \\ \\ .\n // / \\ Npk_m Ivpk_m Ovpk_m Tpk_m .\n // contract_class_id \\ |...................\n // / | \\ \\\n // artifact_hash | public_bytecode_commitment salted_initialization_hash\n // | / / \\\n // private_function_tree_root deployer_address salt initialization_hash\n // / \\ / \\\n // ... ... constructor_fn_selector constructor_args_hash\n // / \\\n // / \\ / \\\n // leaf leaf leaf leaf\n // ^\n // |\n // |---h(function_selector, vk_hash)\n // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n // Each of these represents a private function of the contract.\n\n let public_keys_hash = public_keys.hash();\n\n let pre_address = poseidon2_hash_with_separator(\n [public_keys_hash.to_field(), partial_address.to_field()],\n DOM_SEP__CONTRACT_ADDRESS_V1,\n );\n\n // Note: `.add()` will fail within the blackbox fn if either of the points are not on the curve. (See tests below).\n let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n public_keys.ivpk_m.to_point(),\n );\n\n // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n // our secret can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n AztecAddress::from_field(address_point.x)\n }\n\n pub fn compute_from_class_id(\n contract_class_id: ContractClassId,\n salted_initialization_hash: SaltedInitializationHash,\n public_keys: PublicKeys,\n ) -> Self {\n let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n contract_class_id,\n salted_initialization_hash,\n );\n\n AztecAddress::compute(public_keys, partial_address)\n }\n\n pub fn is_zero(self) -> bool {\n self.inner == 0\n }\n\n pub fn assert_is_zero(self) {\n assert(self.to_field() == 0);\n }\n}\n\n#[test]\nfn check_max_field_value() {\n // Check that it is indeed r-1.\n assert_eq(MAX_FIELD_VALUE + 1, 0);\n}\n\n#[test]\nfn check_is_positive() {\n assert(AztecAddress::is_positive(0));\n assert(AztecAddress::is_positive(1));\n assert(!AztecAddress::is_positive(-1));\n assert(AztecAddress::is_positive(MAX_FIELD_VALUE / 2));\n assert(!AztecAddress::is_positive((MAX_FIELD_VALUE / 2) + 1));\n}\n\n// Gives us confidence that we don't need to manually check that the input public keys need to be on the curve for `add`,\n// because the blackbox function does this check for us.\n#[test(should_fail_with = \"is not on curve\")]\nfn check_embedded_curve_point_add() {\n // Choose a point not on the curve:\n let p1 = Point { x: 1, y: 1, is_infinite: false };\n let p2 = Point::generator();\n let _ = p1 + p2;\n}\n\n// Gives us confidence that we don't need to manually check that the input public keys need to be on the curve for `add`,\n// because the blackbox function does this check for us.\n#[test(should_fail_with = \"is not on curve\")]\nfn check_embedded_curve_point_add_2() {\n // Choose a point not on the curve in the 2nd position.\n let p1 = Point::generator();\n let p2 = Point { x: 1, y: 1, is_infinite: false };\n let _ = p1 + p2;\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n let public_keys = PublicKeys {\n npk_m: NpkM {\n inner: Point {\n x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n is_infinite: false,\n },\n },\n ivpk_m: IvpkM {\n inner: Point {\n x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n is_infinite: false,\n },\n },\n ovpk_m: OvpkM {\n inner: Point {\n x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n is_infinite: false,\n },\n },\n tpk_m: TpkM {\n inner: Point {\n x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n is_infinite: false,\n },\n },\n };\n\n let partial_address = PartialAddress::from_field(\n 0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n );\n\n let address = AztecAddress::compute(public_keys, partial_address);\n\n // The following value was generated by `derivation.test.ts`.\n // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n let expected_computed_address_from_partial_and_pubkeys =\n 0x105626366aab4a53d471701395a4e0e04af65ad1fad8483c74de338f397f226c;\n assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n let pre_address = poseidon2_hash_with_separator([1, 2], DOM_SEP__CONTRACT_ADDRESS_V1);\n let expected_computed_preaddress_from_partial_and_pubkey =\n 0x0b661dee14f3871040a5938dbc5c1a7977aede0b64cff6b7faa168d11a288d75;\n assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n let address = AztecAddress { inner: 37 };\n assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n let address = AztecAddress { inner: 37 };\n // We use the AZTEC_ADDRESS_LENGTH constant to ensure that there is a match between the derived trait\n // implementation and the constant.\n let serialized: [Field; AZTEC_ADDRESS_LENGTH] = address.serialize();\n let deserialized = AztecAddress::deserialize(serialized);\n assert_eq(address, deserialized);\n}\n\n#[test]\nfn to_address_point_valid() {\n // x = 8 where x^3 - 17 = 512 - 17 = 495, which is a residue in this field\n let address = AztecAddress { inner: 8 };\n let maybe_point = address.to_address_point();\n assert(maybe_point.is_some());\n\n let point = maybe_point.unwrap().inner;\n // check that x is preserved\n assert_eq(point.x, Field::from(8));\n\n // check that the curve equation holds: y^2 == x^3 - 17\n assert_eq(point.y * point.y, point.x * point.x * point.x - 17);\n}\n\n#[test]\nunconstrained fn to_address_point_invalid() {\n // x = 3 where x^3 - 17 = 27 - 17 = 10, which is a non-residue in this field\n let address = AztecAddress { inner: 3 }; //\n let maybe_point = address.to_address_point();\n assert(maybe_point.is_none());\n}\n"
|
|
2838
|
+
"source": "use crate::{\n address::{\n partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n },\n constants::{AZTEC_ADDRESS_LENGTH, DOM_SEP__CONTRACT_ADDRESS_V1, MAX_FIELD_VALUE},\n contract_class_id::ContractClassId,\n hash::poseidon2_hash_with_separator,\n public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n utils::field::sqrt,\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n ops::Add,\n};\nuse std::meta::derive;\n\n// Aztec address\n#[derive(Deserialize, Eq, Packable, Serialize)]\npub struct AztecAddress {\n pub inner: Field,\n}\n\nimpl Empty for AztecAddress {\n fn empty() -> Self {\n Self { inner: 0 }\n }\n}\n\nimpl ToField for AztecAddress {\n fn to_field(self) -> Field {\n self.inner\n }\n}\n\nimpl FromField for AztecAddress {\n fn from_field(value: Field) -> AztecAddress {\n AztecAddress { inner: value }\n }\n}\n\nimpl AztecAddress {\n pub fn zero() -> Self {\n Self { inner: 0 }\n }\n\n /// Returns an address's `AddressPoint`, which can be used to create shared secrets with the owner\n /// of the address. If the address is invalid (i.e. it is not a properly derived Aztec address), then this\n /// returns `Option::none()`, and no shared secrets can be created.\n pub fn to_address_point(self) -> Option<AddressPoint> {\n // We compute the address point by taking our address as x, and then solving for y in the\n // equation which defines the grumpkin curve:\n // y^2 = x^3 - 17; x = address\n let x = self.inner;\n let y_squared = x * x * x - 17;\n\n // An invalid AztecAddress is one for which no y coordinate satisfies the curve equation, which we'll\n // identify by proving that the square root of y_squared does not exist.\n sqrt(y_squared).map(|y| {\n // If we get a negative y coordinate (y > (r - 1) / 2), we swap it to the\n // positive one (where y <= (r - 1) / 2) by negating it.\n let final_y = if Self::is_positive(y) { y } else { -y };\n\n AddressPoint { inner: Point { x: self.inner, y: final_y, is_infinite: false } }\n })\n }\n\n /// Determines whether a y-coordinate is in the lower (positive) or upper (negative) \"half\" of the field.\n /// I.e.\n /// y <= (r - 1)/2 => positive.\n /// y > (r - 1)/2 => negative.\n /// An AddressPoint always uses the \"positive\" y.\n fn is_positive(y: Field) -> bool {\n // Note: The field modulus r is MAX_FIELD_VALUE + 1.\n let MID = MAX_FIELD_VALUE / 2; // (r - 1) / 2\n let MID_PLUS_1 = MID + 1; // (r - 1)/2 + 1\n // Note: y <= m implies y < m + 1.\n y.lt(MID_PLUS_1)\n }\n\n pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n //\n // address = address_point.x\n // |\n // address_point = pre_address * G + Ivpk_m (always choose \"positive\" y-coord)\n // | ^\n // | |.....................\n // pre_address .\n // / \\ .\n // / \\ .\n // partial_address public_keys_hash .\n // / \\ / / \\ \\ .\n // / \\ Npk_m Ivpk_m Ovpk_m Tpk_m .\n // contract_class_id \\ |...................\n // / | \\ \\\n // artifact_hash | public_bytecode_commitment salted_initialization_hash\n // | / / \\\n // private_function_tree_root deployer_address salt initialization_hash\n // / \\ / \\\n // ... ... constructor_fn_selector constructor_args_hash\n // / \\\n // / \\ / \\\n // leaf leaf leaf leaf\n // ^\n // |\n // |---h(function_selector, vk_hash)\n // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n // Each of these represents a private function of the contract.\n\n let public_keys_hash = public_keys.hash();\n\n let pre_address = poseidon2_hash_with_separator(\n [public_keys_hash.to_field(), partial_address.to_field()],\n DOM_SEP__CONTRACT_ADDRESS_V1,\n );\n\n // Note: `.add()` will fail within the blackbox fn if either of the points are not on the curve. (See tests below).\n let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n public_keys.ivpk_m.to_point(),\n );\n\n // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n // our secret can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n AztecAddress::from_field(address_point.x)\n }\n\n pub fn compute_from_class_id(\n contract_class_id: ContractClassId,\n salted_initialization_hash: SaltedInitializationHash,\n public_keys: PublicKeys,\n ) -> Self {\n let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n contract_class_id,\n salted_initialization_hash,\n );\n\n AztecAddress::compute(public_keys, partial_address)\n }\n\n pub fn is_zero(self) -> bool {\n self.inner == 0\n }\n\n pub fn assert_is_zero(self) {\n assert(self.to_field() == 0);\n }\n}\n\n#[test]\nfn check_max_field_value() {\n // Check that it is indeed r-1.\n assert_eq(MAX_FIELD_VALUE + 1, 0);\n}\n\n#[test]\nfn check_is_positive() {\n assert(AztecAddress::is_positive(0));\n assert(AztecAddress::is_positive(1));\n assert(!AztecAddress::is_positive(-1));\n assert(AztecAddress::is_positive(MAX_FIELD_VALUE / 2));\n assert(!AztecAddress::is_positive((MAX_FIELD_VALUE / 2) + 1));\n}\n\n// Gives us confidence that we don't need to manually check that the input public keys need to be on the curve for `add`,\n// because the blackbox function does this check for us.\n#[test(should_fail_with = \"is not on curve\")]\nfn check_embedded_curve_point_add() {\n // Choose a point not on the curve:\n let p1 = Point { x: 1, y: 1, is_infinite: false };\n let p2 = Point::generator();\n let _ = p1 + p2;\n}\n\n// Gives us confidence that we don't need to manually check that the input public keys need to be on the curve for `add`,\n// because the blackbox function does this check for us.\n#[test(should_fail_with = \"is not on curve\")]\nfn check_embedded_curve_point_add_2() {\n // Choose a point not on the curve in the 2nd position.\n let p1 = Point::generator();\n let p2 = Point { x: 1, y: 1, is_infinite: false };\n let _ = p1 + p2;\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n let public_keys = PublicKeys {\n npk_m: NpkM {\n inner: Point {\n x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n is_infinite: false,\n },\n },\n ivpk_m: IvpkM {\n inner: Point {\n x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n is_infinite: false,\n },\n },\n ovpk_m: OvpkM {\n inner: Point {\n x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n is_infinite: false,\n },\n },\n tpk_m: TpkM {\n inner: Point {\n x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n is_infinite: false,\n },\n },\n };\n\n let partial_address = PartialAddress::from_field(\n 0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n );\n\n let address = AztecAddress::compute(public_keys, partial_address);\n\n // The following value was generated by `derivation.test.ts`.\n // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n let expected_computed_address_from_partial_and_pubkeys =\n 0x2f66081d4bb077fbe8e8abe96a3516a713a3d7e34360b4e985da0da95092b37d;\n assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n let pre_address = poseidon2_hash_with_separator([1, 2], DOM_SEP__CONTRACT_ADDRESS_V1);\n let expected_computed_preaddress_from_partial_and_pubkey =\n 0x286c7755f2924b1e53b00bcaf1adaffe7287bd74bba7a02f4ab867e3892d28da;\n assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n let address = AztecAddress { inner: 37 };\n assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n let address = AztecAddress { inner: 37 };\n // We use the AZTEC_ADDRESS_LENGTH constant to ensure that there is a match between the derived trait\n // implementation and the constant.\n let serialized: [Field; AZTEC_ADDRESS_LENGTH] = address.serialize();\n let deserialized = AztecAddress::deserialize(serialized);\n assert_eq(address, deserialized);\n}\n\n#[test]\nfn to_address_point_valid() {\n // x = 8 where x^3 - 17 = 512 - 17 = 495, which is a residue in this field\n let address = AztecAddress { inner: 8 };\n let maybe_point = address.to_address_point();\n assert(maybe_point.is_some());\n\n let point = maybe_point.unwrap().inner;\n // check that x is preserved\n assert_eq(point.x, Field::from(8));\n\n // check that the curve equation holds: y^2 == x^3 - 17\n assert_eq(point.y * point.y, point.x * point.x * point.x - 17);\n}\n\n#[test]\nunconstrained fn to_address_point_invalid() {\n // x = 3 where x^3 - 17 = 27 - 17 = 10, which is a non-residue in this field\n let address = AztecAddress { inner: 3 }; //\n let maybe_point = address.to_address_point();\n assert(maybe_point.is_none());\n}\n"
|
|
2839
2839
|
},
|
|
2840
2840
|
"359": {
|
|
2841
2841
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/partial_address.nr",
|
|
@@ -2845,10 +2845,6 @@
|
|
|
2845
2845
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/salted_initialization_hash.nr",
|
|
2846
2846
|
"source": "use crate::{\n address::aztec_address::AztecAddress, constants::DOM_SEP__PARTIAL_ADDRESS,\n hash::poseidon2_hash_with_separator, traits::ToField,\n};\n\n// Salted initialization hash. Used in the computation of a partial address.\n#[derive(Eq)]\npub struct SaltedInitializationHash {\n pub inner: Field,\n}\n\nimpl ToField for SaltedInitializationHash {\n fn to_field(self) -> Field {\n self.inner\n }\n}\n\nimpl SaltedInitializationHash {\n pub fn from_field(field: Field) -> Self {\n Self { inner: field }\n }\n\n pub fn compute(salt: Field, initialization_hash: Field, deployer: AztecAddress) -> Self {\n SaltedInitializationHash::from_field(poseidon2_hash_with_separator(\n [salt, initialization_hash, deployer.to_field()],\n DOM_SEP__PARTIAL_ADDRESS,\n ))\n }\n\n pub fn assert_is_zero(self) {\n assert(self.to_field() == 0);\n }\n}\n"
|
|
2847
2847
|
},
|
|
2848
|
-
"377": {
|
|
2849
|
-
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
|
|
2850
|
-
"source": "// TODO: Expose other wrapped functions than debug (info, warn)\n// ['silent', 'fatal', 'error', 'warn', 'info', 'verbose', 'debug', 'trace']\n\npub global SILENT_LOG_LEVEL: u8 = 0;\npub global FATAL_LOG_LEVEL: u8 = 1;\npub global ERROR_LOG_LEVEL: u8 = 2;\npub global WARN_LOG_LEVEL: u8 = 3;\npub global INFO_LOG_LEVEL: u8 = 4;\npub global VERBOSE_LOG_LEVEL: u8 = 5;\npub global DEBUG_LOG_LEVEL: u8 = 6;\npub global TRACE_LOG_LEVEL: u8 = 7;\n\n/// Utility function to console.log data in the acir simulator.\n/// Example:\n/// debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n debug_log_format(msg, []);\n}\n\n/// Same as debug_log, but allows to customize the log level.\n/// Consider changing just to 'log'\npub fn debug_log_with_level<let N: u32>(log_level: u8, msg: str<N>) {\n debug_log_format_with_level(log_level, msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n/// debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n/// debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { debug_log_array_oracle_wrapper(DEBUG_LOG_LEVEL, msg, args) };\n}\n\n/// Same as debug_log_format, but allows to customize the log level.\n/// Consider changing just to 'log_format'\npub fn debug_log_format_with_level<let M: u32, let N: u32>(\n log_level: u8,\n msg: str<M>,\n args: [Field; N],\n) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { debug_log_array_oracle_wrapper(log_level, msg, args) };\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` slice.\n/// Examples:\n/// debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n/// debug_log_format(\"whole slice: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format_slice<let M: u32>(log_level: u8, msg: str<M>, args: [Field]) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { debug_log_slice_oracle_wrapper(log_level, msg, args) };\n}\n\n// We provide two versions of the debug log oracle: one that takes args as a slice and another one that takes args as an array.\n// We do this since conversion from array to slice generates overhead in public functions, since opcodes need to be emitted for the conversion.\n// By exposing the two flavors, we avoid conversions since the AVM is able to handle both arrays an slices in this oracle.\n\nunconstrained fn debug_log_slice_oracle_wrapper<let M: u32>(\n log_level: u8,\n msg: str<M>,\n args: [Field],\n) {\n debug_log_slice_oracle(log_level, msg, args);\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(utilityDebugLog)]\nunconstrained fn debug_log_slice_oracle<let M: u32>(log_level: u8, msg: str<M>, args: [Field]) {}\n\nunconstrained fn debug_log_array_oracle_wrapper<let M: u32, let N: u32>(\n log_level: u8,\n msg: str<M>,\n args: [Field; N],\n) {\n debug_log_array_oracle(log_level, msg, N, args);\n}\n\n#[oracle(utilityDebugLog)]\nunconstrained fn debug_log_array_oracle<let M: u32, let N: u32>(\n log_level: u8,\n msg: str<M>,\n length: u32,\n args: [Field; N],\n) {}\n"
|
|
2851
|
-
},
|
|
2852
2848
|
"379": {
|
|
2853
2849
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/delayed_public_mutable/delayed_public_mutable_values.nr",
|
|
2854
2850
|
"source": "use crate::{\n delayed_public_mutable::{\n scheduled_delay_change::ScheduledDelayChange, scheduled_value_change::ScheduledValueChange,\n },\n hash::poseidon2_hash,\n traits::{Hash, Packable},\n utils::arrays,\n};\nuse std::meta::derive;\n\nmod test;\n\n/// DelayedPublicMutableValues is just a wrapper around ScheduledValueChange and ScheduledDelayChange that then allows us\n/// to wrap both of these values in WithHash. WithHash allows for efficient read of values in private.\n///\n/// Note that the WithHash optimization does not work in public (due to there being no unconstrained). But we also want\n/// to be able to read the values efficiently in public and we want to be able to read each value separately. Reading\n/// the values separately is tricky because ScheduledValueChange and ScheduledDelayChange are packed together (sdc and\n/// svc.timestamp_of_change are stored in the same slot). For that reason we expose `unpack_value_change` and\n/// `unpack_delay_change` functions that can be used to extract the values from the packed representation. This\n/// is \"hacky\" but there is no way around it.\n#[derive(Eq)]\npub struct DelayedPublicMutableValues<T, let INITIAL_DELAY: u64> {\n pub svc: ScheduledValueChange<T>,\n pub sdc: ScheduledDelayChange<INITIAL_DELAY>,\n}\n\nimpl<T, let INITIAL_DELAY: u64> DelayedPublicMutableValues<T, INITIAL_DELAY> {\n pub fn new(svc: ScheduledValueChange<T>, sdc: ScheduledDelayChange<INITIAL_DELAY>) -> Self {\n DelayedPublicMutableValues { svc, sdc }\n }\n}\n\n/// Extracts a ScheduledValueChange struct from the packed representation of the full DelayedPublicMutable.\n/// TODO: impl the packable trait for ScheduledValueChange.\npub fn unpack_value_change<T, let M: u32>(packed: [Field; 2 * M + 1]) -> ScheduledValueChange<T>\nwhere\n T: Packable<N = M>,\n{\n let svc_pre_packed = arrays::subarray(packed, 1);\n let svc_post_packed = arrays::subarray(packed, M + 1);\n\n // We first cast to u32 as the timestamp_of_change is packed into the same field as the delay change and it\n // occupies the first 32 bits of the field.\n let timestamp_of_change = (packed[0] as u32) as u64;\n ScheduledValueChange::new(\n T::unpack(svc_pre_packed),\n T::unpack(svc_post_packed),\n timestamp_of_change,\n )\n}\n\n/// Extracts a ScheduledDelayChange struct from 0th field of the packed representation of the full DelayedPublicMutable.\n/// This function expects to be called with just the first field of the packed representation, which contains sdc\n/// and svc timestamp_of_change. We'll discard the svc component.\npub fn unpack_delay_change<let INITIAL_DELAY: u64>(\n packed: Field,\n) -> ScheduledDelayChange<INITIAL_DELAY> {\n // This function expects to be called with just the first field of the packed representation, which contains sdc\n // and svc timestamp_of_change. We'll discard the svc component.\n let svc_timestamp_of_change = packed as u32;\n\n let mut tmp = (packed - svc_timestamp_of_change as Field) / TWO_POW_32;\n let sdc_timestamp_of_change = tmp as u32;\n\n tmp = (tmp - sdc_timestamp_of_change as Field) / TWO_POW_32;\n let sdc_post_is_some = (tmp as u1) != 0;\n\n tmp = (tmp - sdc_post_is_some as Field) / TWO_POW_8;\n let sdc_post_inner = tmp as u32;\n\n tmp = (tmp - sdc_post_inner as Field) / TWO_POW_32;\n let sdc_pre_is_some = (tmp as u1) != 0;\n\n tmp = (tmp - sdc_pre_is_some as Field) / TWO_POW_8;\n let sdc_pre_inner = tmp as u32;\n\n // Note that below we cast the values to u64 as that is the default type of timestamp in the system. Us packing\n // the values as u32 is a tech debt that is not worth tackling.\n ScheduledDelayChange {\n pre: if sdc_pre_is_some {\n Option::some(sdc_pre_inner as u64)\n } else {\n Option::none()\n },\n post: if sdc_post_is_some {\n Option::some(sdc_post_inner as u64)\n } else {\n Option::none()\n },\n timestamp_of_change: sdc_timestamp_of_change as u64,\n }\n}\n\n// Q: do these evaluate at comptime or runtime?\nglobal TWO_POW_32: Field = 2.pow_32(32);\nglobal TWO_POW_8: Field = 2.pow_32(8);\n\n// We pack to `2 * N + 1` fields because ScheduledValueChange contains T twice (hence `2 * N`) and we need one extra\n// field to store ScheduledDelayChange and the timestamp_of_change of ScheduledValueChange.\nimpl<T, let INITIAL_DELAY: u64> Packable for DelayedPublicMutableValues<T, INITIAL_DELAY>\nwhere\n T: Packable,\n{\n let N: u32 = 2 * <T as Packable>::N + 1;\n\n fn pack(self) -> [Field; Self::N] {\n let mut result = [0; Self::N];\n\n // We pack sdc.pre, sdc.post, sdc.timestamp_of_change and svc.timestamp_of_change into a single field as follows:\n // [ sdc.pre_inner: u32 | sdc.pre_is_some: u8 | sdc.post_inner: u32 | sdc.post_is_some: u8 | sdc.timestamp_of_change: u32 | svc.timestamp_of_change: u32 ]\n // Note that the code below no longer works after 2106 as by that time the timestamp will overflow u32. This is a tech debt that is not worth tackling.\n result[0] = self.svc.timestamp_of_change as Field\n + ((self.sdc.timestamp_of_change as Field) * 2.pow_32(32))\n + ((self.sdc.post.is_some() as Field) * 2.pow_32(64))\n + ((self.sdc.post.unwrap_unchecked() as Field) * 2.pow_32(72))\n + ((self.sdc.pre.is_some() as Field) * 2.pow_32(104))\n + ((self.sdc.pre.unwrap_unchecked() as Field) * 2.pow_32(112));\n\n // Pack the pre and post values from ScheduledValueChange\n let svc_pre_packed = self.svc.pre.pack();\n let svc_post_packed = self.svc.post.pack();\n for i in 0..<T as Packable>::N {\n result[i + 1] = svc_pre_packed[i];\n result[i + 1 + <T as Packable>::N] = svc_post_packed[i];\n }\n result\n }\n\n // Note: inefficient if all you want to unpack is the svc; use unpack_value_change instead.\n fn unpack(fields: [Field; Self::N]) -> Self {\n let svc = unpack_value_change::<T, _>(fields);\n let sdc = unpack_delay_change::<INITIAL_DELAY>(fields[0]);\n Self::new(svc, sdc)\n }\n}\n\nimpl<T, let INITIAL_DELAY: u64> Hash for DelayedPublicMutableValues<T, INITIAL_DELAY>\nwhere\n T: Packable,\n{\n fn hash(self) -> Field {\n poseidon2_hash(self.pack())\n }\n}\n"
|
|
@@ -2861,21 +2857,25 @@
|
|
|
2861
2857
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/delayed_public_mutable/scheduled_value_change.nr",
|
|
2862
2858
|
"source": "use crate::traits::Empty;\nuse std::cmp::min;\n\nmod test;\n\n// This data structure is used by DelayedPublicMutable to represent a value that changes from `pre` to `post` at some timestamp\n// called the `timestamp_of_change`. The value can only be made to change by scheduling a change event at some future\n// timestamp after some minimum delay measured in seconds has elapsed. This means that at any given timestamp we know\n// both the current value and the smallest timestamp at which the value might change - this is called the\n// 'time horizon'.\npub struct ScheduledValueChange<T> {\n pub(crate) pre: T,\n pub(crate) post: T,\n // Timestamp at which `post` value is used instead of `pre`\n pub(crate) timestamp_of_change: u64,\n}\n\nimpl<T> ScheduledValueChange<T> {\n pub fn new(pre: T, post: T, timestamp_of_change: u64) -> Self {\n Self { pre, post, timestamp_of_change }\n }\n\n /// Returns the value stored in the data structure at a given timestamp. This function can be called both in public\n /// (where `timestamp` is simply the current timestamp, i.e. the timestamp at which the current transaction will be\n /// included) and in private (where `timestamp` is the anchor block's timestamp). Reading in private is only safe\n /// if the transaction's `include_by_timestamp` property is set to a value lower or equal to the time horizon (see\n /// `get_time_horizon()`).\n pub fn get_current_at(self, timestamp: u64) -> T {\n // The post value becomes the current one at the timestamp of change. This means different things in each realm:\n // - in public, any transaction that is included at the timestamp of change will use the post value\n // - in private, any transaction that includes the timestamp of change as part of the historical state will use\n // the post value (barring any follow-up changes)\n if timestamp < self.timestamp_of_change {\n self.pre\n } else {\n self.post\n }\n }\n\n /// Returns the scheduled change, i.e. the post-change value and the timestamp at which it will become the current\n /// value. Note that this timestamp may be in the past if the change has already taken place.\n /// Additionally, further changes might be later scheduled, potentially canceling the one returned by this function.\n pub fn get_scheduled(self) -> (T, u64) {\n (self.post, self.timestamp_of_change)\n }\n\n // Returns the previous value. This is the value that is current up until the timestamp of change. Note that this\n // value might not be the current anymore since timestamp of change might have already passed.\n pub fn get_previous(self) -> (T, u64) {\n (self.pre, self.timestamp_of_change)\n }\n\n /// Returns the largest timestamp at which the value returned by `get_current_at` is known to remain the current\n /// value. This value is only meaningful in private where the proof is constructed against an anchor block, since\n /// due to its asynchronous nature private execution cannot know about any later scheduled changes.\n /// The caller of this function must know how quickly the value can change due to a scheduled change in the form of\n /// `minimum_delay`. If the delay itself is immutable, then this is just its duration. If the delay is mutable\n /// however, then this value is the 'effective minimum delay' (obtained by calling\n /// `ScheduledDelayChange.get_effective_minimum_delay_at`), which equals the minimum time in seconds that needs to\n /// elapse from the next block's timestamp until the value changes, regardless of further delay changes.\n /// The value returned by `get_current_at` in private when called with a anchor block's timestamp is only safe to use\n /// if the transaction's `include_by_timestamp` property is set to a value lower or equal to the time horizon\n /// computed using the same anchor timestamp.\n pub fn get_time_horizon(self, anchor_timestamp: u64, minimum_delay: u64) -> u64 {\n // The time horizon is the very last timestamp in which the current value is known. Any timestamp past the\n // horizon (i.e. with a timestamp larger than the time horizon) may have a different current value.\n // Reading the current value in private typically requires constraining the maximum valid timestamp to be equal\n // to the time horizon.\n if anchor_timestamp >= self.timestamp_of_change {\n // Once the timestamp of change has passed (block with timestamp >= timestamp_of_change was mined),\n // the current value (post) will not change unless a new value change is scheduled. This did not happen at\n // the anchor timestamp (or else it would not be greater or equal to the timestamp of change), and\n // therefore could only happen after the anchor timestamp. The earliest would be the immediate next\n // timestamp, and so the smallest possible next timestamp of change equals `anchor_timestamp + 1 +\n // minimum_delay`. Our time horizon is simply the previous timestamp to that one.\n //\n // timestamp of anchor\n // change timestamp time horizon\n // =======|=============N===================H===========>\n // ^ ^\n // ---------------------\n // minimum delay\n anchor_timestamp + minimum_delay\n } else {\n // If the timestamp of change has not yet been reached however, then there are two possible scenarios.\n // a) It could be so far into the future that the time horizon is actually determined by the minimum\n // delay, because a new change could be scheduled and take place _before_ the currently scheduled one.\n // This is similar to the scenario where the timestamp of change is in the past: the time horizon is\n // the timestamp prior to the earliest one in which a new timestamp of change might land.\n //\n // anchor\n // timestamp time horizon timestamp of change\n // =====N=================================H=================|=========>\n // ^ ^\n // | |\n // -----------------------------------\n // minimum delay\n //\n // b) It could be fewer than `minimum_delay` seconds away from the anchor timestamp, in which case\n // the timestamp of change would become the limiting factor for the time horizon, which would equal\n // the timestamp right before the timestamp of change (since by definition the value changes at the\n // timestamp of change).\n //\n // anchor time horizon\n // timestamp timestamp of change if not scheduled\n // =======N=============|===================H=================>\n // ^ ^ ^\n // | actual horizon |\n // -----------------------------------\n // minimum delay\n //\n // Note that the current implementation does not allow the caller to set the timestamp of change to an\n // arbitrary value, and therefore scenario a) is not currently possible. However implementing #5501 would\n // allow for this to happen.\n // Because anchor_timestamp < self.timestamp_of_change, then timestamp_of_change > 0 and we can safely\n // subtract 1.\n min(\n self.timestamp_of_change - 1,\n anchor_timestamp + minimum_delay,\n )\n }\n }\n\n /// Mutates the value by scheduling a change at the current timestamp. This function is only meaningful when\n /// called in public with the current timestamp.\n pub fn schedule_change(\n &mut self,\n new_value: T,\n current_timestamp: u64,\n minimum_delay: u64,\n timestamp_of_change: u64,\n ) {\n assert(timestamp_of_change >= current_timestamp + minimum_delay);\n\n self.pre = self.get_current_at(current_timestamp);\n self.post = new_value;\n self.timestamp_of_change = timestamp_of_change;\n }\n}\n\nimpl<T> Eq for ScheduledValueChange<T>\nwhere\n T: Eq,\n{\n fn eq(self, other: Self) -> bool {\n (self.pre == other.pre)\n & (self.post == other.post)\n & (self.timestamp_of_change == other.timestamp_of_change)\n }\n}\n\nimpl<T> Empty for ScheduledValueChange<T>\nwhere\n T: Empty,\n{\n fn empty() -> Self {\n Self { pre: T::empty(), post: T::empty(), timestamp_of_change: 0 }\n }\n}\n"
|
|
2863
2859
|
},
|
|
2864
|
-
"
|
|
2860
|
+
"387": {
|
|
2865
2861
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
|
|
2866
|
-
"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"
|
|
2862
|
+
"source": "mod poseidon2_chunks;\n\nuse crate::{\n abis::{\n contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n function_selector::FunctionSelector, nullifier::Nullifier, private_log::PrivateLog,\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\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 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_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_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_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_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 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 compute_siloed_private_log(contract_address: AztecAddress, log: PrivateLog) -> PrivateLog {\n let mut fields = log.fields;\n fields[0] = compute_siloed_private_log_first_field(contract_address, fields[0]);\n PrivateLog::new(fields, log.length)\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_message_hash(\n message: Scoped<L2ToL1Message>,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n let contract_address_bytes: [u8; 32] = message.contract_address.to_field().to_be_bytes();\n let recipient_bytes: [u8; 20] = message.inner.recipient.to_be_bytes();\n let content_bytes: [u8; 32] = message.inner.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\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// 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 subarray_hash_matches_fixed() {\n let mut values_to_hash = [3; 17];\n let mut padded = values_to_hash.concat([0; 11]);\n let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n // Hash the entire values_to_hash.\n let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(values_to_hash, values_to_hash.len());\n\n assert_eq(subarray_hash, fixed_len_hash);\n}\n\n#[test]\nfn subarray_hash_matches_variable() {\n let mut values_to_hash = [3; 17];\n let mut padded = values_to_hash.concat([0; 11]);\n let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n // Hash up to values_to_hash.len() fields of the padded array.\n let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(padded, values_to_hash.len());\n\n assert_eq(subarray_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 unique_siloed_note_hash_matches_typescript() {\n let inner_note_hash = 1;\n let contract_address = AztecAddress::from_field(2);\n let first_nullifier = 3;\n let note_index_in_tx = 4;\n\n let siloed_note_hash = compute_siloed_note_hash(contract_address, inner_note_hash);\n let siloed_note_hash_from_ts =\n 0x1986a4bea3eddb1fff917d629a13e10f63f514f401bdd61838c6b475db949169;\n assert_eq(siloed_note_hash, siloed_note_hash_from_ts);\n\n let nonce: Field = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n let note_hash_nonce_from_ts =\n 0x28e7799791bf066a57bb51fdd0fbcaf3f0926414314c7db515ea343f44f5d58b;\n assert_eq(nonce, note_hash_nonce_from_ts);\n\n let unique_siloed_note_hash_from_nonce = compute_unique_note_hash(nonce, siloed_note_hash);\n let unique_siloed_note_hash = compute_note_nonce_and_unique_note_hash(\n siloed_note_hash,\n first_nullifier,\n note_index_in_tx,\n );\n assert_eq(unique_siloed_note_hash_from_nonce, unique_siloed_note_hash);\n\n let unique_siloed_note_hash_from_ts =\n 0x29949aef207b715303b24639737c17fbfeb375c1d965ecfa85c7e4f0febb7d16;\n assert_eq(unique_siloed_note_hash, unique_siloed_note_hash_from_ts);\n}\n\n#[test]\nfn siloed_nullifier_matches_typescript() {\n let contract_address = AztecAddress::from_field(123);\n let nullifier = 456;\n\n let res = compute_siloed_nullifier(contract_address, nullifier);\n\n let siloed_nullifier_from_ts =\n 0x169b50336c1f29afdb8a03d955a81e485f5ac7d5f0b8065673d1e407e5877813;\n\n assert_eq(res, siloed_nullifier_from_ts);\n}\n\n#[test]\nfn siloed_private_log_first_field_matches_typescript() {\n let contract_address = AztecAddress::from_field(123);\n let field = 456;\n let res = compute_siloed_private_log_first_field(contract_address, field);\n\n let siloed_private_log_first_field_from_ts =\n 0x29480984f7b9257fded523d50addbcfc8d1d33adcf2db73ef3390a8fd5cdffaa;\n\n assert_eq(res, siloed_private_log_first_field_from_ts);\n}\n\n#[test]\nfn empty_l2_to_l1_message_hash_matches_typescript() {\n // All zeroes\n let res = compute_l2_to_l1_message_hash(\n L2ToL1Message { recipient: EthAddress::zero(), content: 0 }.scope(AztecAddress::from_field(\n 0,\n )),\n 0,\n 0,\n );\n\n let empty_l2_to_l1_msg_hash_from_ts =\n 0x003b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992;\n\n assert_eq(res, empty_l2_to_l1_msg_hash_from_ts);\n}\n\n#[test]\nfn l2_to_l1_message_hash_matches_typescript() {\n let message = L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n AztecAddress::from_field(3),\n );\n let version = 4;\n let chainId = 5;\n\n let hash = compute_l2_to_l1_message_hash(message, version, chainId);\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"
|
|
2863
|
+
},
|
|
2864
|
+
"389": {
|
|
2865
|
+
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/logging.nr",
|
|
2866
|
+
"source": "// Log levels matching the JS logger:\n\n// global SILENT_LOG_LEVEL: u8 = 0;\nglobal FATAL_LOG_LEVEL: u8 = 1;\nglobal ERROR_LOG_LEVEL: u8 = 2;\nglobal WARN_LOG_LEVEL: u8 = 3;\nglobal INFO_LOG_LEVEL: u8 = 4;\nglobal VERBOSE_LOG_LEVEL: u8 = 5;\nglobal DEBUG_LOG_LEVEL: u8 = 6;\nglobal TRACE_LOG_LEVEL: u8 = 7;\n\n// --- Per-level log functions (no format args) ---\n\npub fn fatal_log<let N: u32>(msg: str<N>) {\n fatal_log_format(msg, []);\n}\n\npub fn error_log<let N: u32>(msg: str<N>) {\n error_log_format(msg, []);\n}\n\npub fn warn_log<let N: u32>(msg: str<N>) {\n warn_log_format(msg, []);\n}\n\npub fn info_log<let N: u32>(msg: str<N>) {\n info_log_format(msg, []);\n}\n\npub fn verbose_log<let N: u32>(msg: str<N>) {\n verbose_log_format(msg, []);\n}\n\npub fn debug_log<let N: u32>(msg: str<N>) {\n debug_log_format(msg, []);\n}\n\npub fn trace_log<let N: u32>(msg: str<N>) {\n trace_log_format(msg, []);\n}\n\n// --- Per-level log functions (with format args) ---\n\npub fn fatal_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n log_format(FATAL_LOG_LEVEL, msg, args);\n}\n\npub fn error_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n log_format(ERROR_LOG_LEVEL, msg, args);\n}\n\npub fn warn_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n log_format(WARN_LOG_LEVEL, msg, args);\n}\n\npub fn info_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n log_format(INFO_LOG_LEVEL, msg, args);\n}\n\npub fn verbose_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n log_format(VERBOSE_LOG_LEVEL, msg, args);\n}\n\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n log_format(DEBUG_LOG_LEVEL, msg, args);\n}\n\npub fn trace_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n log_format(TRACE_LOG_LEVEL, msg, args);\n}\n\nfn log_format<let M: u32, let N: u32>(log_level: u8, msg: str<M>, args: [Field; N]) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { log_oracle_wrapper(log_level, msg, args) };\n}\n\nunconstrained fn log_oracle_wrapper<let M: u32, let N: u32>(\n log_level: u8,\n msg: str<M>,\n args: [Field; N],\n) {\n log_oracle(log_level, msg, N, args);\n}\n\n#[oracle(utilityLog)]\nunconstrained fn log_oracle<let M: u32, let N: u32>(\n log_level: u8,\n msg: str<M>,\n length: u32,\n args: [Field; N],\n) {}\n"
|
|
2867
2867
|
},
|
|
2868
2868
|
"403": {
|
|
2869
2869
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/point.nr",
|
|
2870
|
-
"source": "pub use
|
|
2870
|
+
"source": "pub use std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse crate::{hash::poseidon2_hash, traits::{Deserialize, Empty, Hash, Packable, Serialize}};\n\npub global POINT_LENGTH: u32 = 3;\n\nimpl Hash for Point {\n fn hash(self) -> Field {\n poseidon2_hash(self.serialize())\n }\n}\n\nimpl Empty for Point {\n /// Note: Does not return a valid point on curve - instead represents an empty/\"unpopulated\" point struct (e.g.\n /// empty/unpopulated value in an array of points).\n fn empty() -> Self {\n Point { x: 0, y: 0, is_infinite: false }\n }\n}\n\npub fn validate_on_curve(p: Point) {\n // y^2 == x^3 - 17\n let x = p.x;\n let y = p.y;\n if p.is_infinite {\n // Assert the canonical representation of infinity\n assert_eq(x, 0, \"Point at infinity should have canonical representation (0 0)\");\n assert_eq(y, 0, \"Point at infinity should have canonical representation (0 0)\");\n } else {\n assert_eq(y * y, x * x * x - 17, \"Point not on curve\");\n }\n}\n\n// TODO(#11356): use compact representation here.\nimpl Packable for Point {\n let N: u32 = POINT_LENGTH;\n\n fn pack(self) -> [Field; Self::N] {\n self.serialize()\n }\n\n fn unpack(packed: [Field; Self::N]) -> Self {\n Self::deserialize(packed)\n }\n}\n\nmod tests {\n use super::validate_on_curve;\n use std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\n #[test]\n unconstrained fn test_validate_on_curve_generator() {\n // The generator point should be on the curve\n let generator = Point::generator();\n validate_on_curve(generator);\n }\n\n #[test]\n unconstrained fn test_validate_on_curve_infinity() {\n // Canonical infinite point (x=0, y=0) should pass\n let infinity = Point { x: 0, y: 0, is_infinite: true };\n validate_on_curve(infinity);\n }\n\n #[test(should_fail_with = \"Point not on curve\")]\n unconstrained fn test_validate_on_curve_invalid_point() {\n // A point not on the curve should fail\n let invalid = Point { x: 1, y: 1, is_infinite: false };\n validate_on_curve(invalid);\n }\n\n #[test(should_fail_with = \"Point at infinity should have canonical representation (0 0)\")]\n unconstrained fn test_validate_on_curve_infinity_non_canonical_x() {\n // Infinite point with non-zero x should fail\n let invalid_infinity = Point { x: 1, y: 0, is_infinite: true };\n validate_on_curve(invalid_infinity);\n }\n\n #[test(should_fail_with = \"Point at infinity should have canonical representation (0 0)\")]\n unconstrained fn test_validate_on_curve_infinity_non_canonical_y() {\n // Infinite point with non-zero y should fail\n let invalid_infinity = Point { x: 0, y: 1, is_infinite: true };\n validate_on_curve(invalid_infinity);\n }\n}\n"
|
|
2871
2871
|
},
|
|
2872
2872
|
"411": {
|
|
2873
2873
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/public_keys.nr",
|
|
2874
|
-
"source": "use crate::{\n address::public_keys_hash::PublicKeysHash,\n constants::{\n DEFAULT_IVPK_M_X, DEFAULT_IVPK_M_Y, DEFAULT_NPK_M_X, DEFAULT_NPK_M_Y, DEFAULT_OVPK_M_X,\n DEFAULT_OVPK_M_Y, DEFAULT_TPK_M_X, DEFAULT_TPK_M_Y, DOM_SEP__PUBLIC_KEYS_HASH,\n },\n hash::poseidon2_hash_with_separator,\n traits::{Deserialize, Hash, Serialize},\n};\n\nuse
|
|
2874
|
+
"source": "use crate::{\n address::public_keys_hash::PublicKeysHash,\n constants::{\n DEFAULT_IVPK_M_X, DEFAULT_IVPK_M_Y, DEFAULT_NPK_M_X, DEFAULT_NPK_M_Y, DEFAULT_OVPK_M_X,\n DEFAULT_OVPK_M_Y, DEFAULT_TPK_M_X, DEFAULT_TPK_M_Y, DOM_SEP__PUBLIC_KEYS_HASH,\n },\n hash::poseidon2_hash_with_separator,\n traits::{Deserialize, Hash, Serialize},\n};\n\nuse std::{default::Default, meta::derive};\nuse std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\npub trait ToPoint {\n fn to_point(self) -> Point;\n}\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct NpkM {\n pub inner: Point,\n}\n\nimpl ToPoint for NpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\n// Note: If we store npk_m_hash directly we can remove this trait implementation. See #8091\nimpl Hash for NpkM {\n fn hash(self) -> Field {\n self.inner.hash()\n }\n}\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct IvpkM {\n pub inner: Point,\n}\n\nimpl ToPoint for IvpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct OvpkM {\n pub inner: Point,\n}\n\nimpl Hash for OvpkM {\n fn hash(self) -> Field {\n self.inner.hash()\n }\n}\n\nimpl ToPoint for OvpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct TpkM {\n pub inner: Point,\n}\n\nimpl ToPoint for TpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct PublicKeys {\n pub npk_m: NpkM,\n pub ivpk_m: IvpkM,\n pub ovpk_m: OvpkM,\n pub tpk_m: TpkM,\n}\n\nimpl Default for PublicKeys {\n fn default() -> Self {\n PublicKeys {\n npk_m: NpkM {\n inner: Point { x: DEFAULT_NPK_M_X, y: DEFAULT_NPK_M_Y, is_infinite: false },\n },\n ivpk_m: IvpkM {\n inner: Point { x: DEFAULT_IVPK_M_X, y: DEFAULT_IVPK_M_Y, is_infinite: false },\n },\n ovpk_m: OvpkM {\n inner: Point { x: DEFAULT_OVPK_M_X, y: DEFAULT_OVPK_M_Y, is_infinite: false },\n },\n tpk_m: TpkM {\n inner: Point { x: DEFAULT_TPK_M_X, y: DEFAULT_TPK_M_Y, is_infinite: false },\n },\n }\n }\n}\n\nimpl PublicKeys {\n pub fn hash(self) -> PublicKeysHash {\n PublicKeysHash::from_field(poseidon2_hash_with_separator(\n self.serialize(),\n DOM_SEP__PUBLIC_KEYS_HASH as Field,\n ))\n }\n}\n\npub struct AddressPoint {\n pub inner: Point,\n}\n\nimpl ToPoint for AddressPoint {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nmod test {\n use crate::{\n point::POINT_LENGTH,\n public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n traits::{Deserialize, Serialize},\n };\n use std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\n #[test]\n unconstrained fn compute_public_keys_hash() {\n let keys = PublicKeys {\n npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n };\n\n let actual = keys.hash();\n\n // The following value was generated by `public_keys.test.ts`.\n let expected_public_keys_hash =\n 0x056998309f6c119e4d753e404f94fef859dddfa530a9379634ceb0854b29bf7a;\n\n assert(actual.to_field() == expected_public_keys_hash);\n }\n\n #[test]\n unconstrained fn compute_default_hash() {\n let keys = PublicKeys::default();\n\n let actual = keys.hash();\n\n // The following value was generated by `public_keys.test.ts`.\n let test_data_default_hash =\n 0x023547e676dba19784188825b901a0e70d8ad978300d21d6185a54281b734da0;\n\n assert(actual.to_field() == test_data_default_hash);\n }\n\n #[test]\n unconstrained fn serde() {\n let keys = PublicKeys {\n npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n };\n\n // We use the PUBLIC_KEYS_LENGTH constant to ensure that there is a match between the derived trait\n let serialized: [Field; POINT_LENGTH * 4] = keys.serialize();\n let deserialized = PublicKeys::deserialize(serialized);\n\n assert_eq(keys, deserialized);\n }\n}\n"
|
|
2875
2875
|
},
|
|
2876
2876
|
"416": {
|
|
2877
2877
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr",
|
|
2878
|
-
"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
|
|
2878
|
+
"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"
|
|
2879
2879
|
},
|
|
2880
2880
|
"42": {
|
|
2881
2881
|
"path": "std/option.nr",
|
|
@@ -2891,7 +2891,7 @@
|
|
|
2891
2891
|
},
|
|
2892
2892
|
"439": {
|
|
2893
2893
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/arrays.nr",
|
|
2894
|
-
"source": "pub(crate) mod assert_trailing_zeros;\npub(crate) mod copy_items_into_array;\npub(crate) mod find_index;\npub(crate) mod get_sorted_tuples;\npub(crate) mod claimed_length_array;\n\n// Re-exports.\npub use assert_trailing_zeros::assert_trailing_zeros;\npub use claimed_length_array::ClaimedLengthArray;\npub use copy_items_into_array::copy_items_into_array;\npub use find_index::{find_first_index, find_last_index};\npub use get_sorted_tuples::{get_sorted_tuples, SortedTuple};\n\nuse crate::traits::Empty;\n\n// TODO: Consider making this a part of the noir stdlib.\n/// Helper fn to create a subarray from a given array.\npub fn subarray<T, let N: u32, let M: u32>(array: [T; N], offset: u32) -> [T; M]\nwhere\n T: Empty,\n{\n let mut result: [T; M] = [T::empty(); M];\n for i in 0..M {\n result[i] = array[offset + i];\n }\n result\n}\n\n/// Helper function to count the number of non-empty elements in a validated array.\n/// Danger: This is only safe to call if the input arrays have been \"validated\" (dense lhs, empty rhs).\n/// 1. All elements before the first empty element are non-empty\n/// 2. All elements after and including the first empty element are empty\n/// 3. The array forms a contiguous sequence of non-empty elements followed by empty elements\npub fn array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n T: Empty,\n{\n // We get the length by checking the index of the first empty element.\n\n // Safety: This is safe because we have validated the array (see function doc comment above) and the emptiness\n // of the element and non-emptiness of the previous element is checked below.\n let length = unsafe { find_first_index(array, |elem: T| elem.is_empty()) };\n\n validate_array_length_hint(array, length);\n\n length\n}\n\n// Extracted into a standalone function to enable testing of bad hints.\nfn validate_array_length_hint<T, let N: u32>(array: [T; N], length: u32)\nwhere\n T: Empty,\n{\n // Note: if length > N, the below `array` access will throw an out of bounds error.\n\n if length != N {\n array[length].assert_empty(\"Expected array[length] to be empty\");\n }\n\n if length != 0 {\n assert(\n !array[length - 1].is_empty(),\n \"Expected claimed final element of array (array[length - 1]) to be nonempty\",\n );\n }\n}\n\n// Returns an array length defined by fully trimming _all_ \"empty\" items\n// from the RHS.\npub unconstrained fn trimmed_array_length_hint<T, let N: u32>(array: [T; N]) -> u32\nwhere\n T: Empty,\n{\n let index_of_last_nonempty = find_last_index(array, |elem: T| !elem.is_empty());\n let length: u32 = if index_of_last_nonempty != N {\n 1 + index_of_last_nonempty\n } else {\n 0\n };\n length\n}\n\n// Returns the number of consecutive elements at the start of the array for which the predicate returns false.\n// This function ensures that any element after the first matching element (predicate returns true) also matches the predicate.\npub fn array_length_until<T, let N: u32, Env>(array: [T; N], predicate: fn[Env](T) -> bool) -> u32 {\n let mut length = 0;\n let mut stop = false;\n for i in 0..N {\n if predicate(array[i]) {\n stop = true;\n } else {\n assert(\n stop == false,\n \"matching element found after already encountering a non-matching element\",\n );\n length += 1;\n }\n }\n length\n}\n\n/// This function assumes that `array1` and `array2` contain no more than N non-empty elements between them,\n/// if this is not the case then elements from the end of `array2` will be dropped.\n/// Danger: This is only safe to call if the input arrays have been \"validated\" (dense lhs, empty rhs).\npub fn array_merge<T, let N: u32>(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n T: Empty,\n{\n // Safety: we constrain this array below\n let result = unsafe { array_merge_helper(array1, array2) };\n\n validate_array_merge_hint(array1, array2, result);\n\n result\n}\n\n// Danger: assumes the array's length has already been validated.\nunconstrained fn array_merge_helper<T, let N: u32>(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n T: Empty,\n{\n let mut result: [T; N] = [T::empty(); N];\n let mut i = 0;\n for elem in array1 {\n // This function should only be used with validated arrays, so it's fine to simply skip empty elements here.\n if !elem.is_empty() {\n result[i] = elem;\n i += 1;\n }\n }\n for elem in array2 {\n if !elem.is_empty() {\n result[i] = elem;\n i += 1;\n }\n }\n result\n}\n\n/// Extracted into a standalone function to enable testing of bad hints.\n/// Danger: This is only safe to call if the input arrays have been \"validated\" (dense lhs, empty rhs).\nfn validate_array_merge_hint<T, let N: u32>(array1: [T; N], array2: [T; N], result: [T; N])\nwhere\n T: Empty,\n{\n // We assume the array length has been validated. The only use cases so far are with previously validated arrays.\n let array1_len = array_length(array1);\n let mut add_from_left = true;\n for i in 0..N {\n add_from_left &= i != array1_len;\n if add_from_left {\n assert_eq(result[i], array1[i], \"Incorrect array merge hint\");\n } else {\n assert_eq(result[i], array2[i - array1_len], \"Incorrect array merge hint\");\n }\n }\n}\n\npub fn check_permutation<T, let N: u32>(\n original_array: [T; N],\n permuted_array: [T; N],\n original_indexes: [u32; N],\n)\nwhere\n T: Eq,\n{\n let mut seen_value = [false; N];\n for i in 0..N {\n let index = original_indexes[i];\n let original_value = original_array[index];\n assert(permuted_array[i].eq(original_value), \"Invalid index\");\n assert(!seen_value[index], \"Duplicated index\");\n seen_value[index] = true;\n }\n}\n\n// Helper function to check if an array is padded with a given value from a given index.\npub fn array_padded_with<T, let N: u32>(array: [T; N], from_index: u32, padded_with: T) -> bool\nwhere\n T: Eq,\n{\n let mut is_valid = true;\n let mut should_check = false;\n for i in 0..N {\n should_check |= i == from_index;\n is_valid &= !should_check | (array[i] == padded_with);\n }\n is_valid\n}\n\n// ==================== subarray tests ====================\n\n#[test]\nfn test_subarray() {\n assert_eq(subarray::<_, 5, 3>([10, 20, 30, 40, 50], 1), [20, 30, 40]);\n assert_eq(subarray::<_, 5, 2>([10, 20, 30, 40, 50], 0), [10, 20]);\n assert_eq(subarray::<_, 3, 0>([10, 20, 30], 2), []);\n assert_eq(subarray::<_, 3, 1>([10, 20, 30], 2), [30]);\n}\n\n#[test(should_fail_with = \"out of bounds\")]\nfn test_subarray_offset_out_of_bounds() {\n let _: [Field; 1] = subarray([10, 20, 30], 5);\n}\n\n#[test(should_fail_with = \"out of bounds\")]\nfn test_subarray_result_size_exceeds_available() {\n let _: [Field; 3] = subarray([10, 20, 30, 40, 50], 3);\n}\n\n// ==================== array_length tests ====================\n\n#[test]\nfn test_array_length_empty_array() {\n assert_eq(array_length([0]), 0);\n assert_eq(array_length([0, 0, 0]), 0);\n}\n\n#[test]\nfn test_array_length() {\n assert_eq(array_length([123]), 1);\n assert_eq(array_length([123, 0, 0]), 1);\n assert_eq(array_length([123, 456]), 2);\n assert_eq(array_length([123, 456, 0]), 2);\n}\n\n#[test]\nfn test_array_length_invalid_arrays() {\n // Result can be misleading (but correct) for invalid arrays.\n // This is why the arrays being passed-into `array_length` must already have been \"validated\"\n // (dense lhs, empty rhs).\n assert_eq(array_length([0, 0, 123]), 0);\n assert_eq(array_length([0, 123, 0]), 0);\n assert_eq(array_length([0, 123, 456]), 0);\n assert_eq(array_length([123, 0, 456]), 1);\n}\n\n// ==================== validate_array_length_hint tests ====================\n\n#[test]\nfn test_validate_array_length_hint_valid() {\n validate_array_length_hint([0, 0, 0], 0);\n validate_array_length_hint([10, 20, 0], 2);\n validate_array_length_hint([10, 20, 30], 3);\n}\n\n#[test(should_fail_with = \"Expected array[length] to be empty\")]\nfn test_validate_array_length_hint_claims_zero_when_not_empty() {\n // Invalid: hint says length 0, but first element is not empty\n validate_array_length_hint([10, 20, 30], 0);\n}\n\n#[test(should_fail_with = \"Expected array[length] to be empty\")]\nfn test_validate_array_length_hint_too_short() {\n // Invalid: hint says length 1, but element at index 1 is not empty\n validate_array_length_hint([10, 20, 0], 1);\n}\n\n#[test(should_fail_with = \"Expected claimed final element of array (array[length - 1]) to be nonempty\")]\nfn test_validate_array_length_hint_too_long() {\n // Invalid: hint says length 2, but element at index 1 is empty\n validate_array_length_hint([10, 0, 0], 2);\n}\n\n#[test(should_fail_with = \"Expected claimed final element of array (array[length - 1]) to be nonempty\")]\nfn test_validate_array_length_hint_of_empty_too_long() {\n // Invalid: hint says length 2, but element at index 1 is empty\n validate_array_length_hint([0, 0, 0], 2);\n}\n\n#[test(should_fail_with = \"out of bounds\")]\nfn test_validate_array_length_hint_out_of_bounds() {\n // Invalid: hint says length 4, but array only has 3 elements\n validate_array_length_hint([10, 20, 30], 4);\n}\n\n// ==================== trimmed_array_length_hint tests ====================\n\n#[test]\nunconstrained fn test_trimmed_array_length_hint_with_trailing_empties() {\n assert_eq(trimmed_array_length_hint([10, 20, 30, 0, 0]), 3);\n}\n\n#[test]\nunconstrained fn test_trimmed_array_length_hint_fully_empty() {\n assert_eq(trimmed_array_length_hint([0, 0, 0, 0, 0]), 0);\n}\n\n#[test]\nunconstrained fn test_trimmed_array_length_hint_no_empties() {\n assert_eq(trimmed_array_length_hint([10, 20, 30, 40, 50]), 5);\n}\n\n#[test]\nunconstrained fn test_trimmed_array_length_hint_with_gaps() {\n // Unlike array_length, this trims from the right only, so gaps don't matter\n assert_eq(trimmed_array_length_hint([10, 0, 30, 0, 0]), 3);\n}\n\n// ==================== array_length_until tests ====================\n\n#[test]\nfn test_array_length_until() {\n let array = [11, 22, 33, 44, 55];\n assert_eq(array_length_until(array, |x| x == 55), 4);\n assert_eq(array_length_until(array, |x| x == 56), 5);\n assert_eq(array_length_until(array, |x| x > 40), 3);\n assert_eq(array_length_until(array, |x| x > 10), 0);\n}\n\n#[test(should_fail_with = \"matching element found after already encountering a non-matching element\")]\nfn test_array_length_until_non_consecutive_fails() {\n let array = [1, 1, 0, 1, 0];\n let _ = array_length_until(array, |x| x == 0);\n}\n\n#[test(should_fail_with = \"matching element found after already encountering a non-matching element\")]\nfn test_array_length_until_first_non_matching_fails() {\n let array = [1, 0, 0, 0, 0];\n let _ = array_length_until(array, |x| x == 1);\n}\n\n// ==================== array_merge tests ====================\n\n#[test]\nfn test_array_merge() {\n assert_eq(array_merge([10, 20, 0, 0, 0], [30, 40, 50, 0, 0]), [10, 20, 30, 40, 50]);\n assert_eq(array_merge([0, 0, 0], [10, 20, 0]), [10, 20, 0]);\n assert_eq(array_merge([10, 20, 0], [0, 0, 0]), [10, 20, 0]);\n assert_eq(array_merge::<Field, 3>([0, 0, 0], [0, 0, 0]), [0, 0, 0]);\n}\n\n#[test(should_fail_with = \"out of bounds\")]\nfn test_array_merge_combined_exceeds_capacity() {\n let _ = array_merge([10, 20, 30, 0, 0], [40, 50, 60, 0, 0]);\n}\n\n#[test(should_fail_with = \"Incorrect array merge hint\")]\nfn test_array_merge_rejects_array1_with_gaps() {\n // array_merge assumes validated arrays (no gaps). The helper compacts empties,\n // but the validation expects array1's structure to be preserved, causing failure.\n let _ = array_merge([10, 0, 20, 0, 0], [30, 0, 0, 0, 0]);\n}\n\n#[test(should_fail_with = \"Incorrect array merge hint\")]\nfn test_array_merge_rejects_array2_with_gaps() {\n // array_merge assumes validated arrays (no gaps). The helper compacts empties,\n // but the validation expects array2's structure to be preserved, causing failure.\n let _ = array_merge([10, 0, 0, 0, 0], [0, 20, 0, 30, 0]);\n}\n\n// ==================== validate_array_merge_hint tests ====================\n\n#[test]\nfn test_validate_array_merge_hint_valid() {\n validate_array_merge_hint([10, 20, 0], [30, 0, 0], [10, 20, 30]);\n validate_array_merge_hint([0, 0, 0], [10, 20, 0], [10, 20, 0]);\n validate_array_merge_hint([10, 20, 0], [0, 0, 0], [10, 20, 0]);\n validate_array_merge_hint([0, 0, 0], [0, 0, 0], [0, 0, 0]);\n validate_array_merge_hint([10, 20, 0, 0], [30, 40, 0, 0], [10, 20, 30, 40]);\n}\n\n#[test(should_fail_with = \"Incorrect array merge hint\")]\nfn test_validate_array_merge_hint_wrong_result_from_array1() {\n // Invalid: result doesn't match array1 elements\n validate_array_merge_hint([10, 20, 0], [30, 0, 0], [99, 20, 30]);\n}\n\n#[test(should_fail_with = \"Incorrect array merge hint\")]\nfn test_validate_array_merge_hint_wrong_result_from_array2() {\n // Invalid: result doesn't match array2 elements\n validate_array_merge_hint([10, 20, 0], [30, 0, 0], [10, 20, 99]);\n}\n\n#[test(should_fail_with = \"Incorrect array merge hint\")]\nfn test_validate_array_merge_hint_swapped_order() {\n // Invalid: result has array2 elements before array1 elements\n validate_array_merge_hint([10, 20, 0], [30, 0, 0], [30, 10, 20]);\n}\n\n#[test(should_fail_with = \"Incorrect array merge hint\")]\nfn test_validate_array_merge_hint_missing_element_from_array1() {\n // Invalid: result is missing an element from array1\n validate_array_merge_hint([10, 20, 0], [30, 0, 0], [10, 30, 0]);\n}\n\n#[test(should_fail_with = \"Incorrect array merge hint\")]\nfn test_validate_array_merge_hint_missing_element_from_array2() {\n // Invalid: result is missing an element from array2 (truncated)\n validate_array_merge_hint([10, 20, 0, 0], [30, 40, 0, 0], [10, 20, 30, 0]);\n}\n\n#[test(should_fail_with = \"Incorrect array merge hint\")]\nfn test_validate_array_merge_hint_extra_element_in_padding() {\n // Invalid: result has garbage where array2's empties should be\n validate_array_merge_hint([10, 0, 0], [20, 0, 0], [10, 20, 99]);\n}\n\n#[test(should_fail_with = \"Incorrect array merge hint\")]\nfn test_validate_array_merge_hint_rejects_compacted_result_for_array1_with_gaps() {\n // If array1 has gaps, a compacted result won't match the expected structure\n validate_array_merge_hint([10, 0, 20, 0, 0], [30, 0, 0, 0, 0], [10, 20, 30, 0, 0]);\n}\n\n#[test(should_fail_with = \"Incorrect array merge hint\")]\nfn test_validate_array_merge_hint_rejects_compacted_result_for_array2_with_gaps() {\n // If array2 has gaps, a compacted result won't match the expected structure\n validate_array_merge_hint([10, 0, 0, 0, 0], [0, 20, 0, 30, 0], [10, 20, 30, 0, 0]);\n}\n\n// ==================== check_permutation tests ====================\n\n#[test]\nfn test_check_permutation() {\n let original_array = [1, 2, 3];\n let permuted_array = [3, 1, 2];\n let indexes = [2, 0, 1];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Duplicated index\")]\nfn test_check_permutation_duplicated_index() {\n let original_array = [0, 1, 0];\n let permuted_array = [1, 0, 0];\n let indexes = [1, 0, 0];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Invalid index\")]\nfn test_check_permutation_invalid_index() {\n let original_array = [0, 1, 2];\n let permuted_array = [1, 0, 0];\n let indexes = [1, 0, 2];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n// ==================== array_padded_with tests ====================\n\n#[test]\nfn test_array_padded_with() {\n let array = [11, 22, 33, 44, 44];\n assert_eq(array_padded_with(array, 0, 44), false);\n assert_eq(array_padded_with(array, 1, 44), false);\n assert_eq(array_padded_with(array, 2, 44), false);\n assert_eq(array_padded_with(array, 3, 44), true);\n assert_eq(array_padded_with(array, 4, 44), true);\n assert_eq(array_padded_with(array, 4, 33), false);\n assert_eq(array_padded_with(array, 5, 44), true); // Index out of bounds.\n assert_eq(array_padded_with(array, 0, 11), false);\n}\n"
|
|
2894
|
+
"source": "pub(crate) mod assert_trailing_zeros;\npub(crate) mod splice_at_count;\npub(crate) mod find_index;\npub(crate) mod get_sorted_tuples;\npub(crate) mod claimed_length_array;\n\n// Re-exports.\npub use assert_trailing_zeros::assert_trailing_zeros;\npub use claimed_length_array::ClaimedLengthArray;\npub use find_index::{find_first_index, find_last_index};\npub use get_sorted_tuples::{get_sorted_tuples, SortedTuple};\npub use splice_at_count::splice_at_count;\n\nuse crate::traits::Empty;\n\n// TODO: Consider making this a part of the noir stdlib.\n/// Helper fn to create a subarray from a given array.\npub fn subarray<T, let N: u32, let M: u32>(array: [T; N], offset: u32) -> [T; M]\nwhere\n T: Empty,\n{\n let mut result: [T; M] = [T::empty(); M];\n for i in 0..M {\n result[i] = array[offset + i];\n }\n result\n}\n\n/// Helper function to count the number of non-empty elements in a validated array.\n/// Danger: This is only safe to call if the input arrays have been \"validated\" (dense lhs, empty rhs).\n/// 1. All elements before the first empty element are non-empty\n/// 2. All elements after and including the first empty element are empty\n/// 3. The array forms a contiguous sequence of non-empty elements followed by empty elements\npub fn array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n T: Empty,\n{\n // We get the length by checking the index of the first empty element.\n\n // Safety: This is safe because we have validated the array (see function doc comment above) and the emptiness\n // of the element and non-emptiness of the previous element is checked below.\n let length = unsafe { find_first_index(array, |elem: T| elem.is_empty()) };\n\n validate_array_length_hint(array, length);\n\n length\n}\n\n// Extracted into a standalone function to enable testing of bad hints.\nfn validate_array_length_hint<T, let N: u32>(array: [T; N], length: u32)\nwhere\n T: Empty,\n{\n // Note: if length > N, the below `array` access will throw an out of bounds error.\n\n if length != N {\n array[length].assert_empty(\"Expected array[length] to be empty\");\n }\n\n if length != 0 {\n assert(\n !array[length - 1].is_empty(),\n \"Expected claimed final element of array (array[length - 1]) to be nonempty\",\n );\n }\n}\n\n// Returns an array length defined by fully trimming _all_ \"empty\" items\n// from the RHS.\npub unconstrained fn trimmed_array_length_hint<T, let N: u32>(array: [T; N]) -> u32\nwhere\n T: Empty,\n{\n let index_of_last_nonempty = find_last_index(array, |elem: T| !elem.is_empty());\n let length: u32 = if index_of_last_nonempty != N {\n 1 + index_of_last_nonempty\n } else {\n 0\n };\n length\n}\n\n// Returns the number of consecutive elements at the start of the array for which the predicate returns false.\n// This function ensures that any element after the first matching element (predicate returns true) also matches the predicate.\npub fn array_length_until<T, let N: u32, Env>(array: [T; N], predicate: fn[Env](T) -> bool) -> u32 {\n let mut length = 0;\n let mut stop = false;\n for i in 0..N {\n if predicate(array[i]) {\n stop = true;\n } else {\n assert(\n stop == false,\n \"matching element found after already encountering a non-matching element\",\n );\n length += 1;\n }\n }\n length\n}\n\npub fn check_permutation<T, let N: u32>(\n original_array: [T; N],\n permuted_array: [T; N],\n original_indexes: [u32; N],\n)\nwhere\n T: Eq,\n{\n let mut seen_value = [false; N];\n for i in 0..N {\n let index = original_indexes[i];\n let original_value = original_array[index];\n assert(permuted_array[i].eq(original_value), \"Invalid index\");\n assert(!seen_value[index], \"Duplicated index\");\n seen_value[index] = true;\n }\n}\n\n// Helper function to check if an array is padded with a given value from a given index.\npub fn array_padded_with<T, let N: u32>(array: [T; N], from_index: u32, padded_with: T) -> bool\nwhere\n T: Eq,\n{\n let mut is_valid = true;\n let mut should_check = false;\n for i in 0..N {\n should_check |= i == from_index;\n is_valid &= !should_check | (array[i] == padded_with);\n }\n is_valid\n}\n\n// ==================== subarray tests ====================\n\n#[test]\nfn test_subarray() {\n assert_eq(subarray::<_, 5, 3>([10, 20, 30, 40, 50], 1), [20, 30, 40]);\n assert_eq(subarray::<_, 5, 2>([10, 20, 30, 40, 50], 0), [10, 20]);\n assert_eq(subarray::<_, 3, 0>([10, 20, 30], 2), []);\n assert_eq(subarray::<_, 3, 1>([10, 20, 30], 2), [30]);\n}\n\n#[test(should_fail_with = \"out of bounds\")]\nfn test_subarray_offset_out_of_bounds() {\n let _: [Field; 1] = subarray([10, 20, 30], 5);\n}\n\n#[test(should_fail_with = \"out of bounds\")]\nfn test_subarray_result_size_exceeds_available() {\n let _: [Field; 3] = subarray([10, 20, 30, 40, 50], 3);\n}\n\n// ==================== array_length tests ====================\n\n#[test]\nfn test_array_length_empty_array() {\n assert_eq(array_length([0]), 0);\n assert_eq(array_length([0, 0, 0]), 0);\n}\n\n#[test]\nfn test_array_length() {\n assert_eq(array_length([123]), 1);\n assert_eq(array_length([123, 0, 0]), 1);\n assert_eq(array_length([123, 456]), 2);\n assert_eq(array_length([123, 456, 0]), 2);\n}\n\n#[test]\nfn test_array_length_invalid_arrays() {\n // Result can be misleading (but correct) for invalid arrays.\n // This is why the arrays being passed-into `array_length` must already have been \"validated\"\n // (dense lhs, empty rhs).\n assert_eq(array_length([0, 0, 123]), 0);\n assert_eq(array_length([0, 123, 0]), 0);\n assert_eq(array_length([0, 123, 456]), 0);\n assert_eq(array_length([123, 0, 456]), 1);\n}\n\n// ==================== validate_array_length_hint tests ====================\n\n#[test]\nfn test_validate_array_length_hint_valid() {\n validate_array_length_hint([0, 0, 0], 0);\n validate_array_length_hint([10, 20, 0], 2);\n validate_array_length_hint([10, 20, 30], 3);\n}\n\n#[test(should_fail_with = \"Expected array[length] to be empty\")]\nfn test_validate_array_length_hint_claims_zero_when_not_empty() {\n // Invalid: hint says length 0, but first element is not empty\n validate_array_length_hint([10, 20, 30], 0);\n}\n\n#[test(should_fail_with = \"Expected array[length] to be empty\")]\nfn test_validate_array_length_hint_too_short() {\n // Invalid: hint says length 1, but element at index 1 is not empty\n validate_array_length_hint([10, 20, 0], 1);\n}\n\n#[test(should_fail_with = \"Expected claimed final element of array (array[length - 1]) to be nonempty\")]\nfn test_validate_array_length_hint_too_long() {\n // Invalid: hint says length 2, but element at index 1 is empty\n validate_array_length_hint([10, 0, 0], 2);\n}\n\n#[test(should_fail_with = \"Expected claimed final element of array (array[length - 1]) to be nonempty\")]\nfn test_validate_array_length_hint_of_empty_too_long() {\n // Invalid: hint says length 2, but element at index 1 is empty\n validate_array_length_hint([0, 0, 0], 2);\n}\n\n#[test(should_fail_with = \"out of bounds\")]\nfn test_validate_array_length_hint_out_of_bounds() {\n // Invalid: hint says length 4, but array only has 3 elements\n validate_array_length_hint([10, 20, 30], 4);\n}\n\n// ==================== trimmed_array_length_hint tests ====================\n\n#[test]\nunconstrained fn test_trimmed_array_length_hint_with_trailing_empties() {\n assert_eq(trimmed_array_length_hint([10, 20, 30, 0, 0]), 3);\n}\n\n#[test]\nunconstrained fn test_trimmed_array_length_hint_fully_empty() {\n assert_eq(trimmed_array_length_hint([0, 0, 0, 0, 0]), 0);\n}\n\n#[test]\nunconstrained fn test_trimmed_array_length_hint_no_empties() {\n assert_eq(trimmed_array_length_hint([10, 20, 30, 40, 50]), 5);\n}\n\n#[test]\nunconstrained fn test_trimmed_array_length_hint_with_gaps() {\n // Unlike array_length, this trims from the right only, so gaps don't matter\n assert_eq(trimmed_array_length_hint([10, 0, 30, 0, 0]), 3);\n}\n\n// ==================== array_length_until tests ====================\n\n#[test]\nfn test_array_length_until() {\n let array = [11, 22, 33, 44, 55];\n assert_eq(array_length_until(array, |x| x == 55), 4);\n assert_eq(array_length_until(array, |x| x == 56), 5);\n assert_eq(array_length_until(array, |x| x > 40), 3);\n assert_eq(array_length_until(array, |x| x > 10), 0);\n}\n\n#[test(should_fail_with = \"matching element found after already encountering a non-matching element\")]\nfn test_array_length_until_non_consecutive_fails() {\n let array = [1, 1, 0, 1, 0];\n let _ = array_length_until(array, |x| x == 0);\n}\n\n#[test(should_fail_with = \"matching element found after already encountering a non-matching element\")]\nfn test_array_length_until_first_non_matching_fails() {\n let array = [1, 0, 0, 0, 0];\n let _ = array_length_until(array, |x| x == 1);\n}\n\n// ==================== check_permutation tests ====================\n\n#[test]\nfn test_check_permutation() {\n let original_array = [1, 2, 3];\n let permuted_array = [3, 1, 2];\n let indexes = [2, 0, 1];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Duplicated index\")]\nfn test_check_permutation_duplicated_index() {\n let original_array = [0, 1, 0];\n let permuted_array = [1, 0, 0];\n let indexes = [1, 0, 0];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Invalid index\")]\nfn test_check_permutation_invalid_index() {\n let original_array = [0, 1, 2];\n let permuted_array = [1, 0, 0];\n let indexes = [1, 0, 2];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n// ==================== array_padded_with tests ====================\n\n#[test]\nfn test_array_padded_with() {\n let array = [11, 22, 33, 44, 44];\n assert_eq(array_padded_with(array, 0, 44), false);\n assert_eq(array_padded_with(array, 1, 44), false);\n assert_eq(array_padded_with(array, 2, 44), false);\n assert_eq(array_padded_with(array, 3, 44), true);\n assert_eq(array_padded_with(array, 4, 44), true);\n assert_eq(array_padded_with(array, 4, 33), false);\n assert_eq(array_padded_with(array, 5, 44), true); // Index out of bounds.\n assert_eq(array_padded_with(array, 0, 11), false);\n}\n"
|
|
2895
2895
|
},
|
|
2896
2896
|
"446": {
|
|
2897
2897
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/reader.nr",
|
|
@@ -2903,7 +2903,7 @@
|
|
|
2903
2903
|
},
|
|
2904
2904
|
"449": {
|
|
2905
2905
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/type_impls.nr",
|
|
2906
|
-
"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"
|
|
2906
|
+
"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"
|
|
2907
2907
|
},
|
|
2908
2908
|
"5": {
|
|
2909
2909
|
"path": "std/cmp.nr",
|
|
@@ -2911,7 +2911,7 @@
|
|
|
2911
2911
|
},
|
|
2912
2912
|
"51": {
|
|
2913
2913
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/contract_instance_registry_contract/src/main.nr",
|
|
2914
|
-
"source": "/**\n * @title ContractInstanceRegistry Contract\n * @notice Manages the registration and updating of contract instances\n * @dev This contract allows deploying new contract instances and updating their class IDs\n */\npub contract ContractInstanceRegistry {\n use aztec::{\n context::{PrivateContext, PublicContext},\n hash::hash_args,\n nullifier::utils::compute_nullifier_existence_request,\n oracle::{avm, debug_log::debug_log_format, version::assert_compatible_oracle_version},\n protocol::{\n abis::function_selector::FunctionSelector,\n address::{AztecAddress, PartialAddress},\n constants::{\n CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS, CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE, DEFAULT_UPDATE_DELAY, MINIMUM_UPDATE_DELAY,\n },\n contract_class_id::ContractClassId,\n point::validate_on_curve,\n public_keys::PublicKeys,\n traits::{Deserialize, Serialize, ToField},\n utils::reader::Reader,\n },\n state_vars::{DelayedPublicMutable, Map, StateVariable},\n };\n\n #[abi(events)]\n struct ContractInstancePublished {\n CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE: Field,\n address: AztecAddress,\n version: u8,\n salt: Field,\n contract_class_id: ContractClassId,\n initialization_hash: Field,\n public_keys: PublicKeys,\n deployer: AztecAddress,\n }\n\n // We need to impl this separately because ts deserializes a point as two fields only.\n // We had issues that:\n // Notice how the 'is_infinite' field is deserialized as the next point.\n // {\n // masterNullifierPublicKey: Point {\n // x: Fr<0x0000000000000000000000000000000000000000000000000000000000000012>,\n // y: Fr<0x0000000000000000000000000000000000000000000000000000000000000034>,\n // isInfinite: false,\n // kind: 'point'\n // },\n // masterIncomingViewingPublicKey: Point {\n // x: Fr<0x0000000000000000000000000000000000000000000000000000000000000000>,\n // y: Fr<0x0000000000000000000000000000000000000000000000000000000000000056>,\n // isInfinite: false,\n // kind: 'point'\n // },\n // masterOutgoingViewingPublicKey: Point {\n // x: Fr<0x0000000000000000000000000000000000000000000000000000000000000078>,\n // y: Fr<0x0000000000000000000000000000000000000000000000000000000000000000>,\n // isInfinite: false,\n // kind: 'point'\n // },\n // masterTaggingPublicKey: Point {\n // x: Fr<0x0000000000000000000000000000000000000000000000000000000000000910>,\n // y: Fr<0x0000000000000000000000000000000000000000000000000000000000001112>,\n // isInfinite: false,\n // kind: 'point'\n // }\n\n impl ContractInstancePublished {\n fn serialize_non_standard(self) -> [Field; 15] {\n [\n self.CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n self.address.to_field(),\n self.version.to_field(),\n self.salt,\n self.contract_class_id.to_field(),\n self.initialization_hash,\n self.public_keys.npk_m.serialize()[0],\n self.public_keys.npk_m.serialize()[1],\n self.public_keys.ivpk_m.serialize()[0],\n self.public_keys.ivpk_m.serialize()[1],\n self.public_keys.ovpk_m.serialize()[0],\n self.public_keys.ovpk_m.serialize()[1],\n self.public_keys.tpk_m.serialize()[0],\n self.public_keys.tpk_m.serialize()[1],\n self.deployer.to_field(),\n ]\n }\n }\n\n #[abi(events)]\n #[derive(Serialize)]\n struct ContractInstanceUpdated {\n CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE: Field,\n address: AztecAddress,\n prev_contract_class_id: ContractClassId,\n new_contract_class_id: ContractClassId,\n timestamp_of_change: u64,\n }\n\n struct Storage<Context> {\n updated_class_ids: Map<AztecAddress, DelayedPublicMutable<ContractClassId, DEFAULT_UPDATE_DELAY, Context>, Context>,\n }\n\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_private]\n fn publish_for_public_execution(\n inputs: aztec::context::inputs::PrivateContextInputs,\n salt: Field,\n contract_class_id: ContractClassId,\n initialization_hash: Field,\n public_keys: PublicKeys,\n universal_deploy: bool,\n ) -> return_data aztec::protocol::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {\n // MACRO CODE START\n // Note: The macros initially inserted a phase check here, but since there is no phase change in this function\n // body, I have removed that check.\n assert_compatible_oracle_version();\n\n let serialized_params: [Field; 16] = [\n salt,\n contract_class_id.to_field(),\n initialization_hash,\n ]\n .concat(public_keys.serialize())\n .concat([universal_deploy.to_field()]);\n\n let args_hash: Field = hash_args(serialized_params);\n let mut context: PrivateContext = PrivateContext::new(inputs, args_hash);\n // MACRO CODE END\n\n // Verify that the contract class is registered\n let nullifier_existence_request = compute_nullifier_existence_request(\n contract_class_id.to_field(),\n CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,\n );\n context.assert_nullifier_exists(nullifier_existence_request);\n\n // Determine the deployer based on universal_deploy flag\n let deployer = if universal_deploy {\n AztecAddress::zero()\n } else {\n context.maybe_msg_sender().unwrap()\n };\n\n let partial_address =\n PartialAddress::compute(contract_class_id, salt, initialization_hash, deployer);\n\n // Note: Out of all the public keys, only the Ivpk_m is checked to be on the curve\n // (implicitly as part of the `add` operation of deriving the address). This at least\n // protects the AVM against DoS attacks.\n // For thoroughness, we also ensure the other points are on the curve:\n validate_on_curve(public_keys.npk_m.inner);\n validate_on_curve(public_keys.ovpk_m.inner);\n validate_on_curve(public_keys.tpk_m.inner);\n\n let address = AztecAddress::compute(public_keys, partial_address);\n\n // Emit the address as a nullifier:\n // - to demonstrate that this contract instance hasn't been published before\n // - to enable apps to read that this contract instance has been published.\n context.push_nullifier(address.to_field());\n\n // Emit the deployment event\n let event = ContractInstancePublished {\n CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n contract_class_id,\n address,\n public_keys,\n initialization_hash,\n salt,\n deployer,\n version: 1,\n };\n let payload = event.serialize_non_standard();\n debug_log_format(\"ContractInstancePublished: {}\", payload);\n let padded_log = payload.concat([0; 3]);\n let length = payload.len();\n context.emit_private_log(padded_log, length);\n\n // MACRO CODE START\n context.finish()\n // MACRO CODE END\n }\n\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n unconstrained fn update(new_contract_class_id: ContractClassId) {\n // MACRO CODE START\n let context: PublicContext = PublicContext::new(\n || -> Field {\n let serialized_args: [Field; 1] =\n avm::calldata_copy(1, <ContractClassId as Serialize>::N);\n hash_args(serialized_args)\n },\n );\n let storage: Storage<PublicContext> = Storage::init(context);\n // MACRO CODE END\n\n let address = context.maybe_msg_sender().unwrap();\n\n // Safety: we're using the nullifier's existence as a guarantee of the availability of the contract's\n // information through publishing, which is safe - we just need this information to be _eventually_ available.\n assert(\n context.nullifier_exists_unsafe(address.to_field(), context.this_address()),\n \"msg.sender is not deployed\",\n );\n\n // Safety: we're using the nullifier's existence as a guarantee of the availability of the new contract class'\n // information through registration, which is safe - we just need this information to be _eventually_ available.\n assert(\n context.nullifier_exists_unsafe(\n new_contract_class_id.to_field(),\n CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,\n ),\n \"New contract class is not registered\",\n );\n\n let scheduled_value_update = storage\n .updated_class_ids\n .at(address)\n .schedule_and_return_value_change(new_contract_class_id);\n let (prev_contract_class_id, timestamp_of_change) = scheduled_value_update.get_previous();\n\n let event = ContractInstanceUpdated {\n CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE,\n address,\n prev_contract_class_id,\n new_contract_class_id,\n timestamp_of_change,\n };\n context.emit_public_log(event);\n }\n\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n unconstrained fn set_update_delay(new_update_delay: u64) {\n // MACRO CODE START\n let context: PublicContext = PublicContext::new(\n || -> Field {\n let serialized_args: [Field; 1] = avm::calldata_copy(1, <u64 as Serialize>::N);\n hash_args(serialized_args)\n },\n );\n let storage: Storage<PublicContext> = Storage::init(context);\n // MACRO CODE END\n\n let msg_sender = context.maybe_msg_sender().unwrap();\n\n // Safety: we're using the nullifier's existence as a guarantee of the availability of the contract's\n // information through publishing, which is safe - we just need this information to be _eventually_ available.\n assert(\n context.nullifier_exists_unsafe(msg_sender.to_field(), context.this_address()),\n \"msg.sender is not deployed\",\n );\n\n assert(new_update_delay >= MINIMUM_UPDATE_DELAY, \"New update delay is too low\");\n\n storage.updated_class_ids.at(msg_sender).schedule_delay_change(new_update_delay);\n }\n\n /**\n * Gets the current update delay for the caller's contract instance.\n *\n * @return The current update delay value\n */\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_view]\n unconstrained fn get_update_delay() -> pub u64 {\n // MACRO CODE START\n let context: PublicContext = PublicContext::new(\n || -> Field {\n let serialized_args: [Field; 0] = avm::calldata_copy(1, 0);\n hash_args(serialized_args)\n },\n );\n let storage: Storage<PublicContext> = Storage::init(context);\n assert(context.is_static_call(), \"Function get_update_delay can only be called statically\");\n // MACRO CODE END\n\n storage.updated_class_ids.at(avm::sender()).get_current_delay()\n }\n\n // // THE REST OF THE CODE IN THIS CONTRACT WAS ORIGINALLY INJECTED BY THE #[aztec] MACRO.\n\n // Function selectors computed at comptime from function signatures\n global UPDATE_SELECTOR: Field =\n comptime { FunctionSelector::from_signature(\"update((Field))\").to_field() };\n global SET_UPDATE_DELAY_SELECTOR: Field =\n comptime { FunctionSelector::from_signature(\"set_update_delay(u64)\").to_field() };\n global GET_UPDATE_DELAY_SELECTOR: Field =\n comptime { FunctionSelector::from_signature(\"get_update_delay()\").to_field() };\n\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n pub unconstrained fn public_dispatch(selector: Field) {\n if selector == UPDATE_SELECTOR {\n let input_calldata: [Field; 1] =\n avm::calldata_copy(1, <ContractClassId as Serialize>::N);\n let mut reader: Reader<1> = Reader::new(input_calldata);\n let arg0: ContractClassId =\n <ContractClassId as Deserialize>::stream_deserialize(&mut reader);\n update(arg0);\n avm::avm_return([].as_vector());\n };\n if selector == SET_UPDATE_DELAY_SELECTOR {\n let input_calldata: [Field; 1] = avm::calldata_copy(1, <u64 as Serialize>::N);\n let mut reader: Reader<1> = Reader::new(input_calldata);\n let arg0: u64 = <u64 as Deserialize>::stream_deserialize(&mut reader);\n set_update_delay(arg0);\n avm::avm_return([].as_vector());\n };\n if selector == GET_UPDATE_DELAY_SELECTOR {\n let return_value: [Field; 1] = <u64 as Serialize>::serialize(get_update_delay());\n avm::avm_return(return_value.as_vector());\n };\n panic(f\"Unknown selector {selector}\")\n }\n\n // THE REST OF THE CODE IN THIS CONTRACT WAS ORIGINALLY INJECTED BY THE #[aztec] MACRO.\n\n impl<Context> Storage<Context> {\n fn init(context: Context) -> Self {\n Self {\n updated_class_ids: <Map<AztecAddress, DelayedPublicMutable<ContractClassId, DEFAULT_UPDATE_DELAY, Context>, Context> as StateVariable<1, Context>>::new(\n context,\n 1,\n ),\n }\n }\n }\n\n // Parameter structs for ABI\n pub struct publish_for_public_execution_parameters {\n pub _salt: Field,\n pub _contract_class_id: ContractClassId,\n pub _initialization_hash: Field,\n pub _public_keys: PublicKeys,\n pub _universal_deploy: bool,\n }\n\n pub struct update_parameters {\n pub _new_contract_class_id: ContractClassId,\n }\n\n pub struct set_update_delay_parameters {\n pub _new_update_delay: u64,\n }\n\n pub struct get_update_delay_parameters {}\n\n // ABI structs\n #[abi(functions)]\n pub struct publish_for_public_execution_abi {\n parameters: publish_for_public_execution_parameters,\n }\n\n #[abi(functions)]\n pub struct update_abi {\n parameters: update_parameters,\n }\n\n #[abi(functions)]\n pub struct set_update_delay_abi {\n parameters: set_update_delay_parameters,\n }\n\n #[abi(functions)]\n pub struct get_update_delay_abi {\n parameters: get_update_delay_parameters,\n return_type: u64,\n }\n}\n"
|
|
2914
|
+
"source": "/**\n * @title ContractInstanceRegistry Contract\n * @notice Manages the registration and updating of contract instances\n * @dev This contract allows deploying new contract instances and updating their class IDs\n */\npub contract ContractInstanceRegistry {\n use aztec::{\n context::{PrivateContext, PublicContext},\n hash::hash_args,\n nullifier::utils::compute_nullifier_existence_request,\n oracle::{avm, logging::debug_log_format, version::assert_compatible_oracle_version},\n protocol::{\n abis::function_selector::FunctionSelector,\n address::{AztecAddress, PartialAddress},\n constants::{\n CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS, CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE, DEFAULT_UPDATE_DELAY, MINIMUM_UPDATE_DELAY,\n },\n contract_class_id::ContractClassId,\n point::validate_on_curve,\n public_keys::PublicKeys,\n traits::{Deserialize, Serialize, ToField},\n utils::reader::Reader,\n },\n state_vars::{DelayedPublicMutable, Map, StateVariable},\n };\n\n #[abi(events)]\n struct ContractInstancePublished {\n CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE: Field,\n address: AztecAddress,\n version: u8,\n salt: Field,\n contract_class_id: ContractClassId,\n initialization_hash: Field,\n public_keys: PublicKeys,\n deployer: AztecAddress,\n }\n\n // We need to impl this separately because ts deserializes a point as two fields only.\n // We had issues that:\n // Notice how the 'is_infinite' field is deserialized as the next point.\n // {\n // masterNullifierPublicKey: Point {\n // x: Fr<0x0000000000000000000000000000000000000000000000000000000000000012>,\n // y: Fr<0x0000000000000000000000000000000000000000000000000000000000000034>,\n // isInfinite: false,\n // kind: 'point'\n // },\n // masterIncomingViewingPublicKey: Point {\n // x: Fr<0x0000000000000000000000000000000000000000000000000000000000000000>,\n // y: Fr<0x0000000000000000000000000000000000000000000000000000000000000056>,\n // isInfinite: false,\n // kind: 'point'\n // },\n // masterOutgoingViewingPublicKey: Point {\n // x: Fr<0x0000000000000000000000000000000000000000000000000000000000000078>,\n // y: Fr<0x0000000000000000000000000000000000000000000000000000000000000000>,\n // isInfinite: false,\n // kind: 'point'\n // },\n // masterTaggingPublicKey: Point {\n // x: Fr<0x0000000000000000000000000000000000000000000000000000000000000910>,\n // y: Fr<0x0000000000000000000000000000000000000000000000000000000000001112>,\n // isInfinite: false,\n // kind: 'point'\n // }\n\n impl ContractInstancePublished {\n fn serialize_non_standard(self) -> [Field; 15] {\n [\n self.CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n self.address.to_field(),\n self.version.to_field(),\n self.salt,\n self.contract_class_id.to_field(),\n self.initialization_hash,\n self.public_keys.npk_m.serialize()[0],\n self.public_keys.npk_m.serialize()[1],\n self.public_keys.ivpk_m.serialize()[0],\n self.public_keys.ivpk_m.serialize()[1],\n self.public_keys.ovpk_m.serialize()[0],\n self.public_keys.ovpk_m.serialize()[1],\n self.public_keys.tpk_m.serialize()[0],\n self.public_keys.tpk_m.serialize()[1],\n self.deployer.to_field(),\n ]\n }\n }\n\n #[abi(events)]\n #[derive(Serialize)]\n struct ContractInstanceUpdated {\n CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE: Field,\n address: AztecAddress,\n prev_contract_class_id: ContractClassId,\n new_contract_class_id: ContractClassId,\n timestamp_of_change: u64,\n }\n\n struct Storage<Context> {\n updated_class_ids: Map<AztecAddress, DelayedPublicMutable<ContractClassId, DEFAULT_UPDATE_DELAY, Context>, Context>,\n }\n\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_private]\n fn publish_for_public_execution(\n inputs: aztec::context::inputs::PrivateContextInputs,\n salt: Field,\n contract_class_id: ContractClassId,\n initialization_hash: Field,\n public_keys: PublicKeys,\n universal_deploy: bool,\n ) -> return_data aztec::protocol::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {\n // MACRO CODE START\n // Note: The macros initially inserted a phase check here, but since there is no phase change in this function\n // body, I have removed that check.\n assert_compatible_oracle_version();\n\n let serialized_params: [Field; 16] = [\n salt,\n contract_class_id.to_field(),\n initialization_hash,\n ]\n .concat(public_keys.serialize())\n .concat([universal_deploy.to_field()]);\n\n let args_hash: Field = hash_args(serialized_params);\n let mut context: PrivateContext = PrivateContext::new(inputs, args_hash);\n // MACRO CODE END\n\n // Verify that the contract class is registered\n let nullifier_existence_request = compute_nullifier_existence_request(\n contract_class_id.to_field(),\n CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,\n );\n context.assert_nullifier_exists(nullifier_existence_request);\n\n // Determine the deployer based on universal_deploy flag\n let deployer = if universal_deploy {\n AztecAddress::zero()\n } else {\n context.maybe_msg_sender().unwrap()\n };\n\n let partial_address =\n PartialAddress::compute(contract_class_id, salt, initialization_hash, deployer);\n\n // Note: Out of all the public keys, only the Ivpk_m is checked to be on the curve\n // (implicitly as part of the `add` operation of deriving the address). This at least\n // protects the AVM against DoS attacks.\n // For thoroughness, we also ensure the other points are on the curve:\n validate_on_curve(public_keys.npk_m.inner);\n validate_on_curve(public_keys.ovpk_m.inner);\n validate_on_curve(public_keys.tpk_m.inner);\n\n let address = AztecAddress::compute(public_keys, partial_address);\n\n // Emit the address as a nullifier:\n // - to demonstrate that this contract instance hasn't been published before\n // - to enable apps to read that this contract instance has been published.\n context.push_nullifier(address.to_field());\n\n // Emit the deployment event\n let event = ContractInstancePublished {\n CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n contract_class_id,\n address,\n public_keys,\n initialization_hash,\n salt,\n deployer,\n version: 1,\n };\n let payload = event.serialize_non_standard();\n debug_log_format(\"ContractInstancePublished: {}\", payload);\n let padded_log = payload.concat([0; 3]);\n let length = payload.len();\n context.emit_private_log(padded_log, length);\n\n // MACRO CODE START\n context.finish()\n // MACRO CODE END\n }\n\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n unconstrained fn update(new_contract_class_id: ContractClassId) {\n // MACRO CODE START\n let context: PublicContext = PublicContext::new(\n || -> Field {\n let serialized_args: [Field; 1] =\n avm::calldata_copy(1, <ContractClassId as Serialize>::N);\n hash_args(serialized_args)\n },\n );\n let storage: Storage<PublicContext> = Storage::init(context);\n // MACRO CODE END\n\n let address = context.maybe_msg_sender().unwrap();\n\n // Safety: we're using the nullifier's existence as a guarantee of the availability of the contract's\n // information through publishing, which is safe - we just need this information to be _eventually_ available.\n assert(\n context.nullifier_exists_unsafe(address.to_field(), context.this_address()),\n \"msg.sender is not deployed\",\n );\n\n // Safety: we're using the nullifier's existence as a guarantee of the availability of the new contract class'\n // information through registration, which is safe - we just need this information to be _eventually_ available.\n assert(\n context.nullifier_exists_unsafe(\n new_contract_class_id.to_field(),\n CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,\n ),\n \"New contract class is not registered\",\n );\n\n let scheduled_value_update = storage\n .updated_class_ids\n .at(address)\n .schedule_and_return_value_change(new_contract_class_id);\n let (prev_contract_class_id, timestamp_of_change) = scheduled_value_update.get_previous();\n\n let event = ContractInstanceUpdated {\n CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE,\n address,\n prev_contract_class_id,\n new_contract_class_id,\n timestamp_of_change,\n };\n context.emit_public_log(event);\n }\n\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n unconstrained fn set_update_delay(new_update_delay: u64) {\n // MACRO CODE START\n let context: PublicContext = PublicContext::new(\n || -> Field {\n let serialized_args: [Field; 1] = avm::calldata_copy(1, <u64 as Serialize>::N);\n hash_args(serialized_args)\n },\n );\n let storage: Storage<PublicContext> = Storage::init(context);\n // MACRO CODE END\n\n let msg_sender = context.maybe_msg_sender().unwrap();\n\n // Safety: we're using the nullifier's existence as a guarantee of the availability of the contract's\n // information through publishing, which is safe - we just need this information to be _eventually_ available.\n assert(\n context.nullifier_exists_unsafe(msg_sender.to_field(), context.this_address()),\n \"msg.sender is not deployed\",\n );\n\n assert(new_update_delay >= MINIMUM_UPDATE_DELAY, \"New update delay is too low\");\n\n storage.updated_class_ids.at(msg_sender).schedule_delay_change(new_update_delay);\n }\n\n /**\n * Gets the current update delay for the caller's contract instance.\n *\n * @return The current update delay value\n */\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_view]\n unconstrained fn get_update_delay() -> pub u64 {\n // MACRO CODE START\n let context: PublicContext = PublicContext::new(\n || -> Field {\n let serialized_args: [Field; 0] = avm::calldata_copy(1, 0);\n hash_args(serialized_args)\n },\n );\n let storage: Storage<PublicContext> = Storage::init(context);\n assert(context.is_static_call(), \"Function get_update_delay can only be called statically\");\n // MACRO CODE END\n\n storage.updated_class_ids.at(avm::sender()).get_current_delay()\n }\n\n // // THE REST OF THE CODE IN THIS CONTRACT WAS ORIGINALLY INJECTED BY THE #[aztec] MACRO.\n\n // Function selectors computed at comptime from function signatures\n global UPDATE_SELECTOR: Field =\n comptime { FunctionSelector::from_signature(\"update((Field))\").to_field() };\n global SET_UPDATE_DELAY_SELECTOR: Field =\n comptime { FunctionSelector::from_signature(\"set_update_delay(u64)\").to_field() };\n global GET_UPDATE_DELAY_SELECTOR: Field =\n comptime { FunctionSelector::from_signature(\"get_update_delay()\").to_field() };\n\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n pub unconstrained fn public_dispatch(selector: Field) {\n if selector == UPDATE_SELECTOR {\n let input_calldata: [Field; 1] =\n avm::calldata_copy(1, <ContractClassId as Serialize>::N);\n let mut reader: Reader<1> = Reader::new(input_calldata);\n let arg0: ContractClassId =\n <ContractClassId as Deserialize>::stream_deserialize(&mut reader);\n update(arg0);\n avm::avm_return([].as_vector());\n };\n if selector == SET_UPDATE_DELAY_SELECTOR {\n let input_calldata: [Field; 1] = avm::calldata_copy(1, <u64 as Serialize>::N);\n let mut reader: Reader<1> = Reader::new(input_calldata);\n let arg0: u64 = <u64 as Deserialize>::stream_deserialize(&mut reader);\n set_update_delay(arg0);\n avm::avm_return([].as_vector());\n };\n if selector == GET_UPDATE_DELAY_SELECTOR {\n let return_value: [Field; 1] = <u64 as Serialize>::serialize(get_update_delay());\n avm::avm_return(return_value.as_vector());\n };\n panic(f\"Unknown selector {selector}\")\n }\n\n // THE REST OF THE CODE IN THIS CONTRACT WAS ORIGINALLY INJECTED BY THE #[aztec] MACRO.\n\n impl<Context> Storage<Context> {\n fn init(context: Context) -> Self {\n Self {\n updated_class_ids: <Map<AztecAddress, DelayedPublicMutable<ContractClassId, DEFAULT_UPDATE_DELAY, Context>, Context> as StateVariable<1, Context>>::new(\n context,\n 1,\n ),\n }\n }\n }\n\n // Parameter structs for ABI\n pub struct publish_for_public_execution_parameters {\n pub _salt: Field,\n pub _contract_class_id: ContractClassId,\n pub _initialization_hash: Field,\n pub _public_keys: PublicKeys,\n pub _universal_deploy: bool,\n }\n\n pub struct update_parameters {\n pub _new_contract_class_id: ContractClassId,\n }\n\n pub struct set_update_delay_parameters {\n pub _new_update_delay: u64,\n }\n\n pub struct get_update_delay_parameters {}\n\n // ABI structs\n #[abi(functions)]\n pub struct publish_for_public_execution_abi {\n parameters: publish_for_public_execution_parameters,\n }\n\n #[abi(functions)]\n pub struct update_abi {\n parameters: update_parameters,\n }\n\n #[abi(functions)]\n pub struct set_update_delay_abi {\n parameters: set_update_delay_parameters,\n }\n\n #[abi(functions)]\n pub struct get_update_delay_abi {\n parameters: get_update_delay_parameters,\n return_type: u64,\n }\n}\n"
|
|
2915
2915
|
},
|
|
2916
2916
|
"58": {
|
|
2917
2917
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/context/private_context.nr",
|