@aztec/protocol-contracts 0.0.1-commit.ec5f612 → 0.0.1-commit.ef17749e1
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 +104 -92
- package/artifacts/ContractClassRegistry.json +13 -13
- package/artifacts/ContractInstanceRegistry.json +20 -20
- package/artifacts/FeeJuice.json +31 -23
- package/artifacts/MultiCallEntrypoint.json +70 -58
- package/artifacts/PublicChecks.json +68 -56
- package/dest/protocol_contract_data.js +29 -29
- package/package.json +4 -4
- package/src/protocol_contract_data.ts +29 -29
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"transpiled": true,
|
|
3
|
-
"noir_version": "1.0.0-beta.19+
|
|
3
|
+
"noir_version": "1.0.0-beta.19+39f25c903f0ddc60373ca60a85cbdaa3c0f016cd",
|
|
4
4
|
"name": "ContractInstanceRegistry",
|
|
5
5
|
"functions": [
|
|
6
6
|
{
|
|
@@ -35,7 +35,7 @@
|
|
|
35
35
|
}
|
|
36
36
|
}
|
|
37
37
|
},
|
|
38
|
-
"bytecode": "
|
|
38
|
+
"bytecode": "JwACBAEoAAABBIBFJwAABEUlAAAAQScCAgQAJwIDBAAfCgACAAMARCUAAABCLQICRCcCAwREJwIEBAE7DgAEAAMmJQAAAmAeAgADCScCBAEBJAIAAwAAAF4lAAAChh4CAAMBKQIABADvUlNNJwIFAAErAgAGAAAAAAAAAAADAAAAAAAAAAAtCAEHJwIIBAUACAEIAScDBwQBACIHAggtCggJLQ4ECQAiCQIJLQ4FCQAiCQIJLQ4DCQAiCQIJLQ4GCS0IAQMnAgQEBQAIAQQBJwMDBAEAIgcCBAAiAwIFPw8ABAAFJwIEBAEAKgMEBi0LBgUnAgMAAAoqBQMEJwIDAQAKKgQDBiQCAAYAAAETJQAAApgeAgADBh4CAAQALyoABQAEAAYcCgYFBBwKBQQAAioGBAUsAgAEAC1eCYuCuje0O5mhMWEY/SDUL1FmyenxP7XqZaltHgptBCoFBAYcCgYHBBwKBwUAAioGBQcEKgcEBhwKBggBHAoIBwAcCgcIAQIqBgcJLAIABgAwM+okblBuiY6X9XDK/9cEywu0YDE/tyCynhOeXBAAAQQqCQYKHAoKCwQcCgsJAAIqCgkLBCoLBAocCgoLARwKCwQAHAoECwECKgoEDAQqDAYKHAoKDAQcCgwGABwKBgoFFgoLBhwKBAsFHAoGBAUEKgsKBhwKCQoFFgoICRwKBwgFHAoJBwUEKggKCRwKBQoFDCoDCgUpAgADBQABUYAkAgAFAAACSyMAAAI3BCoICQQEKgcDBQAqBAUCIwAAAl8EKgsGBQQqBAMGACoFBgIjAAACXyYoAAAEBHhFDAAABAMkAAADAAAChSoBAAEF2sX11rRKMm08BAIBJioBAAEFT99KitfP8NM8BAIBJioBAAEFursh14IzGGQ8BAIBJg==",
|
|
39
39
|
"debug_symbols": "nVjbbuIwEP2XPPPgufjGr1RVRdu0QkK0orDSquLfdwY8DlSyd9cv5OQkOTnjuSTke3qdn0/vT9v928fXtH74np4P291u+/60+3jZHLcfe2G/J6c/EaY1raYYpjWvpgTXTb5sMk/rIBvZAzkHXCoAqABiA3aI7RAb443xxgQ0EApQF1fgC0jOgN0imY2sgl5BvAJ0aMAYMAaMQWNQbUhYSGTAGNZzkoJYgDfGGxOMic6AeEYUoJ5RmSQMOQFqlfRQTldAThlSoIwsMrEvwMvl5BX4AoIyQYEyUYDelJICX0Ay5nLTLCALw3J3xlgAiWcGBbEAjZRRgTLihzVSZgWxgGBMUEb8cFQmKFBG/HBCA8qIDc52VQ5XxjswYAwokxWEq3mPrjDoCyBjSBgvUXgWxuP5vJqsjJ+Oh3nWKr6pa6n2z81h3h+n9f60262mX5vd6XLS1+dmf9keNwc5KpLz/lW2Ivi23c2Kzqvlate+FBBzLJcDEuQq4e81oK2RA4YikQPHRSHdKWDHhUtsJsAtChEG40BoxdHVYF40OLiWhm9rkCb6okCBh+Jg7UTzwKHlIXY1fJXIviokulNIbQXpf4sip3q9OLsTyJ2SgJrQjDfJoJTvq6qzFCnrKLpopBxyWwN66SALJC2BkPtR253SlLFrGUVIcUwDyRoEMXJbg9saHLMllRNh1fiRk54NyWVdjZyhaaNXWpBtNYBcaJUWdCSidGqRiHhT3wkHeyS2Z1anQiGwPj6uIoEDtYxgr0Q5WlIS36zoz8nXqdBQFzRCc/D9JZBqQnCOzUCoI5LQ1SVN8j7RFOHeFEdvdS44tp8EvifioA5h54ibIqGzqJAsmiCvVE2JTpliNAXMzUHeCyTniEscnJomOrklv8wv37HRz2yoPhI538osdYoUM/q6GnQzSBP8h0aoDxXJ8aCGr49XB35IQ5YAqkaAQY3aciR/IUY1uGpgHNMAH6tGCIMayZpWXptGfaS6HkhuTAOXWDAM+sBUc0sw6mN5+SHkMQ3ytW8p4KBGsr4lhmGNuh6Mg/3CS7/waL9EqrUe/eCapjpP5Q1wsOdyfZlj53JT49+ft/IHsDVQfW+QyZPNBqrj22Ln8/lRdjcv28PdN46zih22m+fdXHbfTvuXm6PH3592xL6RfB4+XubX02FWpeVDCcjvAzhegcuP+g1Ed+V7BIB/POvt/wA="
|
|
40
40
|
},
|
|
41
41
|
{
|
|
@@ -107,8 +107,8 @@
|
|
|
107
107
|
}
|
|
108
108
|
}
|
|
109
109
|
},
|
|
110
|
-
"bytecode": "
|
|
111
|
-
"debug_symbols": "tZ3bjhy3robfZa59IerMvEqwEDiJExgwnMAr3sCG4Xdf4i+
|
|
110
|
+
"bytecode": "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",
|
|
111
|
+
"debug_symbols": "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"
|
|
112
112
|
},
|
|
113
113
|
{
|
|
114
114
|
"name": "publish_for_public_execution",
|
|
@@ -2094,8 +2094,8 @@
|
|
|
2094
2094
|
}
|
|
2095
2095
|
}
|
|
2096
2096
|
},
|
|
2097
|
-
"bytecode": "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",
|
|
2098
|
-
"debug_symbols": "
|
|
2097
|
+
"bytecode": "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",
|
|
2098
|
+
"debug_symbols": "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",
|
|
2099
2099
|
"verification_key": "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"
|
|
2100
2100
|
},
|
|
2101
2101
|
{
|
|
@@ -2152,8 +2152,8 @@
|
|
|
2152
2152
|
}
|
|
2153
2153
|
}
|
|
2154
2154
|
},
|
|
2155
|
-
"bytecode": "
|
|
2156
|
-
"debug_symbols": "tZvbbhw5Dobfpa99IVGkDnmVQRA4iTMwYDiBJ1lgEeTdl6QksuxFKbY6c+P+mt31FylREqVq/7x8vvv44+8P949fvv5zeffXz8vHp/uHh/u/Pzx8/XT7/f7rI1t/XoL8iUiXd+nmEonfkrzSeG3dnnG88vvCrwXH63hfS39tMF7z5V0MNxcIkYGVIIYJOKENgGmBaUnTkuoAhAllAE1lygOy3KIK0IQ2oKQJZUCFCdPS4gS+HNj5JM5DFGgDxHkAgTYApiXBBBYEboSEeYC0agcakKclT0uZFmnaDnVATROmsjRzB75FYldRXO1AE9qAmCbUATAtUAYkuRwE8gCcFmwDSHKgCbAFuTUw8+XIaYEFJogFGaR5kTuFpKEUpKEwC7QB0stYBMTCLU8olibQBtC0yE2JXSVJReK7Zwm5A/tM7GGOcYJY2J8MYkEBsbAbWSLtMC0SKWUBsbA/WVKLqkAekMXSBOZV0l9qKTSgTktlS2ZXcwvd+dxwWlqHEnCCWDiKIqmVUUAs7EapfK/Md6/65SbQBsRpARggzhcWrOJ8h2mRFusgo5UjrTp8RVm6qcjlOoDlIx3B/FELoX/UJKMUZAjLd1qk8R1JpBoF6oAkFhIQi3wZ04RpIZiQB8hw6EADyrSIqx3kcm6WJsOhyt2rWMSxliYMSwwBjPIk8X8QTQKzSX4OYpUWhCSaFpXEBkISzyCzSUSD8iSJaRBNKmaTsAaJisytQQJrqCQ2mX+DhDZo2qLENihPktgG0SQwm8Q2SFSykMZWlMRWhTS2TmbT2DrlSRpbJ5pUzKaxdRIVadMosXFfKMqcHiROkHweGJOjfwHcCm5NbpXJdqCM44nZUObeieToN5bRMVFvIa0DMqNNLIbVrdWtza3NrCmok0WxGkb5boyK1VBXwI5J/I2gSIYY7AtNMSnqF8R1lBlvoMx5URZERjLsulkRHZshuhXdSm6lapjBsRiW6JgNq9+4kqPfQlKcU0WqjVgMe/CSRdSD7+hW7djYFMlQ+
|
|
2155
|
+
"bytecode": "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",
|
|
2156
|
+
"debug_symbols": "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"
|
|
2157
2157
|
},
|
|
2158
2158
|
{
|
|
2159
2159
|
"name": "update",
|
|
@@ -2216,8 +2216,8 @@
|
|
|
2216
2216
|
}
|
|
2217
2217
|
}
|
|
2218
2218
|
},
|
|
2219
|
-
"bytecode": "
|
|
2220
|
-
"debug_symbols": "
|
|
2219
|
+
"bytecode": "JwACBAEoAAABBIBMJwAABEwlAAAAQScCAwQBJwIEBAAfCgADAAQASy0ISwIlAAAAqicCAgRMJwIDBAA7DgADAAInAEMAAywAAEQALc/6U80Ocdp7SiJnezNCv8O5BD9Qgb6lg2itAI6qbzcsAABFADBkTnLhMaApuFBFtoGBWF0oM+hIeblwkUPh9ZPwAAAAJwBGBAMnAEcAACcASAEBJwBJBAEnAEoAASYlAAAGKR4CAAQBCiIERQUWCgUGHAoGBwAEKgcEBicCBAEACioFBAckAgAHAAAA4icCCAQAPAYIAR4CAAUAKQIABwADbVJ/LQgBCCcCCQQEAAgBCQEnAwgEAQAiCAIJLQoJCi0OBwoAIgoCCi0OBQoAIgoCCi0OBgonAgkECi0IAAotCggMLQhGDQAIAAkAJQAABk8tAgAALQoMBTMKAAUACCQCAAgAAAFYJQAACaQtCAEFJwIIBAQACAEIAScDBQQBACIFAggtCggJLQ4HCQAiCQIJLQxDCQAiCQIJLQ4CCScCCAQJLQgACS0KBQstCEYMAAgACAAlAAAGTy0CAAAtCgsHMwoABwAFJAIABQAAAcAlAAAJtikCAAUA71JTTS0IAQcnAggEBAAIAQgBJwMHBAEAIgcCCC0KCAktDgUJACIJAgktDEoJACIJAgktDgYJJwIIBAktCAAJLQoHCy0IRgwACAAIACUAAAZPLQIAAC0KCwUKIgVHBwoqBwQIJAIACAAAAjUlAAAJyB4CAAQALyoABQAEAAcAIgVKBB4CAAgALyoABAAIAAknAggAAgAqBQgKHgIACwAvKgAKAAsADBwKBw0EHAoNCwAcCgsHBR4CAAsALyoABQALAA0cCg0OBBwKDgsAAioNCw4sAgALAC1eCYuCuje0O5mhMWEY/SDUL1FmyenxP7XqZaltHgptBCoOCw0cCg0PBBwKDw4AAioNDg8EKg8LDRwKDRABHAoQDwAcCg8QAQIqDQ8RLAIADQAwM+okblBuiY6X9XDK/9cEywu0YDE/tyCynhOeXBAAAQQqEQ0SHAoSEwQcChMRAAIqEhETBCoTCxIcChITARwKEwsAHAoLEwECKhILFAQqFA0SHAoSFAQcChQNABwKDRIFFgoTDRwKCxMFHAoNFAUEKhMSDRwKERIFFgoQERwKDxAFHAoRFQUEKhASERwKDhIFHgIAFgYMKhYSFykCABIFAAFRgCQCABcAAAOyIwAAA54EKhAREwQqFRIQACoTEAMjAAADxgQqEw0QBCoUEhMAKhATAyMAAAPGACoWAxAOKhYQEiQCABIAAAPdJQAACdoMKhYHAxYKAwccCgMSABwKBwMABCoSCQcEKgMMCQAqBwkDHAoQBwAnAgkAICcCEAQSLQgAEi0KCBQtCgkVAAgAEAAlAAAJ7C0CAAAtChQMBCoODAkAKgcJDCcCCQBAJwIQBBItCAASLQoIFC0KCRUACAAQACUAAAnsLQIAAC0KFA4EKg8OCQAqDAkOHAoRCQAnAgwASCcCEAQRLQgAES0KCBMtCgwUAAgAEAAlAAAJ7C0CAAAtChMPBCoJDwwAKg4MCScCDABoJwIPBBAtCAAQLQoIEi0KDBMACAAPACUAAAnsLQIAAC0KEg4EKgsODAAqCQwLHAoNCQAnAgwAcCcCDgQPLQgADy0KCBEtCgwSAAgADgAlAAAJ7C0CAAAtChENBCoJDQgAKgsICSsCAAgAAAAAAAAAAAMAAAAAAAAAAC0IAQsnAgwEBQAIAQwBJwMLBAEAIgsCDC0KDA0tDgkNACINAg0tDgMNACINAg0tDgINACINAg0tDggNLQgBCCcCDAQFAAgBDAEnAwgEAQAiCwIMACIIAg0/DwAMAA0AIghJDC0LDAswCgAJAAUwCgADAAQwCgACAAoAIgVDBDAKAAsABCcCBQQFJwIJBAMAKgUJCC0IAQQACAEIAScDBAQBACIEAggtDgUIACIIAggtDgUIJwIIBAMAKgQIBS0KBQgtDEQIACIIAggtDgYIACIIAggtDgMIACIIAggtDgIIACIIAggtDgcIJwICBAUAIgQCBi0LBgYtCgYFJwIHBAMAKgQHAzcOAAUAAyYoAAAEBHhMDAAABAMkAAADAAAGTioBAAEF2sX11rRKMm08BAIBJiUAAAYpHAoDBQArAgAGAAAAAAAAAAABAAAAAAAAAAAEKgUGBy0IAQUAAAECAS0IAQYnAggEBQAIAQgBJwMGBAEAIgYCCC0KCAktDEcJACIJAgktDEcJACIJAgktDEcJACIJAgktDgcJLQ4GBQYiA0YGJwIHBAAnAggEAi0KBwQjAAAG0wwqBAYJJAIACQAACEYjAAAG5QYiA0YGBCIGRgkCKgMJBAoqBAcGFgoGCSQCAAYAAAftIwAABwoCKgMEBg4qBAMKJAIACgAAByElAAAK2S0LBQoAIgpJDC0LDAsMIgZGDCQCAAwAAAdAJQAACusAIgICDQAqDQYOLQsODAAqCwwNLQIKAycABAQFJQAACv0tCAULACILSQwtDg0MLQ4LBQwoSQQKJAIACgAAB4QjAAAH7QAqCwgKLQsKBAAiBkkKDioGCgwkAgAMAAAHpCUAAAnaDCIKRgYkAgAGAAAHtiUAAArrACICAgwAKgwKDS0LDQYAKgQGAi0CCwMnAAQEBSUAAAr9LQgFBAAqBAgGLQ4CBi0OBAUjAAAH7QoqAwcCEioCCQMkAgADAAAIBCMAAAg0LQsFAi0IAQMnAgQEBQAIAQQBJwMDBAEAIgICBAAiAwIGPw8ABAAGLQ4DBSMAAAg0LQsFAgAiAkkELQsEAy0KAwImLQsFCQAiCUkLLQsLCgQiBEYLBiILRg0KKg0EDCQCAAwAAAhvJQAAC1wMIgtGDCQCAAwAAAiBJQAACusAIgICDQAqDQsOLQsODAAqCgwNLQIJAycABAQFJQAACv0tCAUKACIKSQwtDg0MACoKCAwtCwwJACILSQwOKgsMDSQCAA0AAAjPJQAACdoMIgxGDSQCAA0AAAjhJQAACusAIgICDgAqDgwPLQsPDQAqCQ0MLQIKAycABAQFJQAACv0tCAUJACoJCA0tDgwNACIJRgwtCwwKACoLCAwOKgsMDSQCAA0AAAkvJQAACdoMIgxGCyQCAAsAAAlBJQAACusAIgICDQAqDQwOLQsOCwAqCgsMLQIJAycABAQFJQAACv0tCAUKACIKRgstDgwLLQgBCScCCwQFAAgBCwEnAwkEAQAiCgILACIJAgw/DwALAAwtDgkFACIESQktCgkEIwAABtMqAQABBdUSfSnC0ujtPAQCASYqAQABBa6Sj2upjpKMPAQCASYqAQABBbq7IdeCMxhkPAQCASYqAQABBdAH6/TLxmeQPAQCASYlAAAGKS0IAQUAAAECAS0MSgUnAgcEAicCCAEBLQgBBicCCQQhAAgBCQEnAwYEAQAiBgIJJwIKBCBDA6oAAwAHAAoACAAJLQIJAy0CCgQlAAALbicCAwQhJwIHBCAtCEkEIwAAClIMKgQDCCQCAAgAAAppIwAACmQtCwUCJi0LBQgEKggICQIqBwQIDioEBwokAgAKAAAKiSUAAArZDCoIBwokAgAKAAAKmyUAAArrACIGAgsAKgsIDC0LDAocCgoIAAQqCQIKBCoICgsCKEoICgQqCgkIACoLCAktDgkFACIESQgtCggEIwAAClIqAQABBRu8ZdA/3OrcPAQCASYqAQABBeQIUEUCtYwfPAQCASYtAQMGCgAGAgckAAAHAAALEyMAAAscLQADBSMAAAtbLQABBQAAAQQBAAADBAktAAMKLQAFCwoACgkMJAAADAAAC1YtAQoILQQICwAACgIKAAALAgsjAAALMicBBQQBJioBAAEFBQQbmSCvYEw8BAIBJicABgQCBgAEBgUtAAQIJwAJBAAOAAUJCiQAAAoAAAvBAgAIAggAAAMJCy0BCwYAAAMICy0BCwcAAAMJCy0EBwsAAAMICy0EBgsAAAkCCSMAAAuBJg==",
|
|
2220
|
+
"debug_symbols": "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"
|
|
2221
2221
|
}
|
|
2222
2222
|
],
|
|
2223
2223
|
"outputs": {
|
|
@@ -2821,13 +2821,13 @@
|
|
|
2821
2821
|
"path": "std/hash/mod.nr",
|
|
2822
2822
|
"source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3<let N: u32>(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n crate::assert_constant(separator);\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars, true)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n crate::assert_constant(starting_index);\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Decompose the input 'bn254 scalar' into two 128 bits limbs.\n// It is called 'unsafe' because it does not assert the limbs are 128 bits\n// Assuming the limbs are 128 bits:\n// Assert the decomposition does not overflow the field size.\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n // Check that the decomposition does not overflow the field size\n let (a, b) = if xhi == crate::field::bn254::PHI {\n (xlo, crate::field::bn254::PLO)\n } else {\n (xhi, crate::field::bn254::PHI)\n };\n crate::field::bn254::assert_lt(a, b);\n\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation<let N: u32>(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal<let N: u32>(input: [Field; N]) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher for BuildHasherDefault<H>\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u8 as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u16 as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u32 as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u64 as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash<H>(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl<T> Hash for [T]\nwhere\n T: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n"
|
|
2823
2823
|
},
|
|
2824
|
-
"
|
|
2824
|
+
"233": {
|
|
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 `
|
|
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 `aztec_utl_assertCompatibleOracleVersion` oracle is\n/// called\n/// and if the oracle version is incompatible an error is thrown.\npub global ORACLE_VERSION: Field = 14;\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(aztec_utl_assertCompatibleOracleVersion)]\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
|
"3": {
|
|
2829
2829
|
"path": "std/array/mod.nr",
|
|
2830
|
-
"source": "use crate::cmp::{Eq, Ord};\nuse crate::convert::From;\nuse crate::runtime::is_unconstrained;\n\nmod check_shuffle;\nmod quicksort;\n\nimpl<T, let N: u32> [T; N] {\n /// Returns the length of this array.\n ///\n /// ```noir\n /// fn len(self) -> Field\n /// ```\n ///\n /// example\n ///\n /// ```noir\n /// fn main() {\n /// let array = [42, 42];\n /// assert(array.len() == 2);\n /// }\n /// ```\n #[builtin(array_len)]\n pub fn len(self) -> u32 {}\n\n /// Returns this array as a vector.\n ///\n /// ```noir\n /// let array = [1, 2];\n /// let vector = array.as_vector();\n /// assert_eq(vector, [1, 2].as_vector());\n /// ```\n #[builtin(as_vector)]\n pub fn as_vector(self) -> [T] {}\n\n /// Returns this array as a vector.\n /// This method is deprecated in favor of `as_vector`.\n ///\n /// ```noir\n /// let array = [1, 2];\n /// let vector = array.as_slice();\n /// assert_eq(vector, [1, 2].as_vector());\n /// ```\n #[builtin(as_vector)]\n #[deprecated(\"This method has been renamed to `as_vector`\")]\n pub fn as_slice(self) -> [T] {}\n\n /// Applies a function to each element of this array, returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.map(|a| a * 2);\n /// assert_eq(b, [2, 4, 6]);\n /// ```\n pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array along with its index,\n /// returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.mapi(|i, a| i + a * 2);\n /// assert_eq(b, [2, 5, 8]);\n /// ```\n pub fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(i, self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// let mut i = 0;\n /// a.for_each(|x| {\n /// b[i] = x;\n /// i += 1;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_each<Env>(self, f: fn[Env](T) -> ()) {\n for i in 0..self.len() {\n f(self[i]);\n }\n }\n\n /// Applies a function to each element of this array along with its index.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// a.for_eachi(|i, x| {\n /// b[i] = x;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ()) {\n for i in 0..self.len() {\n f(i, self[i]);\n }\n }\n\n /// Applies a function to each element of the array, returning the final accumulated value. The first\n /// parameter is the initial value.\n ///\n /// This is a left fold, so the given function will be applied to the accumulator and first element of\n /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\n ///\n /// ```rust\n /// let a1 = [1];\n /// let a2 = [1, 2];\n /// let a3 = [1, 2, 3];\n ///\n /// let f = |a, b| a - b;\n /// a1.fold(10, f); //=> f(10, 1)\n /// a2.fold(10, f); //=> f(f(10, 1), 2)\n /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\n ///\n /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\n /// ```\n pub fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\n for elem in self {\n accumulator = f(accumulator, elem);\n }\n accumulator\n }\n\n /// Same as fold, but uses the first element as the starting element.\n ///\n /// Requires the input array to be non-empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [1, 2, 3, 4];\n /// let reduced = arr.reduce(|a, b| a + b);\n /// assert(reduced == 10);\n /// }\n /// ```\n pub fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T {\n let mut accumulator = self[0];\n for i in 1..self.len() {\n accumulator = f(accumulator, self[i]);\n }\n accumulator\n }\n\n /// Returns true if all the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 2];\n /// let all = arr.all(|a| a == 2);\n /// assert(all);\n /// }\n /// ```\n pub fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = true;\n for elem in self {\n ret &= predicate(elem);\n }\n ret\n }\n\n /// Returns true if any of the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 5];\n /// let any = arr.any(|a| a == 5);\n /// assert(any);\n /// }\n /// ```\n pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n for elem in self {\n ret |= predicate(elem);\n }\n ret\n }\n\n /// Concatenates this array with another array.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr1 = [1, 2, 3, 4];\n /// let arr2 = [6, 7, 8, 9, 10, 11];\n /// let concatenated_arr = arr1.concat(arr2);\n /// assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n /// }\n /// ```\n pub fn concat<let M: u32>(self, array2: [T; M]) -> [T; N + M] {\n let mut result = [crate::mem::zeroed(); N + M];\n for i in 0..N {\n result[i] = self[i];\n }\n for i in 0..M {\n result[i + N] = array2[i];\n }\n result\n }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n T: Ord + Eq,\n{\n /// Returns a new sorted array. The original array remains untouched. Notice that this function will\n /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\n /// logic it uses internally is optimized specifically for these values. If you need a sort function to\n /// sort any type, you should use the [`Self::sort_via`] function.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32];\n /// let sorted = arr.sort();\n /// assert(sorted == [32, 42]);\n /// }\n /// ```\n pub fn sort(self) -> Self {\n self.sort_via(|a, b| a <= b)\n }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n T: Eq,\n{\n /// Returns a new sorted array by sorting it with a custom comparison function.\n /// The original array remains untouched.\n /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\n ///\n /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32]\n /// let sorted_ascending = arr.sort_via(|a, b| a <= b);\n /// assert(sorted_ascending == [32, 42]); // verifies\n ///\n /// let sorted_descending = arr.sort_via(|a, b| a >= b);\n /// assert(sorted_descending == [32, 42]); // does not verify\n /// }\n /// ```\n pub fn sort_via<Env>(self, ordering: fn[Env](T, T) -> bool) -> Self {\n // Safety: `sorted` array is checked to be:\n // a. a permutation of `input`'s elements\n // b. satisfying the predicate `ordering`\n let sorted = unsafe { quicksort::quicksort(self, ordering) };\n\n if !is_unconstrained() {\n for i in 0..N - 1 {\n assert(\n ordering(sorted[i], sorted[i + 1]),\n \"Array has not been sorted correctly according to `ordering`.\",\n );\n }\n check_shuffle::check_shuffle(self, sorted);\n }\n sorted\n }\n}\n\nimpl<let N: u32> [u8; N] {\n /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\n /// the given array is interpreted as-is as a string.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let hi = [104, 105].as_str_unchecked();\n /// assert_eq(hi, \"hi\");\n /// }\n /// ```\n #[builtin(array_as_str_unchecked)]\n pub fn as_str_unchecked(self) -> str<N> {}\n}\n\nimpl<let N: u32> From<str<N>> for [u8; N] {\n /// Returns an array of the string bytes.\n fn from(s: str<N>) -> Self {\n s.as_bytes()\n }\n}\n\nmod test {\n #[test]\n fn map_empty() {\n assert_eq([].map(|x| x + 1), []);\n }\n\n global arr_with_100_values: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2, 54,\n 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41, 19, 98,\n 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21, 43, 86, 35,\n 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15, 127, 81, 30, 8,\n 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n global expected_with_100_values: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30, 32,\n 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58, 61, 62,\n 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82, 84, 84, 86,\n 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114, 114, 116, 118,\n 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n fn sort_u32(a: u32, b: u32) -> bool {\n a <= b\n }\n\n #[test]\n fn test_sort() {\n let mut arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n let sorted = arr.sort();\n\n let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_100_values() {\n let mut arr: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n 54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n 19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n 43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n 127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n\n let sorted = arr.sort();\n\n let expected: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n 32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n 61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n 84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n 114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_100_values_comptime() {\n let sorted = arr_with_100_values.sort();\n assert(sorted == expected_with_100_values);\n }\n\n #[test]\n fn test_sort_via() {\n let mut arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n let sorted = arr.sort_via(sort_u32);\n\n let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_via_100_values() {\n let mut arr: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n 54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n 19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n 43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n 127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n\n let sorted = arr.sort_via(sort_u32);\n\n let expected: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n 32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n 61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n 84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n 114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n assert(sorted == expected);\n }\n\n #[test]\n fn mapi_empty() {\n assert_eq([].mapi(|i, x| i * x + 1), []);\n }\n\n #[test]\n fn for_each_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_each(|_x| assert(false));\n }\n\n #[test]\n fn for_eachi_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_eachi(|_i, _x| assert(false));\n }\n\n #[test]\n fn map_example() {\n let a = [1, 2, 3];\n let b = a.map(|a| a * 2);\n assert_eq(b, [2, 4, 6]);\n }\n\n #[test]\n fn mapi_example() {\n let a = [1, 2, 3];\n let b = a.mapi(|i, a| i + a * 2);\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn for_each_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n let mut i = 0;\n let i_ref = &mut i;\n a.for_each(|x| {\n b_ref[*i_ref] = x * 2;\n *i_ref += 1;\n });\n assert_eq(b, [2, 4, 6]);\n assert_eq(i, 3);\n }\n\n #[test]\n fn for_eachi_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn concat() {\n let arr1 = [1, 2, 3, 4];\n let arr2 = [6, 7, 8, 9, 10, 11];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n }\n\n #[test]\n fn concat_zero_length_with_something() {\n let arr1 = [];\n let arr2 = [1];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_something_with_zero_length() {\n let arr1 = [1];\n let arr2 = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_zero_lengths() {\n let arr1: [Field; 0] = [];\n let arr2: [Field; 0] = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, []);\n }\n}\n"
|
|
2830
|
+
"source": "use crate::cmp::{Eq, Ord};\nuse crate::convert::From;\nuse crate::runtime::is_unconstrained;\n\nmod check_shuffle;\nmod quicksort;\n\nimpl<T, let N: u32> [T; N] {\n /// Returns the length of this array.\n ///\n /// ```noir\n /// fn len(self) -> Field\n /// ```\n ///\n /// example\n ///\n /// ```noir\n /// fn main() {\n /// let array = [42, 42];\n /// assert(array.len() == 2);\n /// }\n /// ```\n #[builtin(array_len)]\n pub fn len(self) -> u32 {}\n\n /// Returns this array as a vector.\n ///\n /// ```noir\n /// let array = [1, 2];\n /// let vector = array.as_vector();\n /// assert_eq(vector, [1, 2].as_vector());\n /// ```\n #[builtin(as_vector)]\n pub fn as_vector(self) -> [T] {}\n\n /// Returns this array as a vector.\n /// This method is deprecated in favor of `as_vector`.\n ///\n /// ```noir\n /// let array = [1, 2];\n /// let vector = array.as_slice();\n /// assert_eq(vector, [1, 2].as_vector());\n /// ```\n #[builtin(as_vector)]\n #[deprecated(\"This method has been renamed to `as_vector`\")]\n pub fn as_slice(self) -> [T] {}\n\n /// Applies a function to each element of this array, returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.map(|a| a * 2);\n /// assert_eq(b, [2, 4, 6]);\n /// ```\n pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array along with its index,\n /// returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.mapi(|i, a| i + a * 2);\n /// assert_eq(b, [2, 5, 8]);\n /// ```\n pub fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(i, self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// let mut i = 0;\n /// a.for_each(|x| {\n /// b[i] = x;\n /// i += 1;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_each<Env>(self, f: fn[Env](T) -> ()) {\n for i in 0..self.len() {\n f(self[i]);\n }\n }\n\n /// Applies a function to each element of this array along with its index.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// a.for_eachi(|i, x| {\n /// b[i] = x;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ()) {\n for i in 0..self.len() {\n f(i, self[i]);\n }\n }\n\n /// Applies a function to each element of the array, returning the final accumulated value. The first\n /// parameter is the initial value.\n ///\n /// This is a left fold, so the given function will be applied to the accumulator and first element of\n /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\n ///\n /// ```rust\n /// let a1 = [1];\n /// let a2 = [1, 2];\n /// let a3 = [1, 2, 3];\n ///\n /// let f = |a, b| a - b;\n /// a1.fold(10, f); //=> f(10, 1)\n /// a2.fold(10, f); //=> f(f(10, 1), 2)\n /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\n ///\n /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\n /// ```\n pub fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\n for elem in self {\n accumulator = f(accumulator, elem);\n }\n accumulator\n }\n\n /// Same as fold, but uses the first element as the starting element.\n ///\n /// Requires the input array to be non-empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [1, 2, 3, 4];\n /// let reduced = arr.reduce(|a, b| a + b);\n /// assert(reduced == 10);\n /// }\n /// ```\n pub fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T {\n let mut accumulator = self[0];\n for i in 1..self.len() {\n accumulator = f(accumulator, self[i]);\n }\n accumulator\n }\n\n /// Returns true if all the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 2];\n /// let all = arr.all(|a| a == 2);\n /// assert(all);\n /// }\n /// ```\n pub fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = true;\n for elem in self {\n ret &= predicate(elem);\n }\n ret\n }\n\n /// Returns true if any of the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 5];\n /// let any = arr.any(|a| a == 5);\n /// assert(any);\n /// }\n /// ```\n pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n for elem in self {\n ret |= predicate(elem);\n }\n ret\n }\n\n /// Concatenates this array with another array.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr1 = [1, 2, 3, 4];\n /// let arr2 = [6, 7, 8, 9, 10, 11];\n /// let concatenated_arr = arr1.concat(arr2);\n /// assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n /// }\n /// ```\n pub fn concat<let M: u32>(self, array2: [T; M]) -> [T; N + M] {\n let mut result = [crate::mem::zeroed(); N + M];\n for i in 0..N {\n result[i] = self[i];\n }\n for i in 0..M {\n result[i + N] = array2[i];\n }\n result\n }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n T: Ord + Eq,\n{\n /// Returns a new sorted array. The original array remains untouched. Notice that this function will\n /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\n /// logic it uses internally is optimized specifically for these values. If you need a sort function to\n /// sort any type, you should use the [`Self::sort_via`] function.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32];\n /// let sorted = arr.sort();\n /// assert(sorted == [32, 42]);\n /// }\n /// ```\n pub fn sort(self) -> Self {\n self.sort_via(|a, b| a <= b)\n }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n T: Eq,\n{\n /// Returns a new sorted array by sorting it with a custom comparison function.\n /// The original array remains untouched.\n /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\n ///\n /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32]\n /// let sorted_ascending = arr.sort_via(|a, b| a <= b);\n /// assert(sorted_ascending == [32, 42]); // verifies\n ///\n /// let sorted_descending = arr.sort_via(|a, b| a >= b);\n /// assert(sorted_descending == [32, 42]); // does not verify\n /// }\n /// ```\n pub fn sort_via<Env>(self, ordering: fn[Env](T, T) -> bool) -> Self {\n // Safety: `sorted` array is checked to be:\n // a. a permutation of `input`'s elements\n // b. satisfying the predicate `ordering`\n let sorted = unsafe { quicksort::quicksort(self, ordering) };\n\n if !is_unconstrained() {\n for i in 0..N - 1 {\n assert(\n ordering(sorted[i], sorted[i + 1]),\n \"Array has not been sorted correctly according to `ordering`.\",\n );\n }\n check_shuffle::check_shuffle(self, sorted);\n }\n sorted\n }\n}\n\nimpl<let N: u32> [u8; N] {\n /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\n /// the given array is interpreted as-is as a string.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let hi = [104, 105].as_str_unchecked();\n /// assert_eq(hi, \"hi\");\n /// }\n /// ```\n #[builtin(array_as_str_unchecked)]\n pub fn as_str_unchecked(self) -> str<N> {}\n}\n\nimpl<let N: u32> From<str<N>> for [u8; N] {\n /// Returns an array of the string bytes.\n fn from(s: str<N>) -> Self {\n s.as_bytes()\n }\n}\n\nmod test {\n #[test]\n fn map_empty() {\n assert_eq([].map(|x| x + 1), []);\n }\n\n global arr_with_100_values: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2, 54,\n 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41, 19, 98,\n 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21, 43, 86, 35,\n 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15, 127, 81, 30, 8,\n 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n global expected_with_100_values: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30, 32,\n 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58, 61, 62,\n 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82, 84, 84, 86,\n 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114, 114, 116, 118,\n 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n fn sort_u32(a: u32, b: u32) -> bool {\n a <= b\n }\n\n #[test]\n fn test_sort() {\n let arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n let sorted = arr.sort();\n\n let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_100_values() {\n let arr: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n 54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n 19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n 43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n 127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n\n let sorted = arr.sort();\n\n let expected: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n 32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n 61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n 84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n 114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_100_values_comptime() {\n let sorted = arr_with_100_values.sort();\n assert(sorted == expected_with_100_values);\n }\n\n #[test]\n fn test_sort_via() {\n let arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n let sorted = arr.sort_via(sort_u32);\n\n let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_via_100_values() {\n let arr: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n 54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n 19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n 43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n 127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n\n let sorted = arr.sort_via(sort_u32);\n\n let expected: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n 32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n 61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n 84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n 114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n assert(sorted == expected);\n }\n\n #[test]\n fn mapi_empty() {\n assert_eq([].mapi(|i, x| i * x + 1), []);\n }\n\n #[test]\n fn for_each_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_each(|_x| assert(false));\n }\n\n #[test]\n fn for_eachi_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_eachi(|_i, _x| assert(false));\n }\n\n #[test]\n fn map_example() {\n let a = [1, 2, 3];\n let b = a.map(|a| a * 2);\n assert_eq(b, [2, 4, 6]);\n }\n\n #[test]\n fn mapi_example() {\n let a = [1, 2, 3];\n let b = a.mapi(|i, a| i + a * 2);\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn for_each_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n let mut i = 0;\n let i_ref = &mut i;\n a.for_each(|x| {\n b_ref[*i_ref] = x * 2;\n *i_ref += 1;\n });\n assert_eq(b, [2, 4, 6]);\n assert_eq(i, 3);\n }\n\n #[test]\n fn for_eachi_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn concat() {\n let arr1 = [1, 2, 3, 4];\n let arr2 = [6, 7, 8, 9, 10, 11];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n }\n\n #[test]\n fn concat_zero_length_with_something() {\n let arr1 = [];\n let arr2 = [1];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_something_with_zero_length() {\n let arr1 = [1];\n let arr2 = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_zero_lengths() {\n let arr1: [Field; 0] = [];\n let arr2: [Field; 0] = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, []);\n }\n}\n"
|
|
2831
2831
|
},
|
|
2832
2832
|
"300": {
|
|
2833
2833
|
"path": "/home/aztec-dev/nargo/github.com/noir-lang/poseidon/v0.2.6/src/poseidon2.nr",
|
|
@@ -2835,7 +2835,7 @@
|
|
|
2835
2835
|
},
|
|
2836
2836
|
"358": {
|
|
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 `true` if the address is valid.\n ///\n /// An invalid address is one that can be proven to not be correctly derived, meaning it contains no contract code,\n /// public keys, etc., and can therefore not receive messages nor execute calls.\n pub fn is_valid(self) -> bool {\n self.get_y().is_some()\n }\n\n /// Returns an address's [`AddressPoint`].\n ///\n /// This can be used to create shared secrets with the owner of the address. If the address is invalid (see\n /// [`AztecAddress::is_valid`]) then this returns `Option::none()`, and no shared secrets can be created.\n pub fn to_address_point(self) -> Option<AddressPoint> {\n self.get_y().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 /// Returns one of the two possible y-coordinates.\n ///\n /// Not all `AztecAddresses` are valid, in which case there is no corresponding y-coordinate. This returns\n /// `Option::none()` for invalid addresses.\n ///\n /// An `AztecAddress` is defined by an x-coordinate, for which two y-coordinates exist as solutions to the curve\n /// equation. This function returns either of them. Note that an [`AddressPoint`] must **always** have a positive\n /// y-coordinate - if trying to obtain the underlying point use [`AztecAddress::to_address_point`] instead.\n fn get_y(self) -> Option<Field> {\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 sqrt(y_squared)\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\n assert(address.get_y().is_some()); // We don't bother checking the result of get_y as it is only used internally\n assert(address.is_valid());\n\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\n assert(address.get_y().is_none());\n assert(!address.is_valid());\n\n assert(address.to_address_point().is_none());\n}\n"
|
|
2839
2839
|
},
|
|
2840
2840
|
"361": {
|
|
2841
2841
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/partial_address.nr",
|
|
@@ -2859,11 +2859,11 @@
|
|
|
2859
2859
|
},
|
|
2860
2860
|
"389": {
|
|
2861
2861
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
|
|
2862
|
-
"source": "mod poseidon2_chunks;\n\nuse crate::{\n abis::{\n contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n function_selector::FunctionSelector, nullifier::Nullifier, private_log::PrivateLog,\n transaction::tx_request::TxRequest,\n },\n address::{AztecAddress, EthAddress},\n constants::{\n CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, DOM_SEP__NOTE_HASH_NONCE,\n DOM_SEP__PRIVATE_LOG_FIRST_FIELD, DOM_SEP__SILOED_NOTE_HASH, DOM_SEP__SILOED_NULLIFIER,\n DOM_SEP__UNIQUE_NOTE_HASH, FUNCTION_TREE_HEIGHT, NULL_MSG_SENDER_CONTRACT_ADDRESS,\n TWO_POW_64,\n },\n merkle_tree::root_from_sibling_path,\n messaging::l2_to_l1_message::L2ToL1Message,\n poseidon2::Poseidon2Sponge,\n side_effect::{Counted, Scoped},\n traits::{FromField, Hash, ToField},\n utils::field::{field_from_bytes, field_from_bytes_32_trunc},\n};\n\npub use poseidon2_chunks::poseidon2_absorb_in_chunks_existing_sponge;\nuse poseidon2_chunks::poseidon2_absorb_in_chunks;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\n// TODO: refactor these into their own files: sha256, poseidon2, some protocol-specific hash computations, some merkle computations.\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n let sha256_hashed = sha256::digest(bytes_to_hash);\n let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n selector: FunctionSelector,\n vk_hash: Field,\n function_leaf_index: Field,\n function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n let function_leaf = function_leaf_preimage.hash();\n root_from_sibling_path(\n function_leaf,\n function_leaf_index,\n function_leaf_sibling_path,\n )\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn compute_siloed_note_hash(contract_address: AztecAddress, note_hash: Field) -> Field {\n poseidon2_hash_with_separator(\n [contract_address.to_field(), note_hash],\n DOM_SEP__SILOED_NOTE_HASH,\n )\n}\n\n/// Computes unique, siloed note hashes from siloed note hashes.\n///\n/// The protocol injects uniqueness into every note_hash, so that every single note_hash in the\n/// tree is unique. This prevents faerie gold attacks, where a malicious sender could create\n/// two identical note_hashes for a recipient (meaning only one would be nullifiable in future).\n///\n/// Most privacy protocols will inject the note's leaf_index (its position in the Note Hashes Tree)\n/// into the note, but this requires the creator of a note to wait until their tx is included in\n/// a block to know the note's final note hash (the unique, siloed note hash), because inserting\n/// leaves into trees is the job of a block producer.\n///\n/// We took a different approach so that the creator of a note will know each note's unique, siloed\n/// note hash before broadcasting their tx to the network.\n/// (There was also a historical requirement relating to \"chained transactions\" -- a feature that\n/// Aztec Connect had to enable notes to be spent from distinct txs earlier in the same block,\n/// and hence before an archive block root had been established for that block -- but that feature\n/// was abandoned for the Aztec Network for having too many bad tradeoffs).\n///\n/// (\n/// Edit: it is no longer true that all final note_hashes will be known by the creator of a tx\n/// before they send it to the network. If a tx makes public function calls, then _revertible_\n/// note_hashes that are created in private will not be made unique in private by the Reset circuit,\n/// but will instead be made unique by the AVM, because the `note_index_in_tx` will not be known\n/// until the AVM has executed the public functions of the tx. (See an explanation in\n/// reset_output_composer.nr for why).\n/// For some such txs, the `note_index_in_tx` might still be predictable through simulation, but\n/// for txs whose public functions create a varying number of non-revertible notes (determined at\n/// runtime), the `note_index_in_tx` will not be deterministically derivable before submitting the\n/// tx to the network.\n/// )\n///\n/// We use the `first_nullifier` of a tx as a seed of uniqueness. We have a guarantee that there will\n/// always be at least one nullifier per tx, because the init circuit will create one if one isn't\n/// created naturally by any functions of the tx. (Search \"protocol_nullifier\").\n/// We combine the `first_nullifier` with the note's index (its position within this tx's new\n/// note_hashes array) (`note_index_in_tx`) to get a truly unique value to inject into a note, which\n/// we call a `note_nonce`.\npub fn compute_unique_note_hash(note_nonce: Field, siloed_note_hash: Field) -> Field {\n let inputs = [note_nonce, siloed_note_hash];\n poseidon2_hash_with_separator(inputs, DOM_SEP__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n // unique).\n poseidon2_hash_with_separator(\n [first_nullifier_in_tx, note_index_in_tx as Field],\n DOM_SEP__NOTE_HASH_NONCE,\n )\n}\n\npub fn compute_note_nonce_and_unique_note_hash(\n siloed_note_hash: Field,\n first_nullifier: Field,\n note_index_in_tx: u32,\n) -> Field {\n let note_nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n compute_unique_note_hash(note_nonce, siloed_note_hash)\n}\n\npub fn compute_siloed_nullifier(contract_address: AztecAddress, nullifier: Field) -> Field {\n poseidon2_hash_with_separator(\n [contract_address.to_field(), nullifier],\n DOM_SEP__SILOED_NULLIFIER,\n )\n}\n\npub fn create_protocol_nullifier(tx_request: TxRequest) -> Scoped<Counted<Nullifier>> {\n // The protocol nullifier is ascribed a special side-effect counter of 1. No other side-effect\n // can have counter 1 (see `validate_as_first_call` for that assertion).\n Nullifier { value: tx_request.hash(), note_hash: 0 }.count(1).scope(\n NULL_MSG_SENDER_CONTRACT_ADDRESS,\n )\n}\n\npub fn compute_siloed_private_log_first_field(\n contract_address: AztecAddress,\n field: Field,\n) -> Field {\n poseidon2_hash_with_separator(\n [contract_address.to_field(), field],\n DOM_SEP__PRIVATE_LOG_FIRST_FIELD,\n )\n}\n\npub fn compute_siloed_private_log(contract_address: AztecAddress, log: PrivateLog) -> PrivateLog {\n let mut fields = log.fields;\n fields[0] = compute_siloed_private_log_first_field(contract_address, fields[0]);\n PrivateLog::new(fields, log.length)\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n poseidon2_hash(log)\n}\n\npub fn compute_app_siloed_secret_key(\n master_secret_key: EmbeddedCurveScalar,\n app_address: AztecAddress,\n key_type_domain_separator: Field,\n) -> Field {\n poseidon2_hash_with_separator(\n [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n key_type_domain_separator,\n )\n}\n\npub fn compute_l2_to_l1_message_hash(\n message: Scoped<L2ToL1Message>,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n let contract_address_bytes: [u8; 32] = message.contract_address.to_field().to_be_bytes();\n let recipient_bytes: [u8; 20] = message.inner.recipient.to_be_bytes();\n let content_bytes: [u8; 32] = message.inner.content.to_be_bytes();\n let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n let mut bytes: [u8; 148] = std::mem::zeroed();\n for i in 0..32 {\n bytes[i] = contract_address_bytes[i];\n bytes[i + 32] = rollup_version_id_bytes[i];\n // 64 - 84 are for recipient.\n bytes[i + 84] = chain_id_bytes[i];\n bytes[i + 116] = content_bytes[i];\n }\n\n for i in 0..20 {\n bytes[64 + i] = recipient_bytes[i];\n }\n\n sha256_to_field(bytes)\n}\n\n// TODO: consider a variant that enables domain separation with a u32 (we seem to have standardised u32s for domain separators)\n/// Computes sha256 hash of 2 input fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256(v0: Field, v1: Field) -> Field {\n // Concatenate two fields into 32 x 2 = 64 bytes\n let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n let hash_input_flattened = v0_as_bytes.concat(v1_as_bytes);\n\n sha256_to_field(hash_input_flattened)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n T: ToField,\n{\n let inputs_with_separator = [separator.to_field()].concat(inputs);\n poseidon2_hash(inputs_with_separator)\n}\n\n/// Computes a Poseidon2 hash over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// The caller is responsible for ensuring that the input is padded with zeros if required.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n sponge.squeeze()\n}\n\n// This function is unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n inputs: BoundedVec<Field, N>,\n separator: T,\n) -> Field\nwhere\n T: ToField,\n{\n let in_len = inputs.len() + 1;\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n sponge.absorb(separator.to_field());\n\n for i in 0..inputs.len() {\n sponge.absorb(inputs.get(i));\n }\n\n sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n let mut fields = [0; (N + 30) / 31];\n let mut field_index = 0;\n let mut current_field = [0; 31];\n for i in 0..inputs.len() {\n let index = i % 31;\n current_field[index] = inputs[i];\n if index == 30 {\n fields[field_index] = field_from_bytes(current_field, false);\n current_field = [0; 31];\n field_index += 1;\n }\n }\n if field_index != fields.len() {\n fields[field_index] = field_from_bytes(current_field, false);\n }\n poseidon2_hash(fields)\n}\n\n#[test]\nfn subarray_hash_matches_fixed() {\n let mut values_to_hash = [3; 17];\n let mut padded = values_to_hash.concat([0; 11]);\n let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n // Hash the entire values_to_hash.\n let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(values_to_hash, values_to_hash.len());\n\n assert_eq(subarray_hash, fixed_len_hash);\n}\n\n#[test]\nfn subarray_hash_matches_variable() {\n let mut values_to_hash = [3; 17];\n let mut padded = values_to_hash.concat([0; 11]);\n let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n // Hash up to values_to_hash.len() fields of the padded array.\n let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(padded, values_to_hash.len());\n\n assert_eq(subarray_hash, variable_len_hash);\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n let full_buffer = [\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n ];\n let result = sha256_to_field(full_buffer);\n\n assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n let result_bytes = sha256::digest(full_buffer);\n let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n assert(truncated_field == result);\n let mod_res = result + (result_bytes[31] as Field);\n assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn unique_siloed_note_hash_matches_typescript() {\n let inner_note_hash = 1;\n let contract_address = AztecAddress::from_field(2);\n let first_nullifier = 3;\n let note_index_in_tx = 4;\n\n let siloed_note_hash = compute_siloed_note_hash(contract_address, inner_note_hash);\n let siloed_note_hash_from_ts =\n 0x1986a4bea3eddb1fff917d629a13e10f63f514f401bdd61838c6b475db949169;\n assert_eq(siloed_note_hash, siloed_note_hash_from_ts);\n\n let nonce: Field = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n let note_hash_nonce_from_ts =\n 0x28e7799791bf066a57bb51fdd0fbcaf3f0926414314c7db515ea343f44f5d58b;\n assert_eq(nonce, note_hash_nonce_from_ts);\n\n let unique_siloed_note_hash_from_nonce = compute_unique_note_hash(nonce, siloed_note_hash);\n let unique_siloed_note_hash = compute_note_nonce_and_unique_note_hash(\n siloed_note_hash,\n first_nullifier,\n note_index_in_tx,\n );\n assert_eq(unique_siloed_note_hash_from_nonce, unique_siloed_note_hash);\n\n let unique_siloed_note_hash_from_ts =\n 0x29949aef207b715303b24639737c17fbfeb375c1d965ecfa85c7e4f0febb7d16;\n assert_eq(unique_siloed_note_hash, unique_siloed_note_hash_from_ts);\n}\n\n#[test]\nfn siloed_nullifier_matches_typescript() {\n let contract_address = AztecAddress::from_field(123);\n let nullifier = 456;\n\n let res = compute_siloed_nullifier(contract_address, nullifier);\n\n let siloed_nullifier_from_ts =\n 0x169b50336c1f29afdb8a03d955a81e485f5ac7d5f0b8065673d1e407e5877813;\n\n assert_eq(res, siloed_nullifier_from_ts);\n}\n\n#[test]\nfn siloed_private_log_first_field_matches_typescript() {\n let contract_address = AztecAddress::from_field(123);\n let field = 456;\n let res = compute_siloed_private_log_first_field(contract_address, field);\n\n let siloed_private_log_first_field_from_ts =\n 0x29480984f7b9257fded523d50addbcfc8d1d33adcf2db73ef3390a8fd5cdffaa;\n\n assert_eq(res, siloed_private_log_first_field_from_ts);\n}\n\n#[test]\nfn empty_l2_to_l1_message_hash_matches_typescript() {\n // All zeroes\n let res = compute_l2_to_l1_message_hash(\n L2ToL1Message { recipient: EthAddress::zero(), content: 0 }.scope(AztecAddress::from_field(\n 0,\n )),\n 0,\n 0,\n );\n\n let empty_l2_to_l1_msg_hash_from_ts =\n 0x003b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992;\n\n assert_eq(res, empty_l2_to_l1_msg_hash_from_ts);\n}\n\n#[test]\nfn l2_to_l1_message_hash_matches_typescript() {\n let message = L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n AztecAddress::from_field(3),\n );\n let version = 4;\n let chainId = 5;\n\n let hash = compute_l2_to_l1_message_hash(message, version, chainId);\n\n // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n let l2_to_l1_message_hash_from_ts =\n 0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n assert_eq(hash, l2_to_l1_message_hash_from_ts);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n let separator = 42;\n\n // Hash using bounded vec version\n let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n // Hash using regular version\n let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n // Results should match\n assert_eq(bounded_result, regular_result);\n}\n"
|
|
2862
|
+
"source": "mod poseidon2_chunks;\n\nuse crate::{\n abis::{\n contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n function_selector::FunctionSelector, nullifier::Nullifier, private_log::PrivateLog,\n transaction::tx_request::TxRequest,\n },\n address::{AztecAddress, EthAddress},\n constants::{\n CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, DOM_SEP__NOTE_HASH_NONCE,\n DOM_SEP__PRIVATE_LOG_FIRST_FIELD, DOM_SEP__SILOED_NOTE_HASH, DOM_SEP__SILOED_NULLIFIER,\n DOM_SEP__UNIQUE_NOTE_HASH, FUNCTION_TREE_HEIGHT, NULL_MSG_SENDER_CONTRACT_ADDRESS,\n TWO_POW_64,\n },\n merkle_tree::root_from_sibling_path,\n messaging::l2_to_l1_message::L2ToL1Message,\n poseidon2::Poseidon2Sponge,\n side_effect::{Counted, Scoped},\n traits::{FromField, Hash, ToField},\n utils::field::{field_from_bytes, field_from_bytes_32_trunc},\n};\n\npub use poseidon2_chunks::poseidon2_absorb_in_chunks_existing_sponge;\nuse poseidon2_chunks::poseidon2_absorb_in_chunks;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\n// TODO: refactor these into their own files: sha256, poseidon2, some protocol-specific hash computations, some merkle computations.\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n let sha256_hashed = sha256::digest(bytes_to_hash);\n let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n selector: FunctionSelector,\n vk_hash: Field,\n function_leaf_index: Field,\n function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n let function_leaf = function_leaf_preimage.hash();\n root_from_sibling_path(\n function_leaf,\n function_leaf_index,\n function_leaf_sibling_path,\n )\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn compute_siloed_note_hash(contract_address: AztecAddress, note_hash: Field) -> Field {\n poseidon2_hash_with_separator(\n [contract_address.to_field(), note_hash],\n DOM_SEP__SILOED_NOTE_HASH,\n )\n}\n\n/// Computes unique, siloed note hashes from siloed note hashes.\n///\n/// The protocol injects uniqueness into every note_hash, so that every single note_hash in the\n/// tree is unique. This prevents faerie gold attacks, where a malicious sender could create\n/// two identical note_hashes for a recipient (meaning only one would be nullifiable in future).\n///\n/// Most privacy protocols will inject the note's leaf_index (its position in the Note Hashes Tree)\n/// into the note, but this requires the creator of a note to wait until their tx is included in\n/// a block to know the note's final note hash (the unique, siloed note hash), because inserting\n/// leaves into trees is the job of a block producer.\n///\n/// We took a different approach so that the creator of a note will know each note's unique, siloed\n/// note hash before broadcasting their tx to the network.\n/// (There was also a historical requirement relating to \"chained transactions\" -- a feature that\n/// Aztec Connect had to enable notes to be spent from distinct txs earlier in the same block,\n/// and hence before an archive block root had been established for that block -- but that feature\n/// was abandoned for the Aztec Network for having too many bad tradeoffs).\n///\n/// (\n/// Edit: it is no longer true that all final note_hashes will be known by the creator of a tx\n/// before they send it to the network. If a tx makes public function calls, then _revertible_\n/// note_hashes that are created in private will not be made unique in private by the Reset circuit,\n/// but will instead be made unique by the AVM, because the `note_index_in_tx` will not be known\n/// until the AVM has executed the public functions of the tx. (See an explanation in\n/// reset_output_composer.nr for why).\n/// For some such txs, the `note_index_in_tx` might still be predictable through simulation, but\n/// for txs whose public functions create a varying number of non-revertible notes (determined at\n/// runtime), the `note_index_in_tx` will not be deterministically derivable before submitting the\n/// tx to the network.\n/// )\n///\n/// We use the `first_nullifier` of a tx as a seed of uniqueness. We have a guarantee that there will\n/// always be at least one nullifier per tx, because the init circuit will create one if one isn't\n/// created naturally by any functions of the tx. (Search \"protocol_nullifier\").\n/// We combine the `first_nullifier` with the note's index (its position within this tx's new\n/// note_hashes array) (`note_index_in_tx`) to get a truly unique value to inject into a note, which\n/// we call a `note_nonce`.\npub fn compute_unique_note_hash(note_nonce: Field, siloed_note_hash: Field) -> Field {\n let inputs = [note_nonce, siloed_note_hash];\n poseidon2_hash_with_separator(inputs, DOM_SEP__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n // unique).\n poseidon2_hash_with_separator(\n [first_nullifier_in_tx, note_index_in_tx as Field],\n DOM_SEP__NOTE_HASH_NONCE,\n )\n}\n\npub fn compute_note_nonce_and_unique_note_hash(\n siloed_note_hash: Field,\n first_nullifier: Field,\n note_index_in_tx: u32,\n) -> Field {\n let note_nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n compute_unique_note_hash(note_nonce, siloed_note_hash)\n}\n\npub fn compute_siloed_nullifier(contract_address: AztecAddress, nullifier: Field) -> Field {\n poseidon2_hash_with_separator(\n [contract_address.to_field(), nullifier],\n DOM_SEP__SILOED_NULLIFIER,\n )\n}\n\npub fn create_protocol_nullifier(tx_request: TxRequest) -> Scoped<Counted<Nullifier>> {\n // The protocol nullifier is ascribed a special side-effect counter of 1. No other side-effect\n // can have counter 1 (see `validate_as_first_call` for that assertion).\n Nullifier { value: tx_request.hash(), note_hash: 0 }.count(1).scope(\n NULL_MSG_SENDER_CONTRACT_ADDRESS,\n )\n}\n\npub fn compute_siloed_private_log_first_field(\n contract_address: AztecAddress,\n field: Field,\n) -> Field {\n poseidon2_hash_with_separator(\n [contract_address.to_field(), field],\n DOM_SEP__PRIVATE_LOG_FIRST_FIELD,\n )\n}\n\npub fn compute_siloed_private_log(contract_address: AztecAddress, log: PrivateLog) -> PrivateLog {\n let mut fields = log.fields;\n fields[0] = compute_siloed_private_log_first_field(contract_address, fields[0]);\n PrivateLog::new(fields, log.length)\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n poseidon2_hash(log)\n}\n\npub fn compute_app_siloed_secret_key(\n master_secret_key: EmbeddedCurveScalar,\n app_address: AztecAddress,\n key_type_domain_separator: Field,\n) -> Field {\n poseidon2_hash_with_separator(\n [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n key_type_domain_separator,\n )\n}\n\npub fn compute_l2_to_l1_message_hash(\n message: Scoped<L2ToL1Message>,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n let contract_address_bytes: [u8; 32] = message.contract_address.to_field().to_be_bytes();\n let recipient_bytes: [u8; 20] = message.inner.recipient.to_be_bytes();\n let content_bytes: [u8; 32] = message.inner.content.to_be_bytes();\n let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n let mut bytes: [u8; 148] = std::mem::zeroed();\n for i in 0..32 {\n bytes[i] = contract_address_bytes[i];\n bytes[i + 32] = rollup_version_id_bytes[i];\n // 64 - 84 are for recipient.\n bytes[i + 84] = chain_id_bytes[i];\n bytes[i + 116] = content_bytes[i];\n }\n\n for i in 0..20 {\n bytes[64 + i] = recipient_bytes[i];\n }\n\n sha256_to_field(bytes)\n}\n\n// TODO: consider a variant that enables domain separation with a u32 (we seem to have standardised u32s for domain separators)\n/// Computes sha256 hash of 2 input fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256(v0: Field, v1: Field) -> Field {\n // Concatenate two fields into 32 x 2 = 64 bytes\n let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n let hash_input_flattened = v0_as_bytes.concat(v1_as_bytes);\n\n sha256_to_field(hash_input_flattened)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n T: ToField,\n{\n let inputs_with_separator = [separator.to_field()].concat(inputs);\n poseidon2_hash(inputs_with_separator)\n}\n\n/// Computes a Poseidon2 hash over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// The caller is responsible for ensuring that the input is padded with zeros if required.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n sponge.squeeze()\n}\n\n// This function is unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n inputs: BoundedVec<Field, N>,\n separator: T,\n) -> Field\nwhere\n T: ToField,\n{\n let in_len = inputs.len() + 1;\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n sponge.absorb(separator.to_field());\n\n for i in 0..inputs.len() {\n sponge.absorb(inputs.get(i));\n }\n\n sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n let mut fields = [0; (N + 30) / 31];\n let mut field_index = 0;\n let mut current_field = [0; 31];\n for i in 0..inputs.len() {\n let index = i % 31;\n current_field[index] = inputs[i];\n if index == 30 {\n fields[field_index] = field_from_bytes(current_field, false);\n current_field = [0; 31];\n field_index += 1;\n }\n }\n if field_index != fields.len() {\n fields[field_index] = field_from_bytes(current_field, false);\n }\n poseidon2_hash(fields)\n}\n\n#[test]\nfn subarray_hash_matches_fixed() {\n let values_to_hash = [3; 17];\n let padded = values_to_hash.concat([0; 11]);\n let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n // Hash the entire values_to_hash.\n let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(values_to_hash, values_to_hash.len());\n\n assert_eq(subarray_hash, fixed_len_hash);\n}\n\n#[test]\nfn subarray_hash_matches_variable() {\n let values_to_hash = [3; 17];\n let padded = values_to_hash.concat([0; 11]);\n let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n // Hash up to values_to_hash.len() fields of the padded array.\n let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(padded, values_to_hash.len());\n\n assert_eq(subarray_hash, variable_len_hash);\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n let full_buffer = [\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n ];\n let result = sha256_to_field(full_buffer);\n\n assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n let result_bytes = sha256::digest(full_buffer);\n let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n assert(truncated_field == result);\n let mod_res = result + (result_bytes[31] as Field);\n assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn unique_siloed_note_hash_matches_typescript() {\n let inner_note_hash = 1;\n let contract_address = AztecAddress::from_field(2);\n let first_nullifier = 3;\n let note_index_in_tx = 4;\n\n let siloed_note_hash = compute_siloed_note_hash(contract_address, inner_note_hash);\n let siloed_note_hash_from_ts =\n 0x1986a4bea3eddb1fff917d629a13e10f63f514f401bdd61838c6b475db949169;\n assert_eq(siloed_note_hash, siloed_note_hash_from_ts);\n\n let nonce: Field = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n let note_hash_nonce_from_ts =\n 0x28e7799791bf066a57bb51fdd0fbcaf3f0926414314c7db515ea343f44f5d58b;\n assert_eq(nonce, note_hash_nonce_from_ts);\n\n let unique_siloed_note_hash_from_nonce = compute_unique_note_hash(nonce, siloed_note_hash);\n let unique_siloed_note_hash = compute_note_nonce_and_unique_note_hash(\n siloed_note_hash,\n first_nullifier,\n note_index_in_tx,\n );\n assert_eq(unique_siloed_note_hash_from_nonce, unique_siloed_note_hash);\n\n let unique_siloed_note_hash_from_ts =\n 0x29949aef207b715303b24639737c17fbfeb375c1d965ecfa85c7e4f0febb7d16;\n assert_eq(unique_siloed_note_hash, unique_siloed_note_hash_from_ts);\n}\n\n#[test]\nfn siloed_nullifier_matches_typescript() {\n let contract_address = AztecAddress::from_field(123);\n let nullifier = 456;\n\n let res = compute_siloed_nullifier(contract_address, nullifier);\n\n let siloed_nullifier_from_ts =\n 0x169b50336c1f29afdb8a03d955a81e485f5ac7d5f0b8065673d1e407e5877813;\n\n assert_eq(res, siloed_nullifier_from_ts);\n}\n\n#[test]\nfn siloed_private_log_first_field_matches_typescript() {\n let contract_address = AztecAddress::from_field(123);\n let field = 456;\n let res = compute_siloed_private_log_first_field(contract_address, field);\n\n let siloed_private_log_first_field_from_ts =\n 0x29480984f7b9257fded523d50addbcfc8d1d33adcf2db73ef3390a8fd5cdffaa;\n\n assert_eq(res, siloed_private_log_first_field_from_ts);\n}\n\n#[test]\nfn empty_l2_to_l1_message_hash_matches_typescript() {\n // All zeroes\n let res = compute_l2_to_l1_message_hash(\n L2ToL1Message { recipient: EthAddress::zero(), content: 0 }.scope(AztecAddress::from_field(\n 0,\n )),\n 0,\n 0,\n );\n\n let empty_l2_to_l1_msg_hash_from_ts =\n 0x003b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992;\n\n assert_eq(res, empty_l2_to_l1_msg_hash_from_ts);\n}\n\n#[test]\nfn l2_to_l1_message_hash_matches_typescript() {\n let message = L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n AztecAddress::from_field(3),\n );\n let version = 4;\n let chainId = 5;\n\n let hash = compute_l2_to_l1_message_hash(message, version, chainId);\n\n // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n let l2_to_l1_message_hash_from_ts =\n 0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n assert_eq(hash, l2_to_l1_message_hash_from_ts);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n let separator = 42;\n\n // Hash using bounded vec version\n let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n // Hash using regular version\n let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n // Results should match\n assert_eq(bounded_result, regular_result);\n}\n"
|
|
2863
2863
|
},
|
|
2864
2864
|
"391": {
|
|
2865
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(
|
|
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(aztec_utl_log)]\nunconstrained fn log_oracle<let M: u32, let N: u32>(\n log_level: u8,\n msg: str<M>,\n length: u32,\n args: [Field; N],\n) {}\n"
|
|
2867
2867
|
},
|
|
2868
2868
|
"405": {
|
|
2869
2869
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/point.nr",
|
|
@@ -2887,7 +2887,7 @@
|
|
|
2887
2887
|
},
|
|
2888
2888
|
"440": {
|
|
2889
2889
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/type_packing.nr",
|
|
2890
|
-
"source": "use crate::traits::Packable;\n\nglobal BOOL_PACKED_LEN: u32 = 1;\nglobal U8_PACKED_LEN: u32 = 1;\nglobal U16_PACKED_LEN: u32 = 1;\nglobal U32_PACKED_LEN: u32 = 1;\nglobal U64_PACKED_LEN: u32 = 1;\nglobal U128_PACKED_LEN: u32 = 1;\nglobal FIELD_PACKED_LEN: u32 = 1;\nglobal I8_PACKED_LEN: u32 = 1;\nglobal I16_PACKED_LEN: u32 = 1;\nglobal I32_PACKED_LEN: u32 = 1;\nglobal I64_PACKED_LEN: u32 = 1;\n\nimpl Packable for bool {\n let N: u32 = BOOL_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> bool {\n (fields[0] as u1) != 0\n }\n}\n\nimpl Packable for u8 {\n let N: u32 = U8_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u8\n }\n}\n\nimpl Packable for u16 {\n let N: u32 = U16_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u16\n }\n}\n\nimpl Packable for u32 {\n let N: u32 = U32_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u32\n }\n}\n\nimpl Packable for u64 {\n let N: u32 = U64_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u64\n }\n}\n\nimpl Packable for u128 {\n let N: u32 = U128_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u128\n }\n}\n\nimpl Packable for Field {\n let N: u32 = FIELD_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0]\n }\n}\n\nimpl Packable for i8 {\n let N: u32 = I8_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as u8 as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u8 as i8\n }\n}\n\nimpl Packable for i16 {\n let N: u32 = I16_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as u16 as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u16 as i16\n }\n}\n\nimpl Packable for i32 {\n let N: u32 = I32_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as u32 as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u32 as i32\n }\n}\n\nimpl Packable for i64 {\n let N: u32 = I64_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as u64 as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u64 as i64\n }\n}\n\nimpl<T, let M: u32> Packable for [T; M]\nwhere\n T: Packable,\n{\n let N: u32 = M * <T as Packable>::N;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n let mut result: [Field; Self::N] = std::mem::zeroed();\n for i in 0..M {\n let serialized = self[i].pack();\n for j in 0..<T as Packable>::N {\n result[i * <T as Packable>::N + j] = serialized[j];\n }\n }\n result\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n let mut reader = crate::utils::reader::Reader::new(fields);\n let
|
|
2890
|
+
"source": "use crate::traits::Packable;\n\nglobal BOOL_PACKED_LEN: u32 = 1;\nglobal U8_PACKED_LEN: u32 = 1;\nglobal U16_PACKED_LEN: u32 = 1;\nglobal U32_PACKED_LEN: u32 = 1;\nglobal U64_PACKED_LEN: u32 = 1;\nglobal U128_PACKED_LEN: u32 = 1;\nglobal FIELD_PACKED_LEN: u32 = 1;\nglobal I8_PACKED_LEN: u32 = 1;\nglobal I16_PACKED_LEN: u32 = 1;\nglobal I32_PACKED_LEN: u32 = 1;\nglobal I64_PACKED_LEN: u32 = 1;\n\nimpl Packable for bool {\n let N: u32 = BOOL_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> bool {\n (fields[0] as u1) != 0\n }\n}\n\nimpl Packable for u8 {\n let N: u32 = U8_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u8\n }\n}\n\nimpl Packable for u16 {\n let N: u32 = U16_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u16\n }\n}\n\nimpl Packable for u32 {\n let N: u32 = U32_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u32\n }\n}\n\nimpl Packable for u64 {\n let N: u32 = U64_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u64\n }\n}\n\nimpl Packable for u128 {\n let N: u32 = U128_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u128\n }\n}\n\nimpl Packable for Field {\n let N: u32 = FIELD_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0]\n }\n}\n\nimpl Packable for i8 {\n let N: u32 = I8_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as u8 as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u8 as i8\n }\n}\n\nimpl Packable for i16 {\n let N: u32 = I16_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as u16 as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u16 as i16\n }\n}\n\nimpl Packable for i32 {\n let N: u32 = I32_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as u32 as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u32 as i32\n }\n}\n\nimpl Packable for i64 {\n let N: u32 = I64_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as u64 as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u64 as i64\n }\n}\n\nimpl<T, let M: u32> Packable for [T; M]\nwhere\n T: Packable,\n{\n let N: u32 = M * <T as Packable>::N;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n let mut result: [Field; Self::N] = std::mem::zeroed();\n for i in 0..M {\n let serialized = self[i].pack();\n for j in 0..<T as Packable>::N {\n result[i * <T as Packable>::N + j] = serialized[j];\n }\n }\n result\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n let mut reader = crate::utils::reader::Reader::new(fields);\n let result: [T; M] = std::mem::zeroed();\n reader.read_struct_array::<T, <T as Packable>::N, M>(Packable::unpack, result)\n }\n}\n\n#[test]\nfn test_u16_packing() {\n let a: u16 = 10;\n assert_eq(a, u16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i8_packing() {\n let a: i8 = -10;\n assert_eq(a, i8::unpack(a.pack()));\n}\n\n#[test]\nfn test_i16_packing() {\n let a: i16 = -10;\n assert_eq(a, i16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i32_packing() {\n let a: i32 = -10;\n assert_eq(a, i32::unpack(a.pack()));\n}\n\n#[test]\nfn test_i64_packing() {\n let a: i64 = -10;\n assert_eq(a, i64::unpack(a.pack()));\n}\n"
|
|
2891
2891
|
},
|
|
2892
2892
|
"453": {
|
|
2893
2893
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/reader.nr",
|
|
@@ -2903,7 +2903,7 @@
|
|
|
2903
2903
|
},
|
|
2904
2904
|
"5": {
|
|
2905
2905
|
"path": "std/cmp.nr",
|
|
2906
|
-
"source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl<T, let N: u32> Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl<T> Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n if result {\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n }\n result\n }\n}\n\nimpl<let N: u32> Eq for str<N> {\n fn eq(self, other: str<N>) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl<A, B> Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl<A, B, C> Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl<A, B, C, D> Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl<A, B, C, D, E> Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl<T, let N: u32> Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl<T> Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let self_len = self.len();\n let other_len = other.len();\n let min_len = if self_len < other_len {\n self_len\n } else {\n other_len\n };\n\n let mut result = Ordering::equal();\n for i in 0..min_len {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n\n if result != Ordering::equal() {\n result\n } else {\n self_len.cmp(other_len)\n }\n }\n}\n\nimpl<A, B> Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl<A, B, C> Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl<A, B, C, D> Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl<A, B, C, D, E> Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max<T>(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min<T>(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use super::{Eq, max, min, Ord};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0_u64, 1), 0);\n assert_eq(min(0_u64, 0), 0);\n assert_eq(min(1_u64, 1), 1);\n assert_eq(min(255_u8, 0), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0_u64, 1), 1);\n assert_eq(max(0_u64, 0), 0);\n assert_eq(max(1_u64, 1), 1);\n assert_eq(max(255_u8, 0), 255);\n }\n\n #[test]\n fn correctly_handles_unequal_length_vectors() {\n let vector_1 = [0, 1, 2, 3].as_vector();\n let vector_2 = [0, 1, 2].as_vector();\n assert(!vector_1.eq(vector_2));\n }\n\n #[test]\n fn lexicographic_ordering_for_vectors() {\n assert(\n [2_u32].as_vector().cmp([1_u32, 1_u32, 1_u32].as_vector())\n == super::Ordering::greater(),\n );\n assert(\n [1_u32, 2_u32].as_vector().cmp([1_u32, 2_u32, 3_u32].as_vector())\n == super::Ordering::less(),\n );\n }\n}\n"
|
|
2906
|
+
"source": "use crate::meta::ctstring::AsCtString;\nuse crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl<T, let N: u32> Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl<T> Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n if result {\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n }\n result\n }\n}\n\nimpl<let N: u32> Eq for str<N> {\n fn eq(self, other: str<N>) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\ncomptime fn make_tuple_eq_body(n: u32) -> Quoted {\n let mut body = f\"self.0.eq(other.0)\".as_ctstring();\n for i in 1u32..n {\n body = body.append_fmtstr(f\" & self.{i}.eq(other.{i})\");\n }\n f\"{body}\".quoted_contents()\n}\n\nimpl<A: Eq, B: Eq> Eq for (A, B) {\n fn eq(self, other: (A, B)) -> bool {\n make_tuple_eq_body!(2u32)\n }\n}\n\nimpl<A: Eq, B: Eq, C: Eq> Eq for (A, B, C) {\n fn eq(self, other: (A, B, C)) -> bool {\n make_tuple_eq_body!(3u32)\n }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq> Eq for (A, B, C, D) {\n fn eq(self, other: (A, B, C, D)) -> bool {\n make_tuple_eq_body!(4u32)\n }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq> Eq for (A, B, C, D, E) {\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n make_tuple_eq_body!(5u32)\n }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq> Eq for (A, B, C, D, E, F) {\n fn eq(self, other: (A, B, C, D, E, F)) -> bool {\n make_tuple_eq_body!(6u32)\n }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq> Eq for (A, B, C, D, E, F, G) {\n fn eq(self, other: (A, B, C, D, E, F, G)) -> bool {\n make_tuple_eq_body!(7u32)\n }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq> Eq for (A, B, C, D, E, F, G, H) {\n fn eq(self, other: (A, B, C, D, E, F, G, H)) -> bool {\n make_tuple_eq_body!(8u32)\n }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq> Eq for (A, B, C, D, E, F, G, H, I) {\n fn eq(self, other: (A, B, C, D, E, F, G, H, I)) -> bool {\n make_tuple_eq_body!(9u32)\n }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq, J: Eq> Eq for (A, B, C, D, E, F, G, H, I, J) {\n fn eq(self, other: (A, B, C, D, E, F, G, H, I, J)) -> bool {\n make_tuple_eq_body!(10u32)\n }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq, J: Eq, K: Eq> Eq for (A, B, C, D, E, F, G, H, I, J, K) {\n fn eq(self, other: (A, B, C, D, E, F, G, H, I, J, K)) -> bool {\n make_tuple_eq_body!(11u32)\n }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq, J: Eq, K: Eq, L: Eq> Eq for (A, B, C, D, E, F, G, H, I, J, K, L) {\n fn eq(self, other: (A, B, C, D, E, F, G, H, I, J, K, L)) -> bool {\n make_tuple_eq_body!(12u32)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl<T, let N: u32> Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl<T> Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let self_len = self.len();\n let other_len = other.len();\n let min_len = if self_len < other_len {\n self_len\n } else {\n other_len\n };\n\n let mut result = Ordering::equal();\n for i in 0..min_len {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n\n if result != Ordering::equal() {\n result\n } else {\n self_len.cmp(other_len)\n }\n }\n}\n\ncomptime fn make_tuple_ord_body(n: u32) -> Quoted {\n let last = n - 1u32;\n let mut body = if last == 1 {\n f\"let result = self.0.cmp(other.0);\".as_ctstring()\n } else {\n f\"let mut result = self.0.cmp(other.0);\".as_ctstring()\n };\n for i in 1u32..last {\n body = body.append_fmtstr(\n f\" if result == Ordering::equal() {{ result = self.{i}.cmp(other.{i}); }}\",\n );\n }\n body = body.append_fmtstr(\n f\" if result != Ordering::equal() {{ result }} else {{ self.{last}.cmp(other.{last}) }}\",\n );\n f\"{body}\".quoted_contents()\n}\n\nimpl<A: Ord, B: Ord> Ord for (A, B) {\n fn cmp(self, other: (A, B)) -> Ordering {\n make_tuple_ord_body!(2u32)\n }\n}\n\nimpl<A: Ord, B: Ord, C: Ord> Ord for (A, B, C) {\n fn cmp(self, other: (A, B, C)) -> Ordering {\n make_tuple_ord_body!(3u32)\n }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord> Ord for (A, B, C, D) {\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n make_tuple_ord_body!(4u32)\n }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord> Ord for (A, B, C, D, E) {\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n make_tuple_ord_body!(5u32)\n }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord> Ord for (A, B, C, D, E, F) {\n fn cmp(self, other: (A, B, C, D, E, F)) -> Ordering {\n make_tuple_ord_body!(6u32)\n }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord> Ord for (A, B, C, D, E, F, G) {\n fn cmp(self, other: (A, B, C, D, E, F, G)) -> Ordering {\n make_tuple_ord_body!(7u32)\n }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord> Ord for (A, B, C, D, E, F, G, H) {\n fn cmp(self, other: (A, B, C, D, E, F, G, H)) -> Ordering {\n make_tuple_ord_body!(8u32)\n }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord> Ord for (A, B, C, D, E, F, G, H, I) {\n fn cmp(self, other: (A, B, C, D, E, F, G, H, I)) -> Ordering {\n make_tuple_ord_body!(9u32)\n }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord, J: Ord> Ord for (A, B, C, D, E, F, G, H, I, J) {\n fn cmp(self, other: (A, B, C, D, E, F, G, H, I, J)) -> Ordering {\n make_tuple_ord_body!(10u32)\n }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord, J: Ord, K: Ord> Ord for (A, B, C, D, E, F, G, H, I, J, K) {\n fn cmp(self, other: (A, B, C, D, E, F, G, H, I, J, K)) -> Ordering {\n make_tuple_ord_body!(11u32)\n }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord, J: Ord, K: Ord, L: Ord> Ord for (A, B, C, D, E, F, G, H, I, J, K, L) {\n fn cmp(self, other: (A, B, C, D, E, F, G, H, I, J, K, L)) -> Ordering {\n make_tuple_ord_body!(12u32)\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max<T>(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min<T>(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use super::{Eq, max, min, Ord};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0_u64, 1), 0);\n assert_eq(min(0_u64, 0), 0);\n assert_eq(min(1_u64, 1), 1);\n assert_eq(min(255_u8, 0), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0_u64, 1), 1);\n assert_eq(max(0_u64, 0), 0);\n assert_eq(max(1_u64, 1), 1);\n assert_eq(max(255_u8, 0), 255);\n }\n\n #[test]\n fn correctly_handles_unequal_length_vectors() {\n let vector_1 = [0, 1, 2, 3].as_vector();\n let vector_2 = [0, 1, 2].as_vector();\n assert(!vector_1.eq(vector_2));\n }\n\n #[test]\n fn lexicographic_ordering_for_vectors() {\n assert(\n [2_u32].as_vector().cmp([1_u32, 1_u32, 1_u32].as_vector())\n == super::Ordering::greater(),\n );\n assert(\n [1_u32, 2_u32].as_vector().cmp([1_u32, 2_u32, 3_u32].as_vector())\n == super::Ordering::less(),\n );\n }\n}\n"
|
|
2907
2907
|
},
|
|
2908
2908
|
"50": {
|
|
2909
2909
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/contract_instance_registry_contract/src/main.nr",
|
|
@@ -2927,11 +2927,11 @@
|
|
|
2927
2927
|
},
|
|
2928
2928
|
"71": {
|
|
2929
2929
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/avm.nr",
|
|
2930
|
-
"source": "//! AVM oracles.\n//!\n//! There are only available during public execution. Calling any of them from a private or utility function will\n//! result in runtime errors.\n\nuse crate::protocol::address::{AztecAddress, EthAddress};\n\npub unconstrained fn address() -> AztecAddress {\n address_opcode()\n}\npub unconstrained fn sender() -> AztecAddress {\n sender_opcode()\n}\npub unconstrained fn transaction_fee() -> Field {\n transaction_fee_opcode()\n}\npub unconstrained fn chain_id() -> Field {\n chain_id_opcode()\n}\npub unconstrained fn version() -> Field {\n version_opcode()\n}\npub unconstrained fn block_number() -> u32 {\n block_number_opcode()\n}\npub unconstrained fn timestamp() -> u64 {\n timestamp_opcode()\n}\npub unconstrained fn min_fee_per_l2_gas() -> u128 {\n min_fee_per_l2_gas_opcode()\n}\npub unconstrained fn min_fee_per_da_gas() -> u128 {\n min_fee_per_da_gas_opcode()\n}\npub unconstrained fn l2_gas_left() -> u32 {\n l2_gas_left_opcode()\n}\npub unconstrained fn da_gas_left() -> u32 {\n da_gas_left_opcode()\n}\npub unconstrained fn is_static_call() -> u1 {\n is_static_call_opcode()\n}\npub unconstrained fn note_hash_exists(note_hash: Field, leaf_index: u64) -> u1 {\n note_hash_exists_opcode(note_hash, leaf_index)\n}\npub unconstrained fn emit_note_hash(note_hash: Field) {\n emit_note_hash_opcode(note_hash)\n}\npub unconstrained fn nullifier_exists(siloed_nullifier: Field) -> u1 {\n nullifier_exists_opcode(siloed_nullifier)\n}\npub unconstrained fn emit_nullifier(nullifier: Field) {\n emit_nullifier_opcode(nullifier)\n}\npub unconstrained fn emit_public_log(message: [Field]) {\n emit_public_log_opcode(message)\n}\npub unconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: u64) -> u1 {\n l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\npub unconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n send_l2_to_l1_msg_opcode(recipient, content)\n}\n\npub unconstrained fn call<let N: u32>(\n l2_gas_allocation: u32,\n da_gas_allocation: u32,\n address: AztecAddress,\n args: [Field; N],\n) {\n call_opcode(l2_gas_allocation, da_gas_allocation, address, N, args)\n}\n\npub unconstrained fn call_static<let N: u32>(\n l2_gas_allocation: u32,\n da_gas_allocation: u32,\n address: AztecAddress,\n args: [Field; N],\n) {\n call_static_opcode(l2_gas_allocation, da_gas_allocation, address, N, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n calldata_copy_opcode(cdoffset, copy_size)\n}\n\n/// `success_copy` is placed immediately after the CALL opcode to get the success value\npub unconstrained fn success_copy() -> bool {\n success_copy_opcode()\n}\n\npub unconstrained fn returndata_size() -> u32 {\n returndata_size_opcode()\n}\n\npub unconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n returndata_copy_opcode(rdoffset, copy_size)\n}\n\n/// The additional prefix is to avoid clashing with the `return` Noir keyword.\npub unconstrained fn avm_return(returndata: [Field]) {\n return_opcode(returndata)\n}\n\n/// This opcode reverts using the exact data given. In general it should only be used to do rethrows, where the revert\n/// data is the same as the original revert data. For normal reverts, use Noir's `assert` which, on top of reverting,\n/// will also add an error selector to the revert data.\npub unconstrained fn revert(revertdata: [Field]) {\n revert_opcode(revertdata)\n}\n\npub unconstrained fn storage_read(storage_slot: Field, contract_address: Field) -> Field {\n storage_read_opcode(storage_slot, contract_address)\n}\n\npub unconstrained fn storage_write(storage_slot: Field, value: Field) {\n storage_write_opcode(storage_slot, value);\n}\n\n#[oracle(
|
|
2930
|
+
"source": "//! AVM oracles.\n//!\n//! There are only available during public execution. Calling any of them from a private or utility function will\n//! result in runtime errors.\n\nuse crate::protocol::address::{AztecAddress, EthAddress};\n\npub unconstrained fn address() -> AztecAddress {\n address_opcode()\n}\npub unconstrained fn sender() -> AztecAddress {\n sender_opcode()\n}\npub unconstrained fn transaction_fee() -> Field {\n transaction_fee_opcode()\n}\npub unconstrained fn chain_id() -> Field {\n chain_id_opcode()\n}\npub unconstrained fn version() -> Field {\n version_opcode()\n}\npub unconstrained fn block_number() -> u32 {\n block_number_opcode()\n}\npub unconstrained fn timestamp() -> u64 {\n timestamp_opcode()\n}\npub unconstrained fn min_fee_per_l2_gas() -> u128 {\n min_fee_per_l2_gas_opcode()\n}\npub unconstrained fn min_fee_per_da_gas() -> u128 {\n min_fee_per_da_gas_opcode()\n}\npub unconstrained fn l2_gas_left() -> u32 {\n l2_gas_left_opcode()\n}\npub unconstrained fn da_gas_left() -> u32 {\n da_gas_left_opcode()\n}\npub unconstrained fn is_static_call() -> u1 {\n is_static_call_opcode()\n}\npub unconstrained fn note_hash_exists(note_hash: Field, leaf_index: u64) -> u1 {\n note_hash_exists_opcode(note_hash, leaf_index)\n}\npub unconstrained fn emit_note_hash(note_hash: Field) {\n emit_note_hash_opcode(note_hash)\n}\npub unconstrained fn nullifier_exists(siloed_nullifier: Field) -> u1 {\n nullifier_exists_opcode(siloed_nullifier)\n}\npub unconstrained fn emit_nullifier(nullifier: Field) {\n emit_nullifier_opcode(nullifier)\n}\npub unconstrained fn emit_public_log(message: [Field]) {\n emit_public_log_opcode(message)\n}\npub unconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: u64) -> u1 {\n l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\npub unconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n send_l2_to_l1_msg_opcode(recipient, content)\n}\n\npub unconstrained fn call<let N: u32>(\n l2_gas_allocation: u32,\n da_gas_allocation: u32,\n address: AztecAddress,\n args: [Field; N],\n) {\n call_opcode(l2_gas_allocation, da_gas_allocation, address, N, args)\n}\n\npub unconstrained fn call_static<let N: u32>(\n l2_gas_allocation: u32,\n da_gas_allocation: u32,\n address: AztecAddress,\n args: [Field; N],\n) {\n call_static_opcode(l2_gas_allocation, da_gas_allocation, address, N, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n calldata_copy_opcode(cdoffset, copy_size)\n}\n\n/// `success_copy` is placed immediately after the CALL opcode to get the success value\npub unconstrained fn success_copy() -> bool {\n success_copy_opcode()\n}\n\npub unconstrained fn returndata_size() -> u32 {\n returndata_size_opcode()\n}\n\npub unconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n returndata_copy_opcode(rdoffset, copy_size)\n}\n\n/// The additional prefix is to avoid clashing with the `return` Noir keyword.\npub unconstrained fn avm_return(returndata: [Field]) {\n return_opcode(returndata)\n}\n\n/// This opcode reverts using the exact data given. In general it should only be used to do rethrows, where the revert\n/// data is the same as the original revert data. For normal reverts, use Noir's `assert` which, on top of reverting,\n/// will also add an error selector to the revert data.\npub unconstrained fn revert(revertdata: [Field]) {\n revert_opcode(revertdata)\n}\n\npub unconstrained fn storage_read(storage_slot: Field, contract_address: Field) -> Field {\n storage_read_opcode(storage_slot, contract_address)\n}\n\npub unconstrained fn storage_write(storage_slot: Field, value: Field) {\n storage_write_opcode(storage_slot, value);\n}\n\n#[oracle(aztec_avm_address)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(aztec_avm_sender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(aztec_avm_transactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(aztec_avm_chainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(aztec_avm_version)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(aztec_avm_blockNumber)]\nunconstrained fn block_number_opcode() -> u32 {}\n\n#[oracle(aztec_avm_timestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(aztec_avm_minFeePerL2Gas)]\nunconstrained fn min_fee_per_l2_gas_opcode() -> u128 {}\n\n#[oracle(aztec_avm_minFeePerDaGas)]\nunconstrained fn min_fee_per_da_gas_opcode() -> u128 {}\n\n#[oracle(aztec_avm_l2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> u32 {}\n\n#[oracle(aztec_avm_daGasLeft)]\nunconstrained fn da_gas_left_opcode() -> u32 {}\n\n#[oracle(aztec_avm_isStaticCall)]\nunconstrained fn is_static_call_opcode() -> u1 {}\n\n#[oracle(aztec_avm_noteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: u64) -> u1 {}\n\n#[oracle(aztec_avm_emitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(aztec_avm_nullifierExists)]\nunconstrained fn nullifier_exists_opcode(siloed_nullifier: Field) -> u1 {}\n\n#[oracle(aztec_avm_emitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n#[oracle(aztec_avm_emitPublicLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(aztec_avm_l1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: u64) -> u1 {}\n\n#[oracle(aztec_avm_sendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(aztec_avm_calldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(aztec_avm_returndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(aztec_avm_returndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(aztec_avm_return)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n#[oracle(aztec_avm_revert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n// While the length parameter might seem unnecessary given that we have N we keep it around because at the AVM bytecode\n// level, we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally take\n// that route.\n#[oracle(aztec_avm_call)]\nunconstrained fn call_opcode<let N: u32>(\n l2_gas_allocation: u32,\n da_gas_allocation: u32,\n address: AztecAddress,\n length: u32,\n args: [Field; N],\n) {}\n\n// While the length parameter might seem unnecessary given that we have N we keep it around because at the AVM bytecode\n// level, we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally take\n// that route.\n#[oracle(aztec_avm_staticCall)]\nunconstrained fn call_static_opcode<let N: u32>(\n l2_gas_allocation: u32,\n da_gas_allocation: u32,\n address: AztecAddress,\n length: u32,\n args: [Field; N],\n) {}\n\n#[oracle(aztec_avm_successCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(aztec_avm_storageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field, contract_address: Field) -> Field {}\n\n#[oracle(aztec_avm_storageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
|
|
2931
2931
|
},
|
|
2932
2932
|
"80": {
|
|
2933
2933
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/nullifiers.nr",
|
|
2934
|
-
"source": "//! Nullifier creation, existence checks, etc.\n\nuse crate::protocol::address::aztec_address::AztecAddress;\n\n/// Notifies the simulator that a nullifier has been created, so that its correct status (pending or settled) can be\n/// determined when reading nullifiers in subsequent private function calls. The first non-revertible nullifier emitted\n/// is also used to compute note nonces.\npub fn notify_created_nullifier(inner_nullifier: Field) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n // call.\n unsafe { notify_created_nullifier_oracle(inner_nullifier) };\n}\n\n#[oracle(
|
|
2934
|
+
"source": "//! Nullifier creation, existence checks, etc.\n\nuse crate::protocol::address::aztec_address::AztecAddress;\n\n/// Notifies the simulator that a nullifier has been created, so that its correct status (pending or settled) can be\n/// determined when reading nullifiers in subsequent private function calls. The first non-revertible nullifier emitted\n/// is also used to compute note nonces.\npub fn notify_created_nullifier(inner_nullifier: Field) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n // call.\n unsafe { notify_created_nullifier_oracle(inner_nullifier) };\n}\n\n#[oracle(aztec_prv_notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_inner_nullifier: Field) {}\n\n/// Returns true if the nullifier has been emitted in the same transaction, i.e. if [notify_created_nullifier] has been\n/// called for this inner nullifier from the contract with the specified address.\n///\n/// Note that despite sharing pending transaction information with the app, this is not a privacy leak: anyone in the\n/// network can always determine in which transaction a inner nullifier was emitted by a given contract by simply\n/// inspecting transaction effects. What _would_ constitute a leak would be to share the list of inner pending\n/// nullifiers, as that would reveal their preimages.\npub unconstrained fn is_nullifier_pending(\n inner_nullifier: Field,\n contract_address: AztecAddress,\n) -> bool {\n is_nullifier_pending_oracle(inner_nullifier, contract_address)\n}\n\n#[oracle(aztec_prv_isNullifierPending)]\nunconstrained fn is_nullifier_pending_oracle(\n _inner_nullifier: Field,\n _contract_address: AztecAddress,\n) -> bool {}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before\n/// the current transaction is included in a block. While this might seem of little use at first, certain design\n/// patterns benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n check_nullifier_exists_oracle(inner_nullifier)\n}\n\n#[oracle(aztec_utl_checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> bool {}\n"
|
|
2935
2935
|
},
|
|
2936
2936
|
"82": {
|
|
2937
2937
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/state_vars/delayed_public_mutable.nr",
|