@aztec/protocol-contracts 0.0.1-commit.43597cc1 → 0.0.1-commit.4d79d1f2d
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 +14 -14
- package/artifacts/ContractClassRegistry.json +26 -4008
- package/artifacts/ContractInstanceRegistry.json +21 -21
- package/artifacts/FeeJuice.json +11 -11
- package/artifacts/MultiCallEntrypoint.json +20 -20
- package/artifacts/PublicChecks.json +19 -19
- package/dest/protocol_contract_data.js +13 -13
- package/package.json +4 -4
- package/src/protocol_contract_data.ts +13 -13
|
@@ -36,7 +36,7 @@
|
|
|
36
36
|
}
|
|
37
37
|
},
|
|
38
38
|
"bytecode": "JwACBAEoAAABBIBFJwAABEUlAAAAQScCAQQAJwICBAAfCgABAAIARCUAAABCLQIBRCcCAgREJwIDBAE7DgADAAImJQAAAnUeAgACCScCAwEBJAIAAgAAAF4lAAACmx4CAAIBKQIAAwDvUlNNJwIEAAErAgAFAAAAAAAAAAADAAAAAAAAAAAtCAEGJwIHBAUACAEHAScDBgQBACIGAgctCgcILQ4DCAAiCAIILQ4ECAAiCAIILQ4CCAAiCAIILQ4FCC0LBgIAIgICAi0OAgYtCAECJwIDBAUACAEDAScDAgQBACIGAgMAIgICBD8PAAMABCcCAwQBACoCAwUtCwUEJwICAAAKKgQCAycCAgEACioDAgUkAgAFAAABICUAAAKtHgIAAgYeAgADAC8qAAQAAwAFHAoFBAQcCgQDAAIqBQMELAIAAwAtXgmLgro3tDuZoTFhGP0g1C9RZsnp8T+16mWpbR4KbQQqBAMFHAoFBgQcCgYEAAIqBQQGBCoGAwUcCgUHARwKBwYAHAoGBwECKgUGCCwCAAUAMDPqJG5QbomOl/Vwyv/XBMsLtGAxP7cgsp4TnlwQAAEEKggFCRwKCQoEHAoKCAACKgkICgQqCgMJHAoJCgEcCgoDABwKAwoBAioJAwsEKgsFCRwKCQsEHAoLBQAcCgUJBRYKCgUcCgMKBRwKBQMFBCoKCQUcCggJBRYKBwgcCgYHBRwKCAYFBCoHCQgcCgQJBQwqAgkEKQIAAgUAAVGAJAIABAAAAlwjAAACRAQqBwgDBCoGAgQAKgMEAi0KAgEjAAACdAQqCgUEBCoDAgUAKgQFAi0KAgEjAAACdCYoAAAEBHhFDAAABAMkAAADAAACmioBAAEF2sX11rRKMm08BAIBJioBAAEFT99KitfP8NM8BAIBJioBAAEFursh14IzGGQ8BAIBJg==",
|
|
39
|
-
"debug_symbols": "
|
|
39
|
+
"debug_symbols": "nZjbbtswDIbfxde5kEjqwLzKUBRp6w4BgrTIkgFDkXcfmZiSU0DCppv49+/4MylR9OFreptfLj+f98f3j1/T9sfX9HLaHw77n8+Hj9fdef9xFPdrcvqT/LTFzZTitKXNlP19w7cN07SNspE9L//xLi/C4yKQTNghskNkTjAnmBPBRFyERnEXYRHZmbBLZAuDDcjpLsCBCQUGEd6ZCIsAc8AcNAfNIQ0jqoiLCOYE/U8WEZ0Jc5I5yZyMJiRlABEaM6jD4qDbTKihohxC702oI1kgqCPjjzpiNxHldAwq8iKSOlGFOkmEXhSzirwINud2Ud5M5MQhuTqRMyExkxcRnAl1JB7STAlVqCNhkGZ6F+boNFFQoY7EQ6xOUhHuIjh1sorlrOB4cTyZMAfUYRV8Dz4gLo7W2E2QOVpjQbIIWmMBrtfNZBX+fD7Nsxb4quRlIXzuTvPxPG2Pl8NhM/3eHS63P/363B1v2/PuJEcFOR/fZCvA9/1hVnXd1LNd+1TvgXk5XdYJ+III/oHh2wyOEBcER0qVwA8E6EThMpUgXCUkGM0DW3l0GUSVQRFajNBmYCFgpKE8CFyNgXIrhtRhgJb4HQEcCiHTAyG3CZAtBlmL5Xzy8QHAvTS8LzGIrEOJOT3WleuWRUCjOHauTemUJwYoydTSks72SOiUJ/icFwR4jmOMOikgDbfNoDaDEhuDMtYx9fzPYSBzndrV3H4Po1devq40uS20ysv3EM4XhMMVAgfXSW73rU6VSssopeE8tcKAThxZ7i0LIhP7Zu/r1Gcsw5l8s/X10kBX+i+6Vcf4ngZ2EAnLSKSQmgjqzSmEWCYVUvs+EHoQp3WzQBxSExI7A1qXa5RnrSaiU6CQyoLnZhvvJcKcoOaxbuPfgujNayDrfhg6YXTnNZfSyMCteUXfWyRQGhdjTQQT/wcjlq4jMzzICFwXaxhioAu+MKIfZJQVL8/COMqgwoA0xvAhFUaMg4xaHuBH48hlPOQdZYwBNReIg3FALnOLfjSO+uCDQGMMLM8siKtnyP9j5NKOyQ8zyngQDK4XquuFRtdLQqq3lsExzaWbYubBNcfJ+gc5x03GP99pV3P7rZ2GXhuTu5q1U7d6WZIZv16fZHf3uj89fPi4Kuy0370c5mX3/XJ8XR09//m0I/bh5PP08Tq/XU6zkurXE/3M8EOepDfyyPSkH0Z0V978Pbinq17+Lw=="
|
|
40
40
|
},
|
|
41
41
|
{
|
|
42
42
|
"name": "public_dispatch",
|
|
@@ -108,7 +108,7 @@
|
|
|
108
108
|
}
|
|
109
109
|
},
|
|
110
110
|
"bytecode": "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",
|
|
111
|
-
"debug_symbols": "
|
|
111
|
+
"debug_symbols": "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"
|
|
112
112
|
},
|
|
113
113
|
{
|
|
114
114
|
"name": "publish_for_public_execution",
|
|
@@ -2094,9 +2094,9 @@
|
|
|
2094
2094
|
}
|
|
2095
2095
|
}
|
|
2096
2096
|
},
|
|
2097
|
-
"bytecode": "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",
|
|
2098
|
-
"debug_symbols": "
|
|
2099
|
-
"verification_key": "
|
|
2097
|
+
"bytecode": "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",
|
|
2098
|
+
"debug_symbols": "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",
|
|
2099
|
+
"verification_key": "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"
|
|
2100
2100
|
},
|
|
2101
2101
|
{
|
|
2102
2102
|
"name": "set_update_delay",
|
|
@@ -2153,7 +2153,7 @@
|
|
|
2153
2153
|
}
|
|
2154
2154
|
},
|
|
2155
2155
|
"bytecode": "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",
|
|
2156
|
-
"debug_symbols": "
|
|
2156
|
+
"debug_symbols": "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"
|
|
2157
2157
|
},
|
|
2158
2158
|
{
|
|
2159
2159
|
"name": "update",
|
|
@@ -2217,7 +2217,7 @@
|
|
|
2217
2217
|
}
|
|
2218
2218
|
},
|
|
2219
2219
|
"bytecode": "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",
|
|
2220
|
-
"debug_symbols": "
|
|
2220
|
+
"debug_symbols": "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"
|
|
2221
2221
|
}
|
|
2222
2222
|
],
|
|
2223
2223
|
"outputs": {
|
|
@@ -2823,7 +2823,7 @@
|
|
|
2823
2823
|
},
|
|
2824
2824
|
"230": {
|
|
2825
2825
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/version.nr",
|
|
2826
|
-
"source": "/// The ORACLE_VERSION constant is used to check that the oracle interface is in sync between PXE and Aztec.nr. We need\n/// to version the oracle interface to ensure that developers get a reasonable error message if they use incompatible\n/// versions of Aztec.nr and PXE. The TypeScript counterpart is in `oracle_version.ts`.\n///\n/// @dev Whenever a contract function or Noir test is run, the `utilityAssertCompatibleOracleVersion` oracle is called\n/// and if the oracle version is incompatible an error is thrown.\npub global ORACLE_VERSION: Field =
|
|
2826
|
+
"source": "/// The ORACLE_VERSION constant is used to check that the oracle interface is in sync between PXE and Aztec.nr. We need\n/// to version the oracle interface to ensure that developers get a reasonable error message if they use incompatible\n/// versions of Aztec.nr and PXE. The TypeScript counterpart is in `oracle_version.ts`.\n///\n/// @dev Whenever a contract function or Noir test is run, the `utilityAssertCompatibleOracleVersion` oracle is called\n/// and if the oracle version is incompatible an error is thrown.\npub global ORACLE_VERSION: Field = 12;\n\n/// Asserts that the version of the oracle is compatible with the version expected by the contract.\npub fn assert_compatible_oracle_version() {\n // Safety: This oracle call returns nothing: we only call it to check Aztec.nr and Oracle interface versions are\n // compatible. It is therefore always safe to call.\n unsafe {\n assert_compatible_oracle_version_wrapper();\n }\n}\n\nunconstrained fn assert_compatible_oracle_version_wrapper() {\n assert_compatible_oracle_version_oracle(ORACLE_VERSION);\n}\n\n#[oracle(utilityAssertCompatibleOracleVersion)]\nunconstrained fn assert_compatible_oracle_version_oracle(version: Field) {}\n\nmod test {\n use super::{assert_compatible_oracle_version_oracle, ORACLE_VERSION};\n\n #[test]\n unconstrained fn compatible_oracle_version() {\n assert_compatible_oracle_version_oracle(ORACLE_VERSION);\n }\n\n #[test(should_fail_with = \"Incompatible oracle version. TXE is using version\")]\n unconstrained fn incompatible_oracle_version() {\n let arbitrary_incorrect_version = 318183437;\n assert_compatible_oracle_version_oracle(arbitrary_incorrect_version);\n }\n}\n"
|
|
2827
2827
|
},
|
|
2828
2828
|
"298": {
|
|
2829
2829
|
"path": "/home/aztec-dev/nargo/github.com/noir-lang/poseidon/v0.2.3/src/poseidon2.nr",
|
|
@@ -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 ::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"
|
|
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,33 +2845,33 @@
|
|
|
2845
2845
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/salted_initialization_hash.nr",
|
|
2846
2846
|
"source": "use crate::{\n address::aztec_address::AztecAddress, constants::DOM_SEP__PARTIAL_ADDRESS,\n hash::poseidon2_hash_with_separator, traits::ToField,\n};\n\n// Salted initialization hash. Used in the computation of a partial address.\n#[derive(Eq)]\npub struct SaltedInitializationHash {\n pub inner: Field,\n}\n\nimpl ToField for SaltedInitializationHash {\n fn to_field(self) -> Field {\n self.inner\n }\n}\n\nimpl SaltedInitializationHash {\n pub fn from_field(field: Field) -> Self {\n Self { inner: field }\n }\n\n pub fn compute(salt: Field, initialization_hash: Field, deployer: AztecAddress) -> Self {\n SaltedInitializationHash::from_field(poseidon2_hash_with_separator(\n [salt, initialization_hash, deployer.to_field()],\n DOM_SEP__PARTIAL_ADDRESS,\n ))\n }\n\n pub fn assert_is_zero(self) {\n assert(self.to_field() == 0);\n }\n}\n"
|
|
2847
2847
|
},
|
|
2848
|
-
"
|
|
2849
|
-
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
|
|
2850
|
-
"source": "// TODO: Expose other wrapped functions than debug (info, warn)\n// ['silent', 'fatal', 'error', 'warn', 'info', 'verbose', 'debug', 'trace']\n\npub global SILENT_LOG_LEVEL: u8 = 0;\npub global FATAL_LOG_LEVEL: u8 = 1;\npub global ERROR_LOG_LEVEL: u8 = 2;\npub global WARN_LOG_LEVEL: u8 = 3;\npub global INFO_LOG_LEVEL: u8 = 4;\npub global VERBOSE_LOG_LEVEL: u8 = 5;\npub global DEBUG_LOG_LEVEL: u8 = 6;\npub global TRACE_LOG_LEVEL: u8 = 7;\n\n/// Utility function to console.log data in the acir simulator.\n/// Example:\n/// debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n debug_log_format(msg, []);\n}\n\n/// Same as debug_log, but allows to customize the log level.\n/// Consider changing just to 'log'\npub fn debug_log_with_level<let N: u32>(log_level: u8, msg: str<N>) {\n debug_log_format_with_level(log_level, msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n/// debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n/// debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { debug_log_array_oracle_wrapper(DEBUG_LOG_LEVEL, msg, args) };\n}\n\n/// Same as debug_log_format, but allows to customize the log level.\n/// Consider changing just to 'log_format'\npub fn debug_log_format_with_level<let M: u32, let N: u32>(\n log_level: u8,\n msg: str<M>,\n args: [Field; N],\n) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { debug_log_array_oracle_wrapper(log_level, msg, args) };\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` slice.\n/// Examples:\n/// debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n/// debug_log_format(\"whole slice: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format_slice<let M: u32>(log_level: u8, msg: str<M>, args: [Field]) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { debug_log_slice_oracle_wrapper(log_level, msg, args) };\n}\n\n// We provide two versions of the debug log oracle: one that takes args as a slice and another one that takes args as an array.\n// We do this since conversion from array to slice generates overhead in public functions, since opcodes need to be emitted for the conversion.\n// By exposing the two flavors, we avoid conversions since the AVM is able to handle both arrays an slices in this oracle.\n\nunconstrained fn debug_log_slice_oracle_wrapper<let M: u32>(\n log_level: u8,\n msg: str<M>,\n args: [Field],\n) {\n debug_log_slice_oracle(log_level, msg, args);\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(utilityDebugLog)]\nunconstrained fn debug_log_slice_oracle<let M: u32>(log_level: u8, msg: str<M>, args: [Field]) {}\n\nunconstrained fn debug_log_array_oracle_wrapper<let M: u32, let N: u32>(\n log_level: u8,\n msg: str<M>,\n args: [Field; N],\n) {\n debug_log_array_oracle(log_level, msg, N, args);\n}\n\n#[oracle(utilityDebugLog)]\nunconstrained fn debug_log_array_oracle<let M: u32, let N: u32>(\n log_level: u8,\n msg: str<M>,\n length: u32,\n args: [Field; N],\n) {}\n"
|
|
2851
|
-
},
|
|
2852
|
-
"380": {
|
|
2848
|
+
"379": {
|
|
2853
2849
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/delayed_public_mutable/delayed_public_mutable_values.nr",
|
|
2854
2850
|
"source": "use crate::{\n delayed_public_mutable::{\n scheduled_delay_change::ScheduledDelayChange, scheduled_value_change::ScheduledValueChange,\n },\n hash::poseidon2_hash,\n traits::{Hash, Packable},\n utils::arrays,\n};\nuse std::meta::derive;\n\nmod test;\n\n/// DelayedPublicMutableValues is just a wrapper around ScheduledValueChange and ScheduledDelayChange that then allows us\n/// to wrap both of these values in WithHash. WithHash allows for efficient read of values in private.\n///\n/// Note that the WithHash optimization does not work in public (due to there being no unconstrained). But we also want\n/// to be able to read the values efficiently in public and we want to be able to read each value separately. Reading\n/// the values separately is tricky because ScheduledValueChange and ScheduledDelayChange are packed together (sdc and\n/// svc.timestamp_of_change are stored in the same slot). For that reason we expose `unpack_value_change` and\n/// `unpack_delay_change` functions that can be used to extract the values from the packed representation. This\n/// is \"hacky\" but there is no way around it.\n#[derive(Eq)]\npub struct DelayedPublicMutableValues<T, let INITIAL_DELAY: u64> {\n pub svc: ScheduledValueChange<T>,\n pub sdc: ScheduledDelayChange<INITIAL_DELAY>,\n}\n\nimpl<T, let INITIAL_DELAY: u64> DelayedPublicMutableValues<T, INITIAL_DELAY> {\n pub fn new(svc: ScheduledValueChange<T>, sdc: ScheduledDelayChange<INITIAL_DELAY>) -> Self {\n DelayedPublicMutableValues { svc, sdc }\n }\n}\n\n/// Extracts a ScheduledValueChange struct from the packed representation of the full DelayedPublicMutable.\n/// TODO: impl the packable trait for ScheduledValueChange.\npub fn unpack_value_change<T, let M: u32>(packed: [Field; 2 * M + 1]) -> ScheduledValueChange<T>\nwhere\n T: Packable<N = M>,\n{\n let svc_pre_packed = arrays::subarray(packed, 1);\n let svc_post_packed = arrays::subarray(packed, M + 1);\n\n // We first cast to u32 as the timestamp_of_change is packed into the same field as the delay change and it\n // occupies the first 32 bits of the field.\n let timestamp_of_change = (packed[0] as u32) as u64;\n ScheduledValueChange::new(\n T::unpack(svc_pre_packed),\n T::unpack(svc_post_packed),\n timestamp_of_change,\n )\n}\n\n/// Extracts a ScheduledDelayChange struct from 0th field of the packed representation of the full DelayedPublicMutable.\n/// This function expects to be called with just the first field of the packed representation, which contains sdc\n/// and svc timestamp_of_change. We'll discard the svc component.\npub fn unpack_delay_change<let INITIAL_DELAY: u64>(\n packed: Field,\n) -> ScheduledDelayChange<INITIAL_DELAY> {\n // This function expects to be called with just the first field of the packed representation, which contains sdc\n // and svc timestamp_of_change. We'll discard the svc component.\n let svc_timestamp_of_change = packed as u32;\n\n let mut tmp = (packed - svc_timestamp_of_change as Field) / TWO_POW_32;\n let sdc_timestamp_of_change = tmp as u32;\n\n tmp = (tmp - sdc_timestamp_of_change as Field) / TWO_POW_32;\n let sdc_post_is_some = (tmp as u1) != 0;\n\n tmp = (tmp - sdc_post_is_some as Field) / TWO_POW_8;\n let sdc_post_inner = tmp as u32;\n\n tmp = (tmp - sdc_post_inner as Field) / TWO_POW_32;\n let sdc_pre_is_some = (tmp as u1) != 0;\n\n tmp = (tmp - sdc_pre_is_some as Field) / TWO_POW_8;\n let sdc_pre_inner = tmp as u32;\n\n // Note that below we cast the values to u64 as that is the default type of timestamp in the system. Us packing\n // the values as u32 is a tech debt that is not worth tackling.\n ScheduledDelayChange {\n pre: if sdc_pre_is_some {\n Option::some(sdc_pre_inner as u64)\n } else {\n Option::none()\n },\n post: if sdc_post_is_some {\n Option::some(sdc_post_inner as u64)\n } else {\n Option::none()\n },\n timestamp_of_change: sdc_timestamp_of_change as u64,\n }\n}\n\n// Q: do these evaluate at comptime or runtime?\nglobal TWO_POW_32: Field = 2.pow_32(32);\nglobal TWO_POW_8: Field = 2.pow_32(8);\n\n// We pack to `2 * N + 1` fields because ScheduledValueChange contains T twice (hence `2 * N`) and we need one extra\n// field to store ScheduledDelayChange and the timestamp_of_change of ScheduledValueChange.\nimpl<T, let INITIAL_DELAY: u64> Packable for DelayedPublicMutableValues<T, INITIAL_DELAY>\nwhere\n T: Packable,\n{\n let N: u32 = 2 * <T as Packable>::N + 1;\n\n fn pack(self) -> [Field; Self::N] {\n let mut result = [0; Self::N];\n\n // We pack sdc.pre, sdc.post, sdc.timestamp_of_change and svc.timestamp_of_change into a single field as follows:\n // [ sdc.pre_inner: u32 | sdc.pre_is_some: u8 | sdc.post_inner: u32 | sdc.post_is_some: u8 | sdc.timestamp_of_change: u32 | svc.timestamp_of_change: u32 ]\n // Note that the code below no longer works after 2106 as by that time the timestamp will overflow u32. This is a tech debt that is not worth tackling.\n result[0] = self.svc.timestamp_of_change as Field\n + ((self.sdc.timestamp_of_change as Field) * 2.pow_32(32))\n + ((self.sdc.post.is_some() as Field) * 2.pow_32(64))\n + ((self.sdc.post.unwrap_unchecked() as Field) * 2.pow_32(72))\n + ((self.sdc.pre.is_some() as Field) * 2.pow_32(104))\n + ((self.sdc.pre.unwrap_unchecked() as Field) * 2.pow_32(112));\n\n // Pack the pre and post values from ScheduledValueChange\n let svc_pre_packed = self.svc.pre.pack();\n let svc_post_packed = self.svc.post.pack();\n for i in 0..<T as Packable>::N {\n result[i + 1] = svc_pre_packed[i];\n result[i + 1 + <T as Packable>::N] = svc_post_packed[i];\n }\n result\n }\n\n // Note: inefficient if all you want to unpack is the svc; use unpack_value_change instead.\n fn unpack(fields: [Field; Self::N]) -> Self {\n let svc = unpack_value_change::<T, _>(fields);\n let sdc = unpack_delay_change::<INITIAL_DELAY>(fields[0]);\n Self::new(svc, sdc)\n }\n}\n\nimpl<T, let INITIAL_DELAY: u64> Hash for DelayedPublicMutableValues<T, INITIAL_DELAY>\nwhere\n T: Packable,\n{\n fn hash(self) -> Field {\n poseidon2_hash(self.pack())\n }\n}\n"
|
|
2855
2851
|
},
|
|
2856
|
-
"
|
|
2852
|
+
"382": {
|
|
2857
2853
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/delayed_public_mutable/scheduled_delay_change.nr",
|
|
2858
2854
|
"source": "use crate::traits::Empty;\nuse std::cmp::min;\n\nmod test;\n\n// This data structure is used by DelayedPublicMutable to store the minimum delay with which a ScheduledValueChange object can\n// schedule a change.\n// This delay is initially equal to INITIAL_DELAY, and can be safely mutated to any other value over time. This mutation\n// is performed via `schedule_change` in order to satisfy ScheduleValueChange constraints: if e.g. we allowed for the\n// delay to be decreased immediately then it'd be possible for the state variable to schedule a value change with a\n// reduced delay, invalidating prior private reads.\npub struct ScheduledDelayChange<let INITIAL_DELAY: u64> {\n // Both pre and post are stored in public storage, so by default they are zeroed. By wrapping them in an Option,\n // they default to Option::none(), which we detect and replace with INITIAL_DELAY. The end result is that a\n // ScheduledDelayChange that has not been initialized has a delay equal to INITIAL_DELAY, which is the desired\n // effect. Once initialized, the Option will never be none again.\n pub(crate) pre: Option<u64>,\n pub(crate) post: Option<u64>,\n // Timestamp at which `post` value is used instead of `pre`\n pub(crate) timestamp_of_change: u64,\n}\n\nimpl<let INITIAL_DELAY: u64> ScheduledDelayChange<INITIAL_DELAY> {\n pub fn new(pre: Option<u64>, post: Option<u64>, timestamp_of_change: u64) -> Self {\n Self { pre, post, timestamp_of_change }\n }\n\n /// Returns the current value of the delay stored in the data structure.\n /// WARNING: This function only returns a meaningful value when called in public with the current timestamp - for\n /// historical private reads use `get_effective_minimum_delay_at` instead.\n pub fn get_current(self, current_timestamp: u64) -> u64 {\n // The post value becomes the current one at the timestamp of change, so any transaction that is included at or after\n // the timestamp of change will use the post value.\n if current_timestamp < self.timestamp_of_change {\n self.pre.unwrap_or(INITIAL_DELAY)\n } else {\n self.post.unwrap_or(INITIAL_DELAY)\n }\n }\n\n /// Returns the scheduled change, i.e. the post-change delay and the timestamp at which it will become the current\n /// delay. Note that this timestamp may be in the past if the change has already taken place.\n /// Additionally, further changes might be later scheduled, potentially canceling the one returned by this function.\n pub fn get_scheduled(self) -> (u64, u64) {\n (self.post.unwrap_or(INITIAL_DELAY), self.timestamp_of_change)\n }\n\n /// Schedules a change to the delay, given the `current_timestamp` and the `current` delay.\n /// This function is only meaningful when called in public with the current timestamp.\n /// The timestamp at which the new delay will become effective is determined automatically:\n /// - when increasing the delay, the change is effective immediately\n /// - when reducing the delay, the change will take effect after a delay equal to the difference between old and\n /// new delay. For example, if reducing from 3 days to 1 day, the reduction will be scheduled to happen after 2\n /// days.\n pub fn schedule_change(&mut self, new: u64, current_timestamp: u64) {\n let current = self.get_current(current_timestamp);\n\n // When changing the delay value we must ensure that it is not possible to produce a value change with a delay\n // shorter than the current one.\n let time_until_delay_change = if new > current {\n // Increasing the delay value can therefore be done immediately: this does not invalidate prior constraints\n // about how quickly a value might be changed (indeed it strengthens them).\n //\n //\n // Earliest `svc.timestamp_of_change`, Earliest `svc.timestamp_of_change`\n // `current_timestamp` if the delay had remained unchanged immediately after this scheduling fn.\n // v v v\n // ====|==========================================================|==============|==>\n // | | |\n // [------------------`current` delay-------------------------] |\n // | |\n // [-------------------------`new` (longer) delay----------------------------]\n // |\n // [] <--- `time_until_delay_change` is `0`; the change is immediate.\n // |\n // ^\n // The newly-calculated `self.timestamp_of_change` (unchanged)\n\n 0\n } else {\n // Decreasing the delay requires waiting for the difference between current and new delay in order to ensure\n // that overall the current delay is respected.\n //\n //\n // Earliest `svc.timestamp_of_change`,\n // if the delay had remained unchanged\n // AND\n // Earliest `svc.timestamp_of_change`,\n // `current_timestamp` immediately after this scheduling fn.\n // ====|============================|=============================|=================>\n // | |\n // [---------------------`current` delay----------------------]\n // | |\n // [- --`new` (shorter) delay----]\n // | ^\n // [-`time_until_delay_change`--] |\n // | |\n // ^ |\n // The newly-calculated |\n // `self.timestamp_of_change` |\n // |\n // The new `self.timestamp_of_change`\n // is calculated so that these ends\n // align.\n current - new\n };\n\n self.pre = Option::some(current);\n self.post = Option::some(new);\n self.timestamp_of_change = current_timestamp + time_until_delay_change;\n }\n\n /// Returns the minimum delay before a value might mutate due to a scheduled change, from the perspective of some\n /// historical timestamp. It only returns a meaningful value when called in private with historical timestamps.\n /// The output of this function can be passed into `ScheduledValueChange.get_time_horizon` to properly\n /// constrain the `include_by_timestamp` when reading delayed mutable state.\n /// This value typically equals the current delay at the timestamp following the historical one (the earliest one in\n /// which a value change could be scheduled), but it also considers scenarios in which a delay reduction is\n /// scheduled to happen in the near future, resulting in a way to schedule a change with an overall delay lower than\n /// the current one.\n ///\n /// Alternative explanation: returns the maximum amount of time (from the historical timestamp) that a state read\n /// (as at the historical timestamp) will remain valid.\n /// A read might end up being valid for less time in the case where a `svc.timestamp_of_change` has already been\n /// set and if it's sooner than the output of this function. In that case, the `scheduled_value_change.nr`'s\n /// `get_time_horizon` function will realize this.\n ///\n pub fn get_effective_minimum_delay_at(self, historical_timestamp: u64) -> u64 {\n // If a change is scheduled, then the effective delay might be lower than the current one (pre). At the\n // timestamp of change the current delay will be the scheduled one, with an overall delay from the historical\n // timestamp equal to the time until the change plus the new delay. If this value is lower\n // than the current delay, then that is the effective minimum delay.\n\n // If using some block as the anchor block of some tx, then note that if you\n // read a `delayed_mutable` from that anchor block, you're actually reading the\n // `delayed_mutable` _as at the very end_ of that block.\n // Therefore the `delayed_mutable` that you will read _as at the very start of the next\n // block_ will be _the very same_ `delayed_mutable` (nothing can possibly have changed).\n // Therefore the first opportunity to schedule a value change (from the anchor timestamp)\n // is the first tx of that next block, which takes place at least 1 second after the\n // anchor block.\n // So should you choose to go ahead and schedule a value change in the first tx of that\n // next block, it will only take effect after the \"current delay\" (as dictated by the\n // `delayed_mutable` of that tx, which is the same as the `delayed_mutable` as at the\n // anchor timestamp).\n // In all, the time between the anchor block's timestamp and the earliest-possible value\n // timestamp_of_change, is therefore: 1 second + the \"current\" delay (as at the time of\n // the anchor timestamp).\n // Reads must only be valid until _just before_ the earliest-possible value change --\n // i.e. 1 second before the earliest-possible value change.\n // That is, reads are only valid for the \"current\" delay (as at the time of the anchor\n // timestamp) _at most_.\n // (I.e. the read remains valid for 1 + \"current delay\" - 1 = \"current delay\", from the\n // anchor timestamp).\n //\n // ____________ ____________\n // | | | |\n // | Block |<--At least a 1 second gap-->| Block |\n // |____________| |____________|\n // ^ ^\n // | You can schedule a value change from here.\n // |\n // Suppose this is your anchor block.\n // The delayed_mutable (and hence the \"current\" delay) as at the end of this block will\n // be the same as at the start of the next block.\n //\n if self.timestamp_of_change <= historical_timestamp {\n //\n // `self.timestamp_of_change` <= `historical_timestamp`\n // v v\n // ===================|==============================|=========\n // ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n // `self.pre` is |`self.post` takes effect from here.\n // effective before. |\n //\n // So in this `if` case, `self.post` is in effect at the time of the `historical_timestamp`.\n //\n // If no delay changes are scheduled (as at the time of the anchor timestamp), then the\n // \"current delay\" (as at the time of the historical timestamp) is `self.post` (or the\n // INITIAL_DELAY if never set).\n self.post.unwrap_or(INITIAL_DELAY)\n } else {\n //\n // `historical_timestamp` < `self.timestamp_of_change`\n // v\n // ===================|======================|====================================\n // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n // `self.pre` is effective |`self.post` takes effect from here.\n // during this period. |\n //\n // So in this `else` case, `self.pre` is in effect at the time of the `historical_timestamp`.\n //\n // If a delay change _is_ already scheduled (as at the time of the historical timestamp):\n // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n // |________________\n // |\n // v Earliest possible\n // `historical_ Scheduled delay change: `svc.timestamp_of_change`\n // timestamp` < `self.timestamp_of_change` (if not already set [^1])\n // v v v\n // ===||=============================|====================================|================>\n // .| . .\n // .| . .\n // .|__ Earliest possible timestamp at which a .\n // . function could call `schedule_change` for a new .\n // . _value_ change..................................................And the earliest timestamp at\n // . . .which the new value would take effect.\n // .[---------------`self.pre` delay-----------------------------------]\n // . . .\n // [******************************************************************].\n // [ ].\n // [----------------`self.pre` delay----------------------------------].\n // [ ].\n // [ If reading a _value_ at that (<--) anchor timestamp, then the ].\n // [ read will remain valid for this duration, unless a shorter ].\n // [ delay has been scheduled (see just below in this diagram). ].\n // [ If a _deferred, longer_ delay has been scheduled, it might yet ].\n // [ still be cancelled, in which case this `pre` delay would ].\n // [ bite (see the `min` calc below) -- meaning reads would remain ].\n // [ valid for this duration. ].\n // [ ].\n // [******************************************************************].\n // . . .\n // . . .\n // [---`time_until_delay_change`--] .\n // . . .\n // . . .\n // . . .\n // SCENARIO 1: scheduled delay is shorter than the `self.pre` delay: .\n // . . .\n // . . .\n // . [-`self.post` delay-] .\n // . . (if shorter ^^ .\n // . . than `pre`) ||_ new values can take effect from here.\n // . . |\n // . . |_ reads are only valid until here:\n // . . . `historic_timestamp + time_until_delay_change + self.post - 1`\n // . . . .\n // [*************************************************] .\n // [ ] .\n // [----`time_until_delay_change + self.post - 1`----] .\n // [ ] .\n // [ If reading a _value_ at that (<--) anchor ] .\n // [ timestamp, then the read will remain valid ] .\n // [ for this duration: ] .\n // [ ] .\n // [*************************************************] .\n // . . .\n // . . .\n // . . .\n // SCENARIO 2: scheduled delay is longer than the `self.pre` delay, AND is deferred:\n // (note: scheduling deferred delay changes is not yet possible)\n // . . .\n // . . .\n // . [-`self.post` delay (if longer than `pre` & deferred)------------------]\n // . . (scheduling deferred delay changes is not yet possible) ^^\n // . . ||\n // . . reads would only be valid until here:___________________________||\n // . . `historic_timestamp + time_until_delay_change + self.post - 1` |\n // . . |\n // . . new values would take effect from here,_______|\n // . . but only once this longer delay takes effect .\n // . . . .\n // . . . .\n // [****************************************************************************************************].\n // [ ].\n // [----`time_until_delay_change + self.post - 1`-------------------------------------------------------].\n // [ ].\n // [ Given a longer, deferred delay, then if reading a _value_ at that (<--) historical timestamp, then ].\n // [ you might think the read would remain valid for this duration. ].\n // [ BUT, in this case of this deferred, longer-than-`self.pre` delay, the `pre` delay ends sooner (by ].\n // [ construction) (see above in this diagram). ].\n // [ And since this scheduled delay (`post`) can be cancelled up until the time it takes effect, ].\n // [ any reads as at that (<--) historical timestamp would cautiously only be valid until the earlier ].\n // [ `pre` delay expiry. ].\n // [ ].\n // [****************************************************************************************************].\n //\n //\n //\n // [^1] If a svc.timestamp_of_change has already been set, and if it's sooner than the\n // output of this function, then it will bite within `scheduled_value_change.nr`'s\n // `get_time_horizon` function.\n let time_until_delay_change = self.timestamp_of_change - historical_timestamp;\n\n min(\n self.pre.unwrap_or(INITIAL_DELAY), // in case the scheduled delay (`post`) gets cancelled before it takes effect.\n time_until_delay_change + self.post.unwrap_or(INITIAL_DELAY) - 1,\n )\n }\n }\n}\n\nimpl<let INITIAL_DELAY: u64> Eq for ScheduledDelayChange<INITIAL_DELAY> {\n fn eq(self, other: Self) -> bool {\n (self.pre == other.pre)\n & (self.post == other.post)\n & (self.timestamp_of_change == other.timestamp_of_change)\n }\n}\n\nimpl<let INITIAL_DELAY: u64> Empty for ScheduledDelayChange<INITIAL_DELAY> {\n fn empty() -> Self {\n Self { pre: Option::none(), post: Option::none(), timestamp_of_change: 0 }\n }\n}\n"
|
|
2859
2855
|
},
|
|
2860
|
-
"
|
|
2856
|
+
"384": {
|
|
2861
2857
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/delayed_public_mutable/scheduled_value_change.nr",
|
|
2862
2858
|
"source": "use crate::traits::Empty;\nuse std::cmp::min;\n\nmod test;\n\n// This data structure is used by DelayedPublicMutable to represent a value that changes from `pre` to `post` at some timestamp\n// called the `timestamp_of_change`. The value can only be made to change by scheduling a change event at some future\n// timestamp after some minimum delay measured in seconds has elapsed. This means that at any given timestamp we know\n// both the current value and the smallest timestamp at which the value might change - this is called the\n// 'time horizon'.\npub struct ScheduledValueChange<T> {\n pub(crate) pre: T,\n pub(crate) post: T,\n // Timestamp at which `post` value is used instead of `pre`\n pub(crate) timestamp_of_change: u64,\n}\n\nimpl<T> ScheduledValueChange<T> {\n pub fn new(pre: T, post: T, timestamp_of_change: u64) -> Self {\n Self { pre, post, timestamp_of_change }\n }\n\n /// Returns the value stored in the data structure at a given timestamp. This function can be called both in public\n /// (where `timestamp` is simply the current timestamp, i.e. the timestamp at which the current transaction will be\n /// included) and in private (where `timestamp` is the anchor block's timestamp). Reading in private is only safe\n /// if the transaction's `include_by_timestamp` property is set to a value lower or equal to the time horizon (see\n /// `get_time_horizon()`).\n pub fn get_current_at(self, timestamp: u64) -> T {\n // The post value becomes the current one at the timestamp of change. This means different things in each realm:\n // - in public, any transaction that is included at the timestamp of change will use the post value\n // - in private, any transaction that includes the timestamp of change as part of the historical state will use\n // the post value (barring any follow-up changes)\n if timestamp < self.timestamp_of_change {\n self.pre\n } else {\n self.post\n }\n }\n\n /// Returns the scheduled change, i.e. the post-change value and the timestamp at which it will become the current\n /// value. Note that this timestamp may be in the past if the change has already taken place.\n /// Additionally, further changes might be later scheduled, potentially canceling the one returned by this function.\n pub fn get_scheduled(self) -> (T, u64) {\n (self.post, self.timestamp_of_change)\n }\n\n // Returns the previous value. This is the value that is current up until the timestamp of change. Note that this\n // value might not be the current anymore since timestamp of change might have already passed.\n pub fn get_previous(self) -> (T, u64) {\n (self.pre, self.timestamp_of_change)\n }\n\n /// Returns the largest timestamp at which the value returned by `get_current_at` is known to remain the current\n /// value. This value is only meaningful in private where the proof is constructed against an anchor block, since\n /// due to its asynchronous nature private execution cannot know about any later scheduled changes.\n /// The caller of this function must know how quickly the value can change due to a scheduled change in the form of\n /// `minimum_delay`. If the delay itself is immutable, then this is just its duration. If the delay is mutable\n /// however, then this value is the 'effective minimum delay' (obtained by calling\n /// `ScheduledDelayChange.get_effective_minimum_delay_at`), which equals the minimum time in seconds that needs to\n /// elapse from the next block's timestamp until the value changes, regardless of further delay changes.\n /// The value returned by `get_current_at` in private when called with a anchor block's timestamp is only safe to use\n /// if the transaction's `include_by_timestamp` property is set to a value lower or equal to the time horizon\n /// computed using the same anchor timestamp.\n pub fn get_time_horizon(self, anchor_timestamp: u64, minimum_delay: u64) -> u64 {\n // The time horizon is the very last timestamp in which the current value is known. Any timestamp past the\n // horizon (i.e. with a timestamp larger than the time horizon) may have a different current value.\n // Reading the current value in private typically requires constraining the maximum valid timestamp to be equal\n // to the time horizon.\n if anchor_timestamp >= self.timestamp_of_change {\n // Once the timestamp of change has passed (block with timestamp >= timestamp_of_change was mined),\n // the current value (post) will not change unless a new value change is scheduled. This did not happen at\n // the anchor timestamp (or else it would not be greater or equal to the timestamp of change), and\n // therefore could only happen after the anchor timestamp. The earliest would be the immediate next\n // timestamp, and so the smallest possible next timestamp of change equals `anchor_timestamp + 1 +\n // minimum_delay`. Our time horizon is simply the previous timestamp to that one.\n //\n // timestamp of anchor\n // change timestamp time horizon\n // =======|=============N===================H===========>\n // ^ ^\n // ---------------------\n // minimum delay\n anchor_timestamp + minimum_delay\n } else {\n // If the timestamp of change has not yet been reached however, then there are two possible scenarios.\n // a) It could be so far into the future that the time horizon is actually determined by the minimum\n // delay, because a new change could be scheduled and take place _before_ the currently scheduled one.\n // This is similar to the scenario where the timestamp of change is in the past: the time horizon is\n // the timestamp prior to the earliest one in which a new timestamp of change might land.\n //\n // anchor\n // timestamp time horizon timestamp of change\n // =====N=================================H=================|=========>\n // ^ ^\n // | |\n // -----------------------------------\n // minimum delay\n //\n // b) It could be fewer than `minimum_delay` seconds away from the anchor timestamp, in which case\n // the timestamp of change would become the limiting factor for the time horizon, which would equal\n // the timestamp right before the timestamp of change (since by definition the value changes at the\n // timestamp of change).\n //\n // anchor time horizon\n // timestamp timestamp of change if not scheduled\n // =======N=============|===================H=================>\n // ^ ^ ^\n // | actual horizon |\n // -----------------------------------\n // minimum delay\n //\n // Note that the current implementation does not allow the caller to set the timestamp of change to an\n // arbitrary value, and therefore scenario a) is not currently possible. However implementing #5501 would\n // allow for this to happen.\n // Because anchor_timestamp < self.timestamp_of_change, then timestamp_of_change > 0 and we can safely\n // subtract 1.\n min(\n self.timestamp_of_change - 1,\n anchor_timestamp + minimum_delay,\n )\n }\n }\n\n /// Mutates the value by scheduling a change at the current timestamp. This function is only meaningful when\n /// called in public with the current timestamp.\n pub fn schedule_change(\n &mut self,\n new_value: T,\n current_timestamp: u64,\n minimum_delay: u64,\n timestamp_of_change: u64,\n ) {\n assert(timestamp_of_change >= current_timestamp + minimum_delay);\n\n self.pre = self.get_current_at(current_timestamp);\n self.post = new_value;\n self.timestamp_of_change = timestamp_of_change;\n }\n}\n\nimpl<T> Eq for ScheduledValueChange<T>\nwhere\n T: Eq,\n{\n fn eq(self, other: Self) -> bool {\n (self.pre == other.pre)\n & (self.post == other.post)\n & (self.timestamp_of_change == other.timestamp_of_change)\n }\n}\n\nimpl<T> Empty for ScheduledValueChange<T>\nwhere\n T: Empty,\n{\n fn empty() -> Self {\n Self { pre: T::empty(), post: T::empty(), timestamp_of_change: 0 }\n }\n}\n"
|
|
2863
2859
|
},
|
|
2864
|
-
"
|
|
2860
|
+
"387": {
|
|
2865
2861
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
|
|
2866
2862
|
"source": "mod poseidon2_chunks;\n\nuse crate::{\n abis::{\n contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n function_selector::FunctionSelector,\n note_hash::NoteHash,\n nullifier::Nullifier,\n private_log::{PrivateLog, PrivateLogData},\n transaction::tx_request::TxRequest,\n },\n address::{AztecAddress, EthAddress},\n constants::{\n CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, DOM_SEP__NOTE_HASH_NONCE,\n DOM_SEP__PRIVATE_LOG_FIRST_FIELD, DOM_SEP__SILOED_NOTE_HASH, DOM_SEP__SILOED_NULLIFIER,\n DOM_SEP__UNIQUE_NOTE_HASH, FUNCTION_TREE_HEIGHT, NULL_MSG_SENDER_CONTRACT_ADDRESS,\n TWO_POW_64,\n },\n merkle_tree::root_from_sibling_path,\n messaging::l2_to_l1_message::L2ToL1Message,\n poseidon2::Poseidon2Sponge,\n side_effect::{Counted, Scoped},\n traits::{FromField, Hash, ToField},\n utils::field::{field_from_bytes, field_from_bytes_32_trunc},\n};\n\npub use poseidon2_chunks::poseidon2_absorb_in_chunks_existing_sponge;\nuse poseidon2_chunks::poseidon2_absorb_in_chunks;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\n// TODO: refactor these into their own files: sha256, poseidon2, some protocol-specific hash computations, some merkle computations.\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n let sha256_hashed = sha256::digest(bytes_to_hash);\n let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n selector: FunctionSelector,\n vk_hash: Field,\n function_leaf_index: Field,\n function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n let function_leaf = function_leaf_preimage.hash();\n root_from_sibling_path(\n function_leaf,\n function_leaf_index,\n function_leaf_sibling_path,\n )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n // unique).\n poseidon2_hash_with_separator(\n [first_nullifier_in_tx, note_index_in_tx as Field],\n DOM_SEP__NOTE_HASH_NONCE,\n )\n}\n\npub fn compute_unique_note_hash(note_nonce: Field, siloed_note_hash: Field) -> Field {\n let inputs = [note_nonce, siloed_note_hash];\n poseidon2_hash_with_separator(inputs, DOM_SEP__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_note_nonce_and_unique_note_hash(\n siloed_note_hash: Field,\n first_nullifier: Field,\n note_index_in_tx: u32,\n) -> Field {\n let note_nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n compute_unique_note_hash(note_nonce, siloed_note_hash)\n}\n\npub fn compute_siloed_note_hash(contract_address: AztecAddress, note_hash: Field) -> Field {\n poseidon2_hash_with_separator(\n [contract_address.to_field(), note_hash],\n DOM_SEP__SILOED_NOTE_HASH,\n )\n}\n\n/// Computes unique, siloed note hashes from siloed note hashes.\n///\n/// The protocol injects uniqueness into every note_hash, so that every single note_hash in the\n/// tree is unique. This prevents faerie gold attacks, where a malicious sender could create\n/// two identical note_hashes for a recipient (meaning only one would be nullifiable in future).\n///\n/// Most privacy protocols will inject the note's leaf_index (its position in the Note Hashes Tree)\n/// into the note, but this requires the creator of a note to wait until their tx is included in\n/// a block to know the note's final note hash (the unique, siloed note hash), because inserting\n/// leaves into trees is the job of a block producer.\n///\n/// We took a different approach so that the creator of a note will know each note's unique, siloed\n/// note hash before broadcasting their tx to the network.\n/// (There was also a historical requirement relating to \"chained transactions\" -- a feature that\n/// Aztec Connect had to enable notes to be spent from distinct txs earlier in the same block,\n/// and hence before an archive block root had been established for that block -- but that feature\n/// was abandoned for the Aztec Network for having too many bad tradeoffs).\n///\n/// (\n/// Edit: it is no longer true that all final note_hashes will be known by the creator of a tx\n/// before they send it to the network. If a tx makes public function calls, then _revertible_\n/// note_hashes that are created in private will not be made unique in private by the Reset circuit,\n/// but will instead be made unique by the AVM, because the `note_index_in_tx` will not be known\n/// until the AVM has executed the public functions of the tx. (See an explanation in\n/// reset_output_composer.nr for why).\n/// For some such txs, the `note_index_in_tx` might still be predictable through simulation, but\n/// for txs whose public functions create a varying number of non-revertible notes (determined at\n/// runtime), the `note_index_in_tx` will not be deterministically derivable before submitting the\n/// tx to the network.\n/// )\n///\n/// We use the `first_nullifier` of a tx as a seed of uniqueness. We have a guarantee that there will\n/// always be at least one nullifier per tx, because the init circuit will create one if one isn't\n/// created naturally by any functions of the tx. (Search \"protocol_nullifier\").\n/// We combine the `first_nullifier` with the note's index (its position within this tx's new\n/// note_hashes array) (`note_index_in_tx`) to get a truly unique value to inject into a note, which\n/// we call a `note_nonce`.\npub fn compute_unique_siloed_note_hash(\n siloed_note_hash: Field,\n first_nullifier: Field,\n note_index_in_tx: u32,\n) -> Field {\n if siloed_note_hash == 0 {\n 0\n } else {\n compute_note_nonce_and_unique_note_hash(siloed_note_hash, first_nullifier, note_index_in_tx)\n }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: Scoped<Counted<NoteHash>>) -> Field {\n if note_hash.contract_address.is_zero() {\n 0\n } else {\n compute_siloed_note_hash(note_hash.contract_address, note_hash.innermost())\n }\n}\n\npub fn compute_siloed_nullifier(contract_address: AztecAddress, nullifier: Field) -> Field {\n poseidon2_hash_with_separator(\n [contract_address.to_field(), nullifier],\n DOM_SEP__SILOED_NULLIFIER,\n )\n}\n\npub fn silo_nullifier(nullifier: Scoped<Counted<Nullifier>>) -> Field {\n let value = nullifier.innermost().value;\n // Q: shouldn't we be checking whether the _whole_ scoped, counted, nullifier struct is empty?\n // A: We don't have to. The init and inner circuits add a contract address only to non-empty nullifiers.\n // So we know we should silo it if the contract address is not empty.\n if nullifier.contract_address.is_zero() {\n // Return `.value` instead of 0, because already-siloed nullifiers also have a zero\n // contract_address field, and we of course want to return that already-siloed nullifier\n // (we just don't want to silo it a second time).\n value\n } else {\n compute_siloed_nullifier(nullifier.contract_address, value)\n }\n}\n\npub fn create_protocol_nullifier(tx_request: TxRequest) -> Scoped<Counted<Nullifier>> {\n // The protocol nullifier is ascribed a special side-effect counter of 1. No other side-effect\n // can have counter 1 (see `validate_as_first_call` for that assertion).\n Nullifier { value: tx_request.hash(), note_hash: 0 }.count(1).scope(\n NULL_MSG_SENDER_CONTRACT_ADDRESS,\n )\n}\n\npub fn compute_siloed_private_log_first_field(\n contract_address: AztecAddress,\n field: Field,\n) -> Field {\n poseidon2_hash_with_separator(\n [contract_address.to_field(), field],\n DOM_SEP__PRIVATE_LOG_FIRST_FIELD,\n )\n}\n\npub fn silo_private_log(private_log: Scoped<Counted<PrivateLogData>>) -> PrivateLog {\n let log = private_log.innermost().log;\n if private_log.contract_address.is_zero() {\n log\n } else {\n let mut fields = log.fields;\n fields[0] = compute_siloed_private_log_first_field(private_log.contract_address, fields[0]);\n PrivateLog::new(fields, log.length)\n }\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n poseidon2_hash(log)\n}\n\npub fn compute_app_siloed_secret_key(\n master_secret_key: EmbeddedCurveScalar,\n app_address: AztecAddress,\n app_secret_key_domain_separator: Field,\n) -> Field {\n poseidon2_hash_with_separator(\n [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n app_secret_key_domain_separator,\n )\n}\n\npub fn compute_l2_to_l1_hash(\n contract_address: AztecAddress,\n recipient: EthAddress,\n content: Field,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n let contract_address_bytes: [u8; 32] = contract_address.to_field().to_be_bytes();\n let recipient_bytes: [u8; 20] = recipient.to_be_bytes();\n let content_bytes: [u8; 32] = content.to_be_bytes();\n let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n let mut bytes: [u8; 148] = std::mem::zeroed();\n for i in 0..32 {\n bytes[i] = contract_address_bytes[i];\n bytes[i + 32] = rollup_version_id_bytes[i];\n // 64 - 84 are for recipient.\n bytes[i + 84] = chain_id_bytes[i];\n bytes[i + 116] = content_bytes[i];\n }\n\n for i in 0..20 {\n bytes[64 + i] = recipient_bytes[i];\n }\n\n sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n msg: Scoped<L2ToL1Message>,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n if msg.contract_address.is_zero() {\n 0\n } else {\n compute_l2_to_l1_hash(\n msg.contract_address,\n msg.inner.recipient,\n msg.inner.content,\n rollup_version_id,\n chain_id,\n )\n }\n}\n\n// TODO: consider a variant that enables domain separation with a u32 (we seem to have standardised u32s for domain separators)\n/// Computes sha256 hash of 2 input fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256(v0: Field, v1: Field) -> Field {\n // Concatenate two fields into 32 x 2 = 64 bytes\n let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n let hash_input_flattened = v0_as_bytes.concat(v1_as_bytes);\n\n sha256_to_field(hash_input_flattened)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n T: ToField,\n{\n let inputs_with_separator = [separator.to_field()].concat(inputs);\n poseidon2_hash(inputs_with_separator)\n}\n\n/// Computes a Poseidon2 hash over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// The caller is responsible for ensuring that the input is padded with zeros if required.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n sponge.squeeze()\n}\n\n// NB the below is the same as poseidon::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n sponge.squeeze()\n}\n\n// This function is unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n inputs: BoundedVec<Field, N>,\n separator: T,\n) -> Field\nwhere\n T: ToField,\n{\n let in_len = inputs.len() + 1;\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n sponge.absorb(separator.to_field());\n\n for i in 0..inputs.len() {\n sponge.absorb(inputs.get(i));\n }\n\n sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n let mut fields = [0; (N + 30) / 31];\n let mut field_index = 0;\n let mut current_field = [0; 31];\n for i in 0..inputs.len() {\n let index = i % 31;\n current_field[index] = inputs[i];\n if index == 30 {\n fields[field_index] = field_from_bytes(current_field, false);\n current_field = [0; 31];\n field_index += 1;\n }\n }\n if field_index != fields.len() {\n fields[field_index] = field_from_bytes(current_field, false);\n }\n poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n let mut fixed_input = [3; 501];\n assert(in_len == fixed_input.len()); // sanity check\n for i in 0..in_len {\n input[i] = 3;\n }\n let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n for i in 0..in_len {\n input[i] = 3;\n }\n let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(input, in_len);\n assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n let full_buffer = [\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n ];\n let result = sha256_to_field(full_buffer);\n\n assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n let result_bytes = sha256::digest(full_buffer);\n let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n assert(truncated_field == result);\n let mod_res = result + (result_bytes[31] as Field);\n assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n // All zeroes\n let hash_result =\n compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n assert(hash_result == 0x3b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992);\n\n // Non-zero case\n let hash_result = compute_l2_to_l1_hash(\n AztecAddress::from_field(1),\n EthAddress::from_field(3),\n 5,\n 2,\n 4,\n );\n assert(hash_result == 0xaab2a5828156782b12a1dc6f336e2bc627eb1b9514b02d511f66296990c050);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n let version = 4;\n let chainId = 5;\n\n let hash = silo_l2_to_l1_message(\n L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n AztecAddress::from_field(3),\n ),\n version,\n chainId,\n );\n\n // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n let l2_to_l1_message_hash_from_ts =\n 0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n assert_eq(hash, l2_to_l1_message_hash_from_ts);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n let separator = 42;\n\n // Hash using bounded vec version\n let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n // Hash using regular version\n let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n // Results should match\n assert_eq(bounded_result, regular_result);\n}\n"
|
|
2867
2863
|
},
|
|
2864
|
+
"389": {
|
|
2865
|
+
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/logging.nr",
|
|
2866
|
+
"source": "// Log levels matching the JS logger:\n\n// global SILENT_LOG_LEVEL: u8 = 0;\nglobal FATAL_LOG_LEVEL: u8 = 1;\nglobal ERROR_LOG_LEVEL: u8 = 2;\nglobal WARN_LOG_LEVEL: u8 = 3;\nglobal INFO_LOG_LEVEL: u8 = 4;\nglobal VERBOSE_LOG_LEVEL: u8 = 5;\nglobal DEBUG_LOG_LEVEL: u8 = 6;\nglobal TRACE_LOG_LEVEL: u8 = 7;\n\n// --- Per-level log functions (no format args) ---\n\npub fn fatal_log<let N: u32>(msg: str<N>) {\n fatal_log_format(msg, []);\n}\n\npub fn error_log<let N: u32>(msg: str<N>) {\n error_log_format(msg, []);\n}\n\npub fn warn_log<let N: u32>(msg: str<N>) {\n warn_log_format(msg, []);\n}\n\npub fn info_log<let N: u32>(msg: str<N>) {\n info_log_format(msg, []);\n}\n\npub fn verbose_log<let N: u32>(msg: str<N>) {\n verbose_log_format(msg, []);\n}\n\npub fn debug_log<let N: u32>(msg: str<N>) {\n debug_log_format(msg, []);\n}\n\npub fn trace_log<let N: u32>(msg: str<N>) {\n trace_log_format(msg, []);\n}\n\n// --- Per-level log functions (with format args) ---\n\npub fn fatal_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n log_format(FATAL_LOG_LEVEL, msg, args);\n}\n\npub fn error_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n log_format(ERROR_LOG_LEVEL, msg, args);\n}\n\npub fn warn_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n log_format(WARN_LOG_LEVEL, msg, args);\n}\n\npub fn info_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n log_format(INFO_LOG_LEVEL, msg, args);\n}\n\npub fn verbose_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n log_format(VERBOSE_LOG_LEVEL, msg, args);\n}\n\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n log_format(DEBUG_LOG_LEVEL, msg, args);\n}\n\npub fn trace_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n log_format(TRACE_LOG_LEVEL, msg, args);\n}\n\nfn log_format<let M: u32, let N: u32>(log_level: u8, msg: str<M>, args: [Field; N]) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { log_oracle_wrapper(log_level, msg, args) };\n}\n\nunconstrained fn log_oracle_wrapper<let M: u32, let N: u32>(\n log_level: u8,\n msg: str<M>,\n args: [Field; N],\n) {\n log_oracle(log_level, msg, N, args);\n}\n\n#[oracle(utilityLog)]\nunconstrained fn log_oracle<let M: u32, let N: u32>(\n log_level: u8,\n msg: str<M>,\n length: u32,\n args: [Field; N],\n) {}\n"
|
|
2867
|
+
},
|
|
2868
2868
|
"403": {
|
|
2869
2869
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/point.nr",
|
|
2870
|
-
"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",
|
|
@@ -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 ::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"
|
|
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",
|