From 42d07b52b1d86914aa1cfa46c1c8dd919b70eb0e Mon Sep 17 00:00:00 2001 From: Oleksandr Zarudnyi Date: Thu, 4 Apr 2024 16:43:27 +0800 Subject: [PATCH] Final sync with the private repo --- Cargo.lock | 199 ++++++++++------- Cargo.toml | 1 + LLVM.lock | 4 + README.md | 16 ++ compiler_tester/Cargo.toml | 5 + compiler_tester/src/compilers/eravm.rs | 9 + compiler_tester/src/compilers/llvm.rs | 9 + compiler_tester/src/compilers/solidity/mod.rs | 1 + compiler_tester/src/compilers/yul.rs | 9 + .../src/directories/ethereum/test.rs | 4 +- compiler_tester/src/lib.rs | 38 ++-- .../src/vm/eravm/system_contracts.rs | 8 +- configs/solc-bin-default.json | 6 + configs/solc-bin-zkevm-candidate-0.8.25.json | 16 ++ configs/solc-bin-zkevm-reference-0.8.25.json | 16 ++ fuzz/.gitignore | 4 + fuzz/Cargo.toml | 38 ++++ fuzz/README.md | 52 +++++ fuzz/fuzz_contracts/demo/demo.md | 119 ++++++++++ fuzz/fuzz_contracts/demo/demo.sol | 11 + .../optimizer_bug/optimizer_bug.sol | 8 + fuzz/fuzz_targets/common.rs | 208 ++++++++++++++++++ fuzz/fuzz_targets/demo.rs | 31 +++ fuzz/fuzz_targets/optimizer_bug.rs | 32 +++ solidity | 2 +- solidity_adapter/src/lib.rs | 4 +- .../test/function_call/parser/lexical/mod.rs | 6 +- .../parser/lexical/token/lexeme/keyword.rs | 4 + .../src/test/function_call/parser/mod.rs | 4 +- .../test/function_call/parser/syntax/mod.rs | 2 +- .../parser/syntax/parser/event.rs | 10 +- .../function_call/parser/syntax/parser/gas.rs | 22 +- system-contracts-stable-build | Bin 406907 -> 443410 bytes tests | 2 +- 34 files changed, 780 insertions(+), 120 deletions(-) create mode 100644 configs/solc-bin-zkevm-candidate-0.8.25.json create mode 100644 configs/solc-bin-zkevm-reference-0.8.25.json create mode 100644 fuzz/.gitignore create mode 100644 fuzz/Cargo.toml create mode 100644 fuzz/README.md create mode 100644 fuzz/fuzz_contracts/demo/demo.md create mode 100644 fuzz/fuzz_contracts/demo/demo.sol create mode 100644 fuzz/fuzz_contracts/optimizer_bug/optimizer_bug.sol create mode 100644 fuzz/fuzz_targets/common.rs create mode 100644 fuzz/fuzz_targets/demo.rs create mode 100644 fuzz/fuzz_targets/optimizer_bug.rs diff --git a/Cargo.lock b/Cargo.lock index a167fa83..7b610881 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -19,18 +19,24 @@ checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe" [[package]] name = "aho-corasick" -version = "1.1.2" +version = "1.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0" +checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" dependencies = [ "memchr", ] [[package]] name = "anyhow" -version = "1.0.80" +version = "1.0.81" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ad32ce52e4161730f7098c077cd2ed6229b5804ccf99e5366be1ab72a98b4e1" +checksum = "0952808a6c2afd1aa8947271f3a60f1a6763c7b912d210184c5149b5cf147247" + +[[package]] +name = "arbitrary" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d5a26814d8dcb93b0e5a0ff3c6d80a8843bafb21b39e8e18a6f05471870e110" [[package]] name = "arrayvec" @@ -57,20 +63,20 @@ checksum = "3c87f3f15e7794432337fc718554eaa4dc8f04c9677a950ffe366f20a162ae42" dependencies = [ "proc-macro2", "quote", - "syn 2.0.52", + "syn 2.0.58", ] [[package]] name = "autocfg" -version = "1.1.0" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" +checksum = "f1fdabc7756949593fe60f30ec81974b613357de856987752631dea1e3394c80" [[package]] name = "backtrace" -version = "0.3.69" +version = "0.3.71" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2089b7e3f35b9dd2d0ed921ead4f6d318c27680d4a5bd167b3ee120edb105837" +checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d" dependencies = [ "addr2line", "cc", @@ -128,9 +134,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "bitflags" -version = "2.4.2" +version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ed570934406eb16438a4e976b1b4500774099c13b8cb96eec99f620f05090ddf" +checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1" dependencies = [ "serde", ] @@ -185,15 +191,19 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" [[package]] name = "bytes" -version = "1.5.0" +version = "1.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223" +checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9" [[package]] name = "cc" version = "1.0.90" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8cd6604a82acf3039f1144f54b8eb34e91ffba622051189e71b781822d5ee1f5" +dependencies = [ + "jobserver", + "libc", +] [[package]] name = "cfg-if" @@ -259,6 +269,21 @@ dependencies = [ "zkevm_tester", ] +[[package]] +name = "compiler-tester-fuzz" +version = "0.0.0" +dependencies = [ + "anyhow", + "compiler-tester", + "era-compiler-llvm-context", + "era-compiler-solidity", + "libfuzzer-sys", + "semver", + "solidity-adapter", + "zkevm-assembly", + "zkevm_tester", +] + [[package]] name = "const-oid" version = "0.9.6" @@ -362,9 +387,9 @@ dependencies = [ [[package]] name = "der" -version = "0.7.8" +version = "0.7.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fffa369a668c8af7dbf8b5e56c9f744fbd399949ed171606040001947de40b1c" +checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0" dependencies = [ "const-oid", "zeroize", @@ -476,7 +501,7 @@ dependencies = [ [[package]] name = "era-compiler-llvm-context" version = "1.4.1" -source = "git+https://github.com/matter-labs/era-compiler-llvm-context?branch=main#f1ae37a655c55ddc9c0bf08f3fbd00f99d38809e" +source = "git+https://github.com/matter-labs/era-compiler-llvm-context?branch=main#7a7d7f8d1772c558c9dc6543148176700a6d9d51" dependencies = [ "anyhow", "era-compiler-common", @@ -498,7 +523,7 @@ dependencies = [ [[package]] name = "era-compiler-solidity" version = "1.4.1" -source = "git+https://github.com/matter-labs/era-compiler-solidity?branch=main#25ef5438bcfbf5cfb773214830d56cec52f0aabd" +source = "git+https://github.com/matter-labs/era-compiler-solidity?branch=main#6a2861cc6fb7557bee9a2aa29075c950e9020b34" dependencies = [ "anyhow", "colored", @@ -526,8 +551,8 @@ dependencies = [ [[package]] name = "era-compiler-vyper" -version = "1.4.0" -source = "git+https://github.com/matter-labs/era-compiler-vyper?branch=main#f60d8409b42e8da3f0999e862338f3961045629a" +version = "1.4.1" +source = "git+https://github.com/matter-labs/era-compiler-vyper?branch=main#8c58782c8bb18cbd5abaf0c5bf0ce8f79f3d6444" dependencies = [ "anyhow", "colored", @@ -733,7 +758,7 @@ checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac" dependencies = [ "proc-macro2", "quote", - "syn 2.0.52", + "syn 2.0.58", ] [[package]] @@ -819,9 +844,9 @@ dependencies = [ [[package]] name = "h2" -version = "0.3.24" +version = "0.3.26" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bb2c4422095b67ee78da96fbb51a4cc413b3b25883c7717ff7ca1ab31022c9c9" +checksum = "81fe527a889e1532da5c525686d96d4c2e74cdd345badf8dfef9f6b39dd5f5e8" dependencies = [ "bytes", "fnv", @@ -1046,9 +1071,9 @@ dependencies = [ [[package]] name = "indexmap" -version = "2.2.5" +version = "2.2.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7b0b929d511467233429c45a44ac1dcaa21ba0f5ba11e4879e6ed28ddb4f9df4" +checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26" dependencies = [ "equivalent", "hashbrown", @@ -1095,9 +1120,18 @@ dependencies = [ [[package]] name = "itoa" -version = "1.0.10" +version = "1.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b" + +[[package]] +name = "jobserver" +version = "0.1.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c" +checksum = "ab46a6e9526ddef3ae7f787c06f0f2600639ba80ea3eade3d8e670a2230f51d6" +dependencies = [ + "libc", +] [[package]] name = "js-sys" @@ -1158,6 +1192,17 @@ version = "0.2.153" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd" +[[package]] +name = "libfuzzer-sys" +version = "0.4.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a96cfd5557eb82f2b83fed4955246c988d331975a002961b07c81584d107e7f7" +dependencies = [ + "arbitrary", + "cc", + "once_cell", +] + [[package]] name = "libmath" version = "0.2.1" @@ -1219,9 +1264,9 @@ checksum = "490cc448043f947bae3cbee9c203358d62dbee0db12107a74be5c30ccfd09771" [[package]] name = "memchr" -version = "2.7.1" +version = "2.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149" +checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d" [[package]] name = "mimalloc" @@ -1367,7 +1412,7 @@ dependencies = [ "proc-macro-crate 1.3.1", "proc-macro2", "quote", - "syn 2.0.52", + "syn 2.0.58", ] [[package]] @@ -1463,14 +1508,14 @@ checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965" dependencies = [ "proc-macro2", "quote", - "syn 2.0.52", + "syn 2.0.58", ] [[package]] name = "pin-project-lite" -version = "0.2.13" +version = "0.2.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58" +checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02" [[package]] name = "pin-utils" @@ -1553,9 +1598,9 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.78" +version = "1.0.79" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2422ad645d89c99f8f3e6b88a9fdeca7fabeac836b1002371c4367c8f984aae" +checksum = "e835ff2298f5721608eb1a980ecaee1aef2c132bf95ecc026a11b7bf3c01c02e" dependencies = [ "unicode-ident", ] @@ -1654,9 +1699,9 @@ dependencies = [ [[package]] name = "rayon" -version = "1.9.0" +version = "1.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e4963ed1bc86e4f3ee217022bd855b297cef07fb9eac5dfa1f788b220b49b3bd" +checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa" dependencies = [ "either", "rayon-core", @@ -1692,9 +1737,9 @@ dependencies = [ [[package]] name = "regex" -version = "1.10.3" +version = "1.10.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15" +checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c" dependencies = [ "aho-corasick", "memchr", @@ -1715,15 +1760,15 @@ dependencies = [ [[package]] name = "regex-syntax" -version = "0.8.2" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f" +checksum = "adad44e29e4c806119491a7f06f03de4d1af22c3a680dd47f1e6e179439d1f56" [[package]] name = "reqwest" -version = "0.11.25" +version = "0.11.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0eea5a9eb898d3783f17c6407670e3592fd174cb81a10e51d4c37f49450b9946" +checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62" dependencies = [ "base64", "bytes", @@ -1802,7 +1847,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b91f7eff05f748767f183df4320a63d6936e9c6107d97c9e6bdd9784f4289c94" dependencies = [ "base64", - "bitflags 2.4.2", + "bitflags 2.5.0", "serde", "serde_derive", ] @@ -1830,11 +1875,11 @@ dependencies = [ [[package]] name = "rustix" -version = "0.38.31" +version = "0.38.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6ea3e1a662af26cd7a3ba09c0297a31af215563ecf42817c98df621387f4e949" +checksum = "65e04861e65f21776e67888bfbea442b3642beaa0138fdb1dd7a84a52dffdb89" dependencies = [ - "bitflags 2.4.2", + "bitflags 2.5.0", "errno", "libc", "linux-raw-sys", @@ -1880,9 +1925,9 @@ checksum = "e86697c916019a8588c99b5fac3cead74ec0b4b819707a682fd4d23fa0ce1ba1" [[package]] name = "scale-info" -version = "2.10.0" +version = "2.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f7d66a1128282b7ef025a8ead62a4a9fcf017382ec53b8ffbf4d7bf77bd3c60" +checksum = "788745a868b0e751750388f4e6546eb921ef714a4317fa6954f7cde114eb2eb7" dependencies = [ "bitvec", "cfg-if", @@ -1893,9 +1938,9 @@ dependencies = [ [[package]] name = "scale-info-derive" -version = "2.10.0" +version = "2.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "abf2c68b89cafb3b8d918dd07b42be0da66ff202cf1155c5739a4e0c1ea0dc19" +checksum = "7dc2f4e8bc344b9fc3d5f74f72c2e55bfc38d28dc2ebc69c194a3df424e4d9ac" dependencies = [ "proc-macro-crate 1.3.1", "proc-macro2", @@ -1977,14 +2022,14 @@ checksum = "7eb0b34b42edc17f6b7cac84a52a1c5f0e1bb2227e997ca9011ea3dd34e8610b" dependencies = [ "proc-macro2", "quote", - "syn 2.0.52", + "syn 2.0.58", ] [[package]] name = "serde_json" -version = "1.0.114" +version = "1.0.115" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c5f09b1bd632ef549eaa9f60a1f8de742bdbc698e6cee2095fc84dde5f549ae0" +checksum = "12dc5c46daa8e9fdf4f5e71b6cf9a53f2487da0e86e55808e2d35539666497dd" dependencies = [ "itoa", "ryu", @@ -2015,9 +2060,9 @@ dependencies = [ [[package]] name = "serde_yaml" -version = "0.9.32" +version = "0.9.34+deprecated" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8fd075d994154d4a774f95b51fb96bdc2832b0ea48425c92546073816cda1f2f" +checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47" dependencies = [ "indexmap", "itoa", @@ -2079,9 +2124,9 @@ dependencies = [ [[package]] name = "smallvec" -version = "1.13.1" +version = "1.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e6ecd384b10a64542d77071bd64bd7b231f4ed5940fba55e98c3de13824cf3d7" +checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67" [[package]] name = "socket2" @@ -2187,9 +2232,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.52" +version = "2.0.58" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b699d15b36d1f02c3e7c69f8ffef53de37aefae075d8488d4ba1a7788d574a07" +checksum = "44cfb93f38070beee36b3fef7d4f5a16f27751d94b187b666a5cc5e9b0d30687" dependencies = [ "proc-macro2", "quote", @@ -2204,20 +2249,20 @@ checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160" [[package]] name = "system-configuration" -version = "0.6.0" +version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "658bc6ee10a9b4fcf576e9b0819d95ec16f4d2c02d39fd83ac1c8789785c4a42" +checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7" dependencies = [ - "bitflags 2.4.2", + "bitflags 1.3.2", "core-foundation", "system-configuration-sys", ] [[package]] name = "system-configuration-sys" -version = "0.6.0" +version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4" +checksum = "a75fb188eb626b924683e3b95e3a48e63551fcfb51949de2f06a9d91dbee93c9" dependencies = [ "core-foundation-sys", "libc", @@ -2249,22 +2294,22 @@ dependencies = [ [[package]] name = "thiserror" -version = "1.0.57" +version = "1.0.58" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e45bcbe8ed29775f228095caf2cd67af7a4ccf756ebff23a306bf3e8b47b24b" +checksum = "03468839009160513471e86a034bb2c5c0e4baae3b43f79ffc55c4a5427b3297" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "1.0.57" +version = "1.0.58" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a953cb265bef375dae3de6663da4d3804eee9682ea80d8e2542529b73c531c81" +checksum = "c61f3ba182994efc43764a46c018c347bc492c79f024e705f46567b418f6d4f7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.52", + "syn 2.0.58", ] [[package]] @@ -2293,9 +2338,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" [[package]] name = "tokio" -version = "1.36.0" +version = "1.37.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "61285f6515fa018fb2d1e46eb21223fff441ee8db5d0f1435e8ab4f5cdb80931" +checksum = "1adbebffeca75fcfd058afa480fb6c0b81e165a0323f9c9d39c9697e37c46787" dependencies = [ "backtrace", "bytes", @@ -2383,7 +2428,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.52", + "syn 2.0.58", ] [[package]] @@ -2454,9 +2499,9 @@ checksum = "e51733f11c9c4f72aa0c160008246859e340b00807569a0da0e7a1079b27ba85" [[package]] name = "unsafe-libyaml" -version = "0.2.10" +version = "0.2.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab4c90930b95a82d00dc9e9ac071b4991924390d46cbd0dfe566148667605e4b" +checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861" [[package]] name = "untrusted" @@ -2523,7 +2568,7 @@ dependencies = [ "once_cell", "proc-macro2", "quote", - "syn 2.0.52", + "syn 2.0.58", "wasm-bindgen-shared", ] @@ -2557,7 +2602,7 @@ checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.52", + "syn 2.0.58", "wasm-bindgen-backend", "wasm-bindgen-shared", ] @@ -2876,7 +2921,7 @@ name = "zkevm_opcode_defs" version = "1.4.1" source = "git+https://github.com/matter-labs/era-zkevm_opcode_defs?branch=v1.4.1#ba8228ff0582d21f64d6a319d50d0aec48e9e7b6" dependencies = [ - "bitflags 2.4.2", + "bitflags 2.5.0", "blake2", "ethereum-types", "k256", diff --git a/Cargo.toml b/Cargo.toml index b6cba5bd..064aa885 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,5 +4,6 @@ members = [ "solidity_adapter", "coverage_watcher", "benchmark_analyzer", + "fuzz" ] resolver = "2" diff --git a/LLVM.lock b/LLVM.lock index e59e9c5e..d400a48b 100644 --- a/LLVM.lock +++ b/LLVM.lock @@ -1,2 +1,6 @@ url = "https://github.com/matter-labs/era-compiler-llvm" +<<<<<<< HEAD branch = "v1.4.1" +======= +branch = "main" +>>>>>>> d020375 (Final sync with the private repo) diff --git a/README.md b/README.md index 35afb3cf..bdb9efc7 100644 --- a/README.md +++ b/README.md @@ -129,7 +129,11 @@ Use: - Yul optimizations enabled (`+`) - level 3 optimizations in LLVM middle-end (`M3`) - level 3 optimizations in LLVM back-end (`B3`) +<<<<<<< HEAD - Solidity compiler version (`0.8.24`) +======= +- Solidity compiler version (`0.8.23`) +>>>>>>> d020375 (Final sync with the private repo) Output: @@ -140,7 +144,11 @@ Output: ```bash cargo run --release --bin compiler-tester -- -DT \ --path='tests/solidity/simple/default.sol' \ +<<<<<<< HEAD --mode='Y+M3B3 0.8.24' \ +======= + --mode='Y+M3B3 0.8.23' \ +>>>>>>> d020375 (Final sync with the private repo) --zksolc '../era-compiler-solidity/target/release/zksolc' ``` @@ -191,7 +199,11 @@ zkevm-llvm checkout && zkevm-llvm build ``` ./target/release/compiler-tester \ --path='tests/solidity/simple/default.sol' \ +<<<<<<< HEAD --mode='Y+M^B3 0.8.24' \ +======= + --mode='Y+M^B3 0.8.23' \ +>>>>>>> d020375 (Final sync with the private repo) --benchmark='reference.json' ``` @@ -204,7 +216,11 @@ zkevm-llvm checkout && zkevm-llvm build ``` ./target/release/compiler-tester \ --path='tests/solidity/simple/default.sol' \ +<<<<<<< HEAD --mode='Y+M^B3 0.8.24' \ +======= + --mode='Y+M^B3 0.8.23' \ +>>>>>>> d020375 (Final sync with the private repo) --benchmark='candidate.json' ``` diff --git a/compiler_tester/Cargo.toml b/compiler_tester/Cargo.toml index e7f03cb7..10efbdda 100644 --- a/compiler_tester/Cargo.toml +++ b/compiler_tester/Cargo.toml @@ -47,6 +47,11 @@ era-compiler-llvm-context = { git = "https://github.com/matter-labs/era-compiler era-compiler-solidity = { git = "https://github.com/matter-labs/era-compiler-solidity", branch = "main" } era-compiler-vyper = { git = "https://github.com/matter-labs/era-compiler-vyper", branch = "main" } +# era-compiler-common = { path = "../../era-compiler-common" } +# era-compiler-llvm-context = { path = "../../era-compiler-llvm-context" } +# era-compiler-solidity = { path = "../../era-compiler-solidity" } +# era-compiler-vyper = { path = "../../era-compiler-vyper" } + solidity-adapter = { path = "../solidity_adapter" } benchmark-analyzer = { path = "../benchmark_analyzer" } diff --git a/compiler_tester/src/compilers/eravm.rs b/compiler_tester/src/compilers/eravm.rs index fc9e9fd3..50e8da1e 100644 --- a/compiler_tester/src/compilers/eravm.rs +++ b/compiler_tester/src/compilers/eravm.rs @@ -19,6 +19,15 @@ use crate::vm::evm::input::Input as EVMInput; #[allow(non_camel_case_types)] pub struct EraVMCompiler; +impl EraVMCompiler { + /// + /// A shortcut constructor. + /// + pub fn new() -> Self { + Self::default() + } +} + impl Compiler for EraVMCompiler { fn compile_for_eravm( &self, diff --git a/compiler_tester/src/compilers/llvm.rs b/compiler_tester/src/compilers/llvm.rs index 902f452a..94ad2a85 100644 --- a/compiler_tester/src/compilers/llvm.rs +++ b/compiler_tester/src/compilers/llvm.rs @@ -33,6 +33,15 @@ lazy_static::lazy_static! { }; } +impl LLVMCompiler { + /// + /// A shortcut constructor. + /// + pub fn new() -> Self { + Self::default() + } +} + impl Compiler for LLVMCompiler { fn compile_for_eravm( &self, diff --git a/compiler_tester/src/compilers/solidity/mod.rs b/compiler_tester/src/compilers/solidity/mod.rs index 3a84918c..872d3cbc 100644 --- a/compiler_tester/src/compilers/solidity/mod.rs +++ b/compiler_tester/src/compilers/solidity/mod.rs @@ -178,6 +178,7 @@ impl SolidityCompiler { &mode.solc_version, false, false, + None, ); let evm_version = if mode.solc_version == semver::Version::new(0, 8, 24) { diff --git a/compiler_tester/src/compilers/yul.rs b/compiler_tester/src/compilers/yul.rs index 8208185d..97d361fb 100644 --- a/compiler_tester/src/compilers/yul.rs +++ b/compiler_tester/src/compilers/yul.rs @@ -33,6 +33,15 @@ lazy_static::lazy_static! { }; } +impl YulCompiler { + /// + /// A shortcut constructor. + /// + pub fn new() -> Self { + Self::default() + } +} + impl Compiler for YulCompiler { fn compile_for_eravm( &self, diff --git a/compiler_tester/src/directories/ethereum/test.rs b/compiler_tester/src/directories/ethereum/test.rs index b49f874f..ff2671c9 100644 --- a/compiler_tester/src/directories/ethereum/test.rs +++ b/compiler_tester/src/directories/ethereum/test.rs @@ -25,9 +25,9 @@ use crate::vm::AddressPredictorIterator; /// pub struct EthereumTest { /// The index test entity. - index_entity: solidity_adapter::EnabledTest, + pub index_entity: solidity_adapter::EnabledTest, /// The test data. - test: solidity_adapter::Test, + pub test: solidity_adapter::Test, } impl EthereumTest { diff --git a/compiler_tester/src/lib.rs b/compiler_tester/src/lib.rs index a80f364f..26d7dae7 100644 --- a/compiler_tester/src/lib.rs +++ b/compiler_tester/src/lib.rs @@ -27,18 +27,20 @@ use itertools::Itertools; use rayon::iter::IntoParallelIterator; use rayon::iter::ParallelIterator; -use crate::compilers::eravm::EraVMCompiler; -use crate::compilers::llvm::LLVMCompiler; -use crate::compilers::mode::Mode; -use crate::compilers::solidity::SolidityCompiler; -use crate::compilers::vyper::VyperCompiler; -use crate::compilers::yul::YulCompiler; -use crate::compilers::Compiler; -use crate::directories::ethereum::EthereumDirectory; -use crate::directories::matter_labs::MatterLabsDirectory; -use crate::directories::Buildable; -use crate::directories::TestsDirectory; -use crate::vm::eravm::deployers::Deployer as EraVMDeployer; +pub use crate::compilers::eravm::EraVMCompiler; +pub use crate::compilers::llvm::LLVMCompiler; +pub use crate::compilers::mode::solidity::Mode as SolidityMode; +pub use crate::compilers::mode::Mode; +pub use crate::compilers::solidity::SolidityCompiler; +pub use crate::compilers::vyper::VyperCompiler; +pub use crate::compilers::yul::YulCompiler; +pub use crate::compilers::Compiler; +pub use crate::directories::ethereum::test::EthereumTest; +pub use crate::directories::ethereum::EthereumDirectory; +pub use crate::directories::matter_labs::MatterLabsDirectory; +pub use crate::directories::Buildable; +pub use crate::directories::TestsDirectory; +pub use crate::vm::eravm::deployers::Deployer as EraVMDeployer; /// The debug directory path. pub const DEBUG_DIRECTORY: &str = "./debug/"; @@ -56,11 +58,11 @@ type Test = (Arc, Arc, Mode); /// pub struct CompilerTester { /// The summary. - summary: Arc>, + pub summary: Arc>, /// The filters. - filters: Filters, + pub filters: Filters, /// The debug config. - debug_config: Option, + pub debug_config: Option, } impl CompilerTester { @@ -190,9 +192,9 @@ impl CompilerTester { fn all_tests(&self) -> anyhow::Result> { let solidity_compiler = Arc::new(SolidityCompiler::new()); let vyper_compiler = Arc::new(VyperCompiler::new()); - let yul_compiler = Arc::new(YulCompiler); - let llvm_compiler = Arc::new(LLVMCompiler); - let eravm_compiler = Arc::new(EraVMCompiler); + let yul_compiler = Arc::new(YulCompiler::new()); + let llvm_compiler = Arc::new(LLVMCompiler::new()); + let eravm_compiler = Arc::new(EraVMCompiler::new()); let mut tests = Vec::with_capacity(16384); diff --git a/compiler_tester/src/vm/eravm/system_contracts.rs b/compiler_tester/src/vm/eravm/system_contracts.rs index dd20f22a..22a5a349 100644 --- a/compiler_tester/src/vm/eravm/system_contracts.rs +++ b/compiler_tester/src/vm/eravm/system_contracts.rs @@ -230,12 +230,8 @@ impl SystemContracts { yul_file_paths.push(file_path.to_owned()); } let yul_mode = YulMode::new(era_compiler_llvm_context::OptimizerSettings::cycles()).into(); - let mut builds = Self::compile( - YulCompiler, - &yul_mode, - yul_file_paths, - debug_config.clone(), - )?; + let mut builds = + Self::compile(YulCompiler, &yul_mode, yul_file_paths, debug_config.clone())?; let mut solidity_file_paths = Vec::with_capacity(solidity_system_contracts.len() + 1); for (_, path) in solidity_system_contracts.iter() { diff --git a/configs/solc-bin-default.json b/configs/solc-bin-default.json index 6c0700a0..de77783d 100644 --- a/configs/solc-bin-default.json +++ b/configs/solc-bin-default.json @@ -463,6 +463,12 @@ "destination": "./solc-bin/solc-${VERSION}" }, "0.8.24": { + "is_enabled": false, + "protocol": "https", + "source": "https://github.com/matter-labs/era-solidity/releases/download/${VERSION}-1.0.0/solc-${PLATFORM}-${VERSION}-1.0.0", + "destination": "./solc-bin/solc-${VERSION}" + }, + "0.8.25": { "is_enabled": true, "protocol": "https", "source": "https://github.com/matter-labs/era-solidity/releases/download/${VERSION}-1.0.0/solc-${PLATFORM}-${VERSION}-1.0.0", diff --git a/configs/solc-bin-zkevm-candidate-0.8.25.json b/configs/solc-bin-zkevm-candidate-0.8.25.json new file mode 100644 index 00000000..7e331a7f --- /dev/null +++ b/configs/solc-bin-zkevm-candidate-0.8.25.json @@ -0,0 +1,16 @@ +{ + "binaries": { + "0.8.25": { + "is_enabled": true, + "protocol": "file", + "source": "./solc-bin/solc-${VERSION}", + "destination": "./solc-bin/solc-${VERSION}" + } + }, + "platforms": { + "linux-amd64": "linux-amd64", + "linux-arm64": "linux-arm64", + "macos-amd64": "macosx-amd64", + "macos-arm64": "macosx-arm64" + } +} diff --git a/configs/solc-bin-zkevm-reference-0.8.25.json b/configs/solc-bin-zkevm-reference-0.8.25.json new file mode 100644 index 00000000..297ce19e --- /dev/null +++ b/configs/solc-bin-zkevm-reference-0.8.25.json @@ -0,0 +1,16 @@ +{ + "binaries": { + "0.8.25": { + "is_enabled": true, + "protocol": "https", + "source": "https://github.com/matter-labs/era-solidity/releases/download/${VERSION}-1.0.0/solc-${PLATFORM}-${VERSION}-1.0.0", + "destination": "./solc-bin/solc-${VERSION}" + } + }, + "platforms": { + "linux-amd64": "linux-amd64", + "linux-arm64": "linux-arm64", + "macos-amd64": "macosx-amd64", + "macos-arm64": "macosx-arm64" + } +} diff --git a/fuzz/.gitignore b/fuzz/.gitignore new file mode 100644 index 00000000..1a45eee7 --- /dev/null +++ b/fuzz/.gitignore @@ -0,0 +1,4 @@ +target +corpus +artifacts +coverage diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml new file mode 100644 index 00000000..c6c457e6 --- /dev/null +++ b/fuzz/Cargo.toml @@ -0,0 +1,38 @@ +[package] +name = "compiler-tester-fuzz" +version = "0.0.0" +publish = false +edition = "2021" + +[package.metadata] +cargo-fuzz = true + +[dependencies] +libfuzzer-sys = "0.4" +era-compiler-llvm-context = { git = "https://github.com/matter-labs/era-compiler-llvm-context", branch = "main" } +era-compiler-solidity = { git = "https://github.com/matter-labs/era-compiler-solidity", branch = "main" } +zkevm-assembly = { git = "https://github.com/matter-labs/era-zkEVM-assembly", branch = "v1.4.1" } +zkevm_tester = { git = "https://github.com/matter-labs/era-zkevm_tester", branch = "v1.4.1" } +anyhow = "1.0" +semver = { version = "1.0", features = ["serde"] } + +[dependencies.compiler-tester] +path = "../compiler_tester" + +[dependencies.solidity-adapter] +path = "../solidity_adapter" + + +[[bin]] +name = "demo" +path = "fuzz_targets/demo.rs" +test = false +doc = false +bench = false + +[[bin]] +name = "optimizer_bug" +path = "fuzz_targets/optimizer_bug.rs" +test = false +doc = false +bench = false diff --git a/fuzz/README.md b/fuzz/README.md new file mode 100644 index 00000000..065c5cc6 --- /dev/null +++ b/fuzz/README.md @@ -0,0 +1,52 @@ +# Solidity Contracts Fuzzing + +This is the skeleton for Solidity smart contracts fuzzing based on the [Rust fuzz](https://rust-fuzz.github.io/book/introduction.html) engine. + +## Project structure + +The project consists of the following directories: + +- `fuzz_contracts` - Solidity smart contracts to be fuzzed. +- `fuzz_targets` - fuzzing targets definitions. + +### Fuzzing targets + +Each fuzzing target is a separate Rust binary crate and defined in the `fuzz_targets` directory. The `Cargo.toml` file in the root directory contains the dependencies and the configuration for the fuzzing engine. + +For example, the `simple` fuzzing target is defined in the `fuzz_targets/simple.rs` file. The `Cargo.toml` file contains the following section: + +```properties +[[bin]] +name = "simple" +path = "fuzz_targets/simple.rs" +... +``` + +`cargo fuzz add ` command can be used to add a new empty fuzzing target. + +## Running fuzzing + +To run the fuzzing, execute the following command: + +```bash +cargo fuzz run +``` + +## Supported targets + +- [`demo`](./fuzz_contracts/demo/demo.md) - demonstrates the basic fuzzing setup. +- `optimizer_bug` - demonstrates fuzzer finding a bug in the optimizer. + +## Current limitations + +- The current setup uses the fixed hardcoded version of optimization settings (`Y+M3B3`) and `solc` compiler version (`0.8.24`). +- The current targets are using the simplest contracts and fuzzing strategy that mutates only the function arguments. +- The current setup uses only EraVM as the execution engine as well as `EthereumTest` as the test type. + +## Roadmap + +- [ ] Add the ability to specify the optimization settings and compiler versions. +- [ ] Support for more complex contracts (real-life use cases). +- [ ] Support on-the-fly fuzzing function generation. +- [ ] Support mutating of the contract source code with Solidity vocabulary. +- [ ] Support CI execution in OSS Fuzz infrastructure. diff --git a/fuzz/fuzz_contracts/demo/demo.md b/fuzz/fuzz_contracts/demo/demo.md new file mode 100644 index 00000000..60db8469 --- /dev/null +++ b/fuzz/fuzz_contracts/demo/demo.md @@ -0,0 +1,119 @@ +# Demo fuzzing target + +This tutorial demonstrates the basic fuzzing setup for a demo Solidity smart contract. + +As part of this tutorial, we will: + +1. Define a Solidity contract to fuzz. +2. Define a fuzzing target. +3. Run the fuzzing. +4. Analyze the results. + +## 1. Contract to fuzz + +As a demo example, we will use the following simple Solidity contract: + +```solidity +contract test { + function should_always_return_0(uint8 input) public pure returns (uint8) { + if (input == 10) { + return 1; + } + return 0; + } +} +``` + +As you can see, the contract has a single function `should_always_return_0` that returns `1` if the input is `10` and `0` otherwise. Our goal is to fuzz this function and find the "edge case" when the function returns `1`. + +## 2. Defining fuzzing target + +Our Rust fuzzing target will call the `should_always_return_0` function with with the inputs generated by the fuzzer and check if the output is `0`. Our goal is to find the input that will make the function return `1`. + +When we define fuzzing target in the `fuzz_targets/demo.rs` file, we should provide the following: + +1. The input contract file path. +2. The function to fuzz. +3. The input parameter types. +4. The expected output. + +Here is the example of the `FuzzingCase` structure definition for the `fuzz_targets/demo.rs` target: + +```rust +let case = common::FuzzingCase { + contract_path: String::from("fuzz/fuzz_contracts/demo/demo.sol"), + function_name: String::from("should_always_return_0"), + input_types: vec![common::TypeVariant::integer_unsigned(8)], // <-- input types must match the contract function signature + inputs: vec![common::integer_literal(data)], // <-- use the fuzzer input here + expected_output: common::integer_literal(0), // <-- expect the output to be 0 +}; +``` + +It's important that the input types and the expected output are defined correctly to match the contract function signature. Otherwise, the contract function will throw an exception and the fuzzing fails. + +After defining the fuzzing case, we can generate the test and execute it: + +```rust +// Generate fuzzing test +let test = common::gen_fuzzing_test(case).expect("Error: cannot build fuzzing test!"); +// Run test and check the results +let result = common::build_and_run(test).expect("Error: cannot execute fuzzing test!"); +// Check if the test was successful +assert!(result.is_successful()) +``` + +## 3. Running the fuzzing + +To run the fuzzing, execute the following command: + +```bash +cargo fuzz run demo +``` + +The fuzzer will start generating the inputs and running the tests. If the fuzzer finds the input that makes the function return `1`, it will report the test as failed and stops fuzzing. + +## 4. Analyzing the results + +Sooner or later, the fuzzer will find the input that makes the function return `1`. The fuzzer will report the test as failed and stop fuzzing. + +Here is an example of the output: + +```bash +INFO: Running with entropic power schedule (0xFF, 100). +INFO: Seed: 1801896173 +INFO: Loaded 1 modules (1847630 inline 8-bit counters): 1847630 [0x10db478d0, 0x10dd0aa1e), +INFO: Loaded 1 PC tables (1847630 PCs): 1847630 [0x10dd0aa20,0x10f93bf00), +INFO: 24 files found in /Users/abalias/projects/compiler-tester/fuzz/corpus/demo +INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytes +INFO: seed corpus: files: 24 min: 1b max: 4b total: 45b rss: 92Mb +Generating fuzzing test with input 47... +Y+M3B3 0.8.24 PASSED fuzz/fuzz_contracts/demo/demo.sol[#deployer:fuzz/fuzz_contracts/demo/demo.sol:test] (size 864, cycles 1550, gas 1125949) +Y+M3B3 0.8.24 PASSED fuzz/fuzz_contracts/demo/demo.sol[should_always_return_0:1] (cycles 29, gas 348) +Generating fuzzing test with input 39... +Y+M3B3 0.8.24 PASSED fuzz/fuzz_contracts/demo/demo.sol[#deployer:fuzz/fuzz_contracts/demo/demo.sol:test] (size 864, cycles 1550, gas 1125949) +Y+M3B3 0.8.24 PASSED fuzz/fuzz_contracts/demo/demo.sol[should_always_return_0:1] (cycles 29, gas 348) +... ... +Generating fuzzing test with input 10... + Downloading compiler binaries + Finished downloading compiler binaries in 0m00s + Loaded the System Contracts from `system-contracts-stable-build` + Saved the System Contracts to `system-contracts-stable-build` +Y+M3B3 0.8.24 PASSED fuzz/fuzz_contracts/demo/demo.sol[#deployer:fuzz/fuzz_contracts/demo/demo.sol:test] (size 864, cycles 1550, gas 1125949) +Y+M3B3 0.8.24 FAILED fuzz/fuzz_contracts/demo/demo.sol[should_always_return_0:1] (expected ( + return_data: [ + "0x0000000000000000000000000000000000000000000000000000000000000000", + ], + exception: false, + events: [], +), found ( + return_data: [ + "0x0000000000000000000000000000000000000000000000000000000000000001", + ], + exception: false, + events: [], +), calldata 0a1a369d000000000000000000000000000000000000000000000000000000000000000a) +thread '' panicked at fuzz/fuzz_targets/demo.rs:26:5: +assertion failed: result.is_successful() +``` + +As you can see, the fuzzer found the input `10` that makes the function return `1`. The test failed as expected. diff --git a/fuzz/fuzz_contracts/demo/demo.sol b/fuzz/fuzz_contracts/demo/demo.sol new file mode 100644 index 00000000..04ec2125 --- /dev/null +++ b/fuzz/fuzz_contracts/demo/demo.sol @@ -0,0 +1,11 @@ +contract test { + + function should_always_return_0(uint8 input) public pure returns (uint8) { + if (input == 10) { + return 1; + } + return 0; + } + +} +// ---- diff --git a/fuzz/fuzz_contracts/optimizer_bug/optimizer_bug.sol b/fuzz/fuzz_contracts/optimizer_bug/optimizer_bug.sol new file mode 100644 index 00000000..1d2c8a32 --- /dev/null +++ b/fuzz/fuzz_contracts/optimizer_bug/optimizer_bug.sol @@ -0,0 +1,8 @@ +contract test { + function function_to_fuzz(uint8 a, bool b) external pure returns (uint8) { + uint8 c = b ? 1 : 0; + uint8 d = a + c; // this arithmetic incorrectly throws an overflow panic + return b ? c : d; + } +} +// ---- diff --git a/fuzz/fuzz_targets/common.rs b/fuzz/fuzz_targets/common.rs new file mode 100644 index 00000000..bb2463f0 --- /dev/null +++ b/fuzz/fuzz_targets/common.rs @@ -0,0 +1,208 @@ +use std::{ + path::{Path, PathBuf}, + sync::Arc, +}; + +use compiler_tester::{Buildable, EthereumTest, Mode, SolidityCompiler, SolidityMode, Summary}; +pub use solidity_adapter::{ + test::function_call::parser::{ + lexical::token::{ + lexeme::literal::boolean::Boolean as LexicalBooleanLiteral, + lexeme::literal::integer::Integer, location::Location, + }, + syntax::tree::{ + call::builder::Builder as CallBuilder, + identifier::Identifier, + literal::{ + alignment::Alignment, boolean::Literal as BooleanLiteral, + integer::Literal as IntegerLiteral, Literal, + }, + r#type::{variant::Variant as TypeVariant, Type}, + }, + }, + EnabledTest, FunctionCall, +}; + +use era_compiler_solidity::SolcPipeline; + +/// +/// Fuzzing case definition +/// +pub struct FuzzingCase { + // The path to the contract to fuzz + pub contract_path: String, + // The smart contract function name to fuzz + pub function_name: String, + // The function inputs types + pub input_types: Vec, + // The inputs values + pub inputs: Vec, + // The expected output + pub expected_output: Literal, +} + +/// Create an integer literal primitive from input data +/// +/// # Arguments +/// +/// * `data` - The input data +/// +/// # Returns +/// +/// * `Literal` - The integer literal +/// +pub fn integer_literal(data: T) -> Literal { + Literal::Integer(IntegerLiteral::new( + Location::new(), + Integer::new_decimal(data.to_string(), false), + Alignment::default(), + )) +} + +/// Create a boolean literal primitive from input data +/// +/// # Arguments +/// +/// * `data` - boolean input +/// +/// # Returns +/// +/// * `Literal` - The boolean literal +/// +pub fn boolean_literal(data: bool) -> Literal { + Literal::Boolean(BooleanLiteral::new( + Location::new(), + if data { + LexicalBooleanLiteral::True + } else { + LexicalBooleanLiteral::False + }, + Alignment::default(), + )) +} + +/// Build function call from fuzzing data +/// +/// # Arguments +/// +/// * `case` - The fuzzing case +/// +/// # Returns +/// +/// * `FunctionCall` - The function call +/// +pub fn build_function_call(case: FuzzingCase) -> anyhow::Result { + // Initialize function call builder + let mut builder: CallBuilder = CallBuilder::default(); + builder.set_location(Location::new()); + + // Set function name + builder.set_call(Identifier::new(Location::new(), case.function_name.clone())); + // Set input parameter type + for ftype in case.input_types.iter() { + builder.push_types(Type::new(Location::new(), ftype.clone())); + } + + // Set input parameter value + for input in case.inputs.iter() { + builder.push_input(input.clone()); + } + + // Set expected output + builder.push_expected(case.expected_output.clone()); + + // Finalize function call + let call = builder.finish(); + FunctionCall::try_from(call) +} + +/// Generates fuzzing test +/// +/// # Arguments +/// +/// * `test_path` - The path to the test contract +/// * `data` - The fuzzing data +/// +/// # Returns +/// +/// * `EthereumTest` - The Ethereum test +pub fn gen_fuzzing_test(case: FuzzingCase) -> anyhow::Result { + let test_path = Path::new(&case.contract_path); + + // Generate Test objects for the fuzzing contract + let enabled_test = EnabledTest::new(test_path.to_path_buf(), None, None, None); + let mut test = solidity_adapter::Test::try_from(test_path)?; + let fcall = build_function_call(case)?; + test.calls.push(fcall); + Ok(EthereumTest { + index_entity: enabled_test, + test, + }) +} + +/// Build and run the test +/// +/// # Arguments +/// +/// * `test` - The Ethereum test +/// +/// # Returns +/// +/// * `Summary` - The test summary +pub fn build_and_run(test: EthereumTest) -> anyhow::Result { + // TODO: this should be parametrized + let solc_version = semver::Version::new(0, 8, 24); + let mode = Mode::Solidity(SolidityMode::new( + solc_version, + SolcPipeline::Yul, + true, + true, + era_compiler_llvm_context::OptimizerSettings::try_from_cli('3') + .expect("Error: optimization settings incorrect!"), + )); + + // Initialization + era_compiler_llvm_context::initialize_target(era_compiler_llvm_context::Target::EraVM); + era_compiler_solidity::EXECUTABLE.get_or_try_init(|| -> Result { + Ok(PathBuf::from( + era_compiler_solidity::DEFAULT_EXECUTABLE_NAME, + )) + })?; + compiler_tester::LLVMOptions::initialize(false, false)?; + let compiler_tester = compiler_tester::CompilerTester::new( + compiler_tester::Summary::new(true, false).wrap(), + compiler_tester::Filters::new(vec![], vec![], vec![]), + None, + )?; + zkevm_tester::runners::compiler_tests::set_tracing_mode( + zkevm_tester::runners::compiler_tests::VmTracingOptions::from_u64(0), + ); + zkevm_assembly::set_encoding_mode(zkevm_assembly::RunningVmEncodingMode::Testing); + + // Compile and run test + if let Some(test) = test.build_for_eravm( + mode, + Arc::new(SolidityCompiler::new()), + compiler_tester.summary.clone(), + &compiler_tester.filters, + compiler_tester.debug_config.clone(), + ) { + test.run::( + compiler_tester.summary.clone(), + Arc::new(compiler_tester::EraVM::new( + vec![ + PathBuf::from("./configs/solc-bin-default.json"), + PathBuf::from("./configs/vyper-bin-default.json"), + ], + PathBuf::from("./configs/solc-bin-system-contracts.json"), + None, + Some(PathBuf::from("system-contracts-stable-build")), + Some(PathBuf::from("system-contracts-stable-build")), + )?), + ); + } + + // Get the results + let summary = compiler_tester::Summary::unwrap_arc(compiler_tester.summary); + Ok(summary) +} diff --git a/fuzz/fuzz_targets/demo.rs b/fuzz/fuzz_targets/demo.rs new file mode 100644 index 00000000..691a448e --- /dev/null +++ b/fuzz/fuzz_targets/demo.rs @@ -0,0 +1,31 @@ +//! +//! The fuzzer demo. +//! + +#![no_main] + +/// This module contains the fuzzing target for the simple contract. +use libfuzzer_sys::fuzz_target; + +pub(crate) mod common; + +fuzz_target!(|data: u8| { + // Fuzzing case definition + let case = common::FuzzingCase { + contract_path: String::from("fuzz/fuzz_contracts/demo/demo.sol"), + function_name: String::from("should_always_return_0"), + input_types: vec![common::TypeVariant::integer_unsigned(8)], + inputs: vec![common::integer_literal(data)], + expected_output: common::integer_literal(0), + }; + + // Generate fuzzing test + println!("Generating fuzzing test with input {data}..."); + let test = common::gen_fuzzing_test(case).expect("Error: cannot build fuzzing test!"); + + // Run test and check the results + let result = common::build_and_run(test).expect("Error: cannot execute fuzzing test!"); + + // Check if the test was successful + assert!(result.is_successful()) +}); diff --git a/fuzz/fuzz_targets/optimizer_bug.rs b/fuzz/fuzz_targets/optimizer_bug.rs new file mode 100644 index 00000000..8e01dd16 --- /dev/null +++ b/fuzz/fuzz_targets/optimizer_bug.rs @@ -0,0 +1,32 @@ +//! +//! The optimizer bug demo. +//! + +#![no_main] + +use libfuzzer_sys::fuzz_target; + +pub(crate) mod common; + +fuzz_target!(|data: u8| { + // Fuzzing case definition + let case = common::FuzzingCase { + contract_path: String::from("fuzz/fuzz_contracts/optimizer_bug/optimizer_bug.sol"), + function_name: String::from("function_to_fuzz"), + input_types: vec![ + common::TypeVariant::integer_unsigned(8), + common::TypeVariant::boolean(), + ], + inputs: vec![common::integer_literal(data), common::boolean_literal(true)], + expected_output: common::integer_literal(1), + }; + + // Generate fuzzing test + let test = common::gen_fuzzing_test(case).expect("Error: cannot build fuzzing test!"); + + // Run test and check the results + let result = common::build_and_run(test).expect("Error: cannot execute fuzzing test!"); + + // Check if the test was successful + assert!(result.is_successful()) +}); diff --git a/solidity b/solidity index c0ef06c3..6040a521 160000 --- a/solidity +++ b/solidity @@ -1 +1 @@ -Subproject commit c0ef06c362f86e1e35c4663e27913e1cabd3f5e6 +Subproject commit 6040a521021f8168107ced1b54a21625b8cce632 diff --git a/solidity_adapter/src/lib.rs b/solidity_adapter/src/lib.rs index 6c86c190..9e3a0ed2 100644 --- a/solidity_adapter/src/lib.rs +++ b/solidity_adapter/src/lib.rs @@ -2,8 +2,8 @@ //! The Solidity adapter library. //! -pub(crate) mod index; -mod test; +pub mod index; +pub mod test; use std::ops::Add; use std::str::FromStr; diff --git a/solidity_adapter/src/test/function_call/parser/lexical/mod.rs b/solidity_adapter/src/test/function_call/parser/lexical/mod.rs index 1047b449..1d2d9b2a 100644 --- a/solidity_adapter/src/test/function_call/parser/lexical/mod.rs +++ b/solidity_adapter/src/test/function_call/parser/lexical/mod.rs @@ -5,9 +5,9 @@ #[cfg(test)] mod tests; -mod error; -mod stream; -mod token; +pub mod error; +pub mod stream; +pub mod token; pub use self::error::Error; pub use self::stream::TokenStream; diff --git a/solidity_adapter/src/test/function_call/parser/lexical/token/lexeme/keyword.rs b/solidity_adapter/src/test/function_call/parser/lexical/token/lexeme/keyword.rs index afe1da02..83808cf9 100644 --- a/solidity_adapter/src/test/function_call/parser/lexical/token/lexeme/keyword.rs +++ b/solidity_adapter/src/test/function_call/parser/lexical/token/lexeme/keyword.rs @@ -41,6 +41,8 @@ pub enum Keyword { Legacy, /// The `legacyOptimized` keyword. LegacyOptimized, + /// The `code` keyword. + Code, /// The `bool` type keyword. Bool, @@ -153,6 +155,7 @@ impl TryFrom<&str> for Keyword { "irOptimized" => return Ok(Self::IrOptimized), "legacy" => return Ok(Self::Legacy), "legacyOptimized" => return Ok(Self::LegacyOptimized), + "code" => return Ok(Self::Code), "bool" => return Ok(Self::Bool), "string" => return Ok(Self::String), @@ -249,6 +252,7 @@ impl fmt::Display for Keyword { Self::IrOptimized => write!(f, "irOptimized"), Self::Legacy => write!(f, "legacy"), Self::LegacyOptimized => write!(f, "legacyOptimized"), + Self::Code => write!(f, "code"), Self::Bool => write!(f, "bool"), Self::String => write!(f, "string"), diff --git a/solidity_adapter/src/test/function_call/parser/mod.rs b/solidity_adapter/src/test/function_call/parser/mod.rs index e258099a..fc0f8a1e 100644 --- a/solidity_adapter/src/test/function_call/parser/mod.rs +++ b/solidity_adapter/src/test/function_call/parser/mod.rs @@ -2,8 +2,8 @@ //! The Solidity tests metadata parser. //! -mod lexical; -mod syntax; +pub mod lexical; +pub mod syntax; pub use syntax::Call; pub use syntax::CallVariant; diff --git a/solidity_adapter/src/test/function_call/parser/syntax/mod.rs b/solidity_adapter/src/test/function_call/parser/syntax/mod.rs index 661bfdbc..ddfc528c 100644 --- a/solidity_adapter/src/test/function_call/parser/syntax/mod.rs +++ b/solidity_adapter/src/test/function_call/parser/syntax/mod.rs @@ -4,7 +4,7 @@ mod error; mod parser; -mod tree; +pub mod tree; pub use self::parser::Parser; pub use self::tree::call::variant::Variant as CallVariant; diff --git a/solidity_adapter/src/test/function_call/parser/syntax/parser/event.rs b/solidity_adapter/src/test/function_call/parser/syntax/parser/event.rs index d0cbdc17..d600fa5f 100644 --- a/solidity_adapter/src/test/function_call/parser/syntax/parser/event.rs +++ b/solidity_adapter/src/test/function_call/parser/syntax/parser/event.rs @@ -339,25 +339,23 @@ impl Parser { #[cfg(test)] mod tests { + use crate::test::function_call::parser::lexical::token::lexeme::identifier::Identifier as LexicalIdentifier; + use crate::test::function_call::parser::lexical::IntegerLiteral as LexicalIntegerLiteral; use crate::test::function_call::parser::lexical::Lexeme; - use crate::test::function_call::parser::lexical::Location; - - use crate::test::function_call::parser::lexical::IntegerLiteral as LexicalIntegerLiteral; use crate::test::function_call::parser::lexical::Token; use crate::test::function_call::parser::lexical::TokenStream; - - use super::Parser; use crate::test::function_call::parser::syntax::error::Error as SyntaxError; use crate::test::function_call::parser::syntax::error::ParsingError; + use crate::test::function_call::parser::syntax::parser::event::Parser; use crate::test::function_call::parser::syntax::tree::event::literal::EventLiteral; use crate::test::function_call::parser::syntax::tree::event::variant::Variant; use crate::test::function_call::parser::syntax::tree::event::Event; use crate::test::function_call::parser::syntax::tree::literal::alignment::Alignment; + use crate::test::function_call::parser::syntax::tree::literal::integer::Literal as IntegerLiteral; use crate::test::function_call::parser::syntax::tree::literal::Literal; use crate::test::function_call::parser::syntax::tree::r#type::variant::Variant as TypeVariant; use crate::test::function_call::parser::syntax::Identifier; - use crate::test::function_call::parser::syntax::IntegerLiteral; use crate::test::function_call::parser::syntax::Type; #[test] diff --git a/solidity_adapter/src/test/function_call/parser/syntax/parser/gas.rs b/solidity_adapter/src/test/function_call/parser/syntax/parser/gas.rs index 98441b9f..25b7819a 100644 --- a/solidity_adapter/src/test/function_call/parser/syntax/parser/gas.rs +++ b/solidity_adapter/src/test/function_call/parser/syntax/parser/gas.rs @@ -28,6 +28,8 @@ pub enum State { /// The `gas` has been parsed so far. Variant, /// The `gas {variant}` has been parsed so far. + ColonOrCode, + /// The `gas {variant}` has been parsed so far. Colon, /// The `gas {variant}:` has been parsed so far. Value, @@ -93,7 +95,7 @@ impl Parser { .. } => { self.builder.set_keyword(keyword); - self.state = State::Colon; + self.state = State::ColonOrCode; } Token { lexeme, location } => { return Err(SyntaxError::new( @@ -104,6 +106,24 @@ impl Parser { .into()); } }, + State::ColonOrCode => match parser::take_or_next(self.next.take(), stream.clone())? + { + Token { + lexeme: Lexeme::Keyword(Keyword::Code), + .. + } => { + self.state = State::Colon; + } + Token { + lexeme: Lexeme::Symbol(Symbol::Colon), + .. + } => { + self.state = State::Value; + } + Token { lexeme, location } => { + return Err(SyntaxError::new(location, vec!["code", ":"], lexeme).into()); + } + }, State::Colon => match parser::take_or_next(self.next.take(), stream.clone())? { Token { lexeme: Lexeme::Symbol(Symbol::Colon), diff --git a/system-contracts-stable-build b/system-contracts-stable-build index b559b1306c82818ad0f21d0e4f92a8fa6a52f88b..01e0ffd843fad15d6968a5b6a5f785d75c758e68 100644 GIT binary patch delta 98808 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

0)cOf)aPb6A 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

%*A7ZCzJGk>wdji9B^-jkkXAFIdY7~P(jyBZ~ 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 diff --git a/tests b/tests index 102f0fdd..a61b8159 160000 --- a/tests +++ b/tests @@ -1 +1 @@ -Subproject commit 102f0fddf185b9b6eaf1a96ab9c2693c1f05ed56 +Subproject commit a61b815996bc623b5bc4adfe232b418a4253bb5c